Volver a conectar la entrada para garantizar tipos de salida específicos
[La característica asociada a esta página, DirectShow, es una característica heredada. Se ha reemplazado por MediaPlayer, IMFMediaEngine y Captura de audio/vídeo en Media Foundation. Esas características se han optimizado para Windows 10 y Windows 11. Microsoft recomienda encarecidamente que el nuevo código use MediaPlayer, IMFMediaEngine y Audio/Video Capture en Media Foundation en lugar de DirectShow, siempre que sea posible. Microsoft sugiere que el código existente que usa las API heredadas se reescriba para usar las nuevas API si es posible.
Los filtros implementan el método IAMStreamConfig::SetFormat para establecer el formato de audio o vídeo antes de que se conecten las patillas del filtro. Si el pin de salida ya está conectado y puede proporcionar un nuevo tipo, vuelva a conectar el pin, pero solo si el otro filtro puede aceptar el nuevo tipo. Si el otro filtro no puede aceptar el tipo de medio, produzca un error en la llamada a SetFormat y deje la conexión sola.
Es posible que un filtro de transformación no tenga ningún tipo de salida preferido a menos que su pin de entrada esté conectado. En ese caso, los métodos SetFormat e IAMStreamConfig::GetStreamCaps deben devolver VFW_E_NOT_CONNECTED hasta que se conecte el pin de entrada. De lo contrario, estos métodos pueden funcionar como de costumbre.
En ciertos casos resulta útil volver a conectar patillas cuando se ofrece un formato en una conexión establecida. Por ejemplo, supongamos que un filtro puede comprimir vídeo RGB de 24 bits en formato X y que puede comprimir vídeo RGB de 8 bits en formato Y. El pin de salida puede realizar una de las siguientes acciones:
- Ofrezca siempre X e Y en GetStreamCaps y acepte siempre X e Y en SetFormat.
- Ofrezca y acepte solo el formato X si el tipo de entrada es RGB de 24 bits. Ofrezca y acepte solo el formato Y si el tipo de entrada RGB de 8 bits. Se produce un error en ambos métodos si el pin de entrada no está conectado.
En cualquier caso, necesitará código de reconexión similar al siguiente:
HRESULT MyOutputPin::CheckMediaType(const CMediaType *pmtOut)
{
// Fail if the input pin is not connected.
if (!m_pFilter->m_pInput->IsConnected()) {
return VFW_E_NOT_CONNECTED;
}
// (Not shown: Reject any media types that you know in advance your
// filter cannot use. Check the major type and subtype GUIDs.)
// (Not shown: If SetFormat was previously called, check whether
// pmtOut exactly matches the format that was specified in SetFormat.
// Return S_OK if they match, or VFW_E_INVALIDMEDIATYPE otherwise.)
// Now do the normal check for this media type.
HRESULT hr;
hr = m_pFilter->CheckTransform(
&m_pFilter->m_pInput->CurrentMediaType(), // The input type.
pmtOut // The proposed output type.
);
if (hr == S_OK)
{
// This format is compatible with the current input type.
return S_OK;
}
// This format is not compatible with the current input type.
// Maybe we can reconnect the input pin with a new input type.
// Enumerate the upstream filter's preferred output types, and
// see if one of them will work.
CMediaType *pmtEnum;
BOOL fFound = FALSE;
IEnumMediaTypes *pEnum;
hr = m_pFilter->m_pInput->GetConnected()->EnumMediaTypes(&pEnum);
if (hr != S_OK)
{
return E_FAIL;
}
while (hr = pEnum->Next(1, (AM_MEDIA_TYPE **)&pmtEnum, NULL), hr == S_OK)
{
// Check this input type against the proposed output type.
hr = m_pFilter->CheckTransform(pmtEnum, pmtOut);
if (hr != S_OK)
{
DeleteMediaType(pmtEnum);
continue; // Try the next one.
}
// This input type is a possible candidate. But, we have to make
// sure that the upstream filter can switch to this type.
hr = m_pFilter->m_pInput->GetConnected()->QueryAccept(pmtEnum);
if (hr != S_OK)
{
// The upstream filter will not switch to this type.
DeleteMediaType(pmtEnum);
continue; // Try the next one.
}
fFound = TRUE;
DeleteMediaType(pmtEnum);
break;
}
pEnum->Release();
if (fFound)
{
// This output type is OK, but if we are asked to use it, we will
// need to reconnect our input pin. (See SetFormat, below.)
return S_OK;
}
else
{
return VFW_E_INVALIDMEDIATYPE;
}
}
HRESULT MyOutputPin::SetFormat(AM_MEDIA_TYPE *pmt)
{
CheckPointer(pmt, E_POINTER);
HRESULT hr;
// Hold the filter state lock, to make sure that streaming isn't
// in the middle of starting or stopping:
CAutoLock cObjectLock(&m_pFilter->m_csFilter);
// Cannot set the format unless the filter is stopped.
if (m_pFilter->m_State != State_Stopped)
{
return VFW_E_NOT_STOPPED;
}
// The set of possible output formats depends on the input format,
// so if the input pin is not connected, return a failure code.
if (!m_pFilter->m_pInput->IsConnected())
{
return VFW_E_NOT_CONNECTED;
}
// If the pin is already using this format, there's nothing to do.
if (IsConnected() && CurrentMediaType() == *pmt)
{
return S_OK;
}
// See if this media type is acceptable.
if ((hr = CheckMediaType((CMediaType *)pmt)) != S_OK)
{
return hr;
}
// If we're connected to a downstream filter, we have to make
// sure that the downstream filter accepts this media type.
if (IsConnected())
{
hr = GetConnected()->QueryAccept(pmt);
if (hr != S_OK)
{
return VFW_E_INVALIDMEDIATYPE;
}
}
// Now make a note that from now on, this is the only format allowed,
// and refuse anything but this in the CheckMediaType code above.
// Changing the format means reconnecting if necessary.
if (IsConnected())
{
m_pFilter->m_pGraph->Reconnect(this);
}
return NOERROR;
}
// Override CTransformFilter::SetMediaType to reconnect the input pin.
// This method is called immediately after the media type is set on a pin.
HRESULT MyFilter::SetMediaType(
PIN_DIRECTION direction,
const CMediaType *pmt
)
{
HRESULT hr;
if (direction == PINDIR_OUTPUT)
{
// Before we set the output type, we might need to reconnect
// the input pin with a new type.
if (m_pInput && m_pInput->IsConnected())
{
// Check if the current input type is compatible.
hr = CheckTransform(
&m_pInput->CurrentMediaType(),
&m_pOutput->CurrentMediaType());
if (SUCCEEDED(hr))
{
return S_OK;
}
// Otherwise, we need to reconnect the input pin.
// Note: The CheckMediaType method has already called
// QueryAccept on the upstream filter.
hr = m_pGraph->Reconnect(m_pInput);
return hr;
}
}
return S_OK;
}