Reconnexion de votre entrée pour garantir des types de sortie spécifiques
[La fonctionnalité associée à cette page, DirectShow, est une fonctionnalité héritée. Il a été remplacé par MediaPlayer, IMFMediaEngine et Audio/Video Capture in Media Foundation. Ces fonctionnalités ont été optimisées pour Windows 10 et Windows 11. Microsoft recommande vivement que le nouveau code utilise MediaPlayer, IMFMediaEngine et Audio/Video Capture dans Media Foundation au lieu de DirectShow, si possible. Microsoft suggère que le code existant qui utilise les API héritées soit réécrit pour utiliser les nouvelles API si possible.]
Les filtres implémentent la méthode IAMStreamConfig::SetFormat pour définir le format audio ou vidéo avant la connexion des broches du filtre. Si votre broche de sortie est déjà connectée et que vous pouvez fournir un nouveau type, reconnectez-la, mais uniquement si l’autre filtre peut accepter le nouveau type. Si l’autre filtre ne peut pas accepter le type de média, échouez l’appel à SetFormat et laissez votre connexion seule.
Un filtre de transformation ne peut avoir aucun type de sortie préféré, sauf si sa broche d’entrée est connectée. Dans ce cas, les méthodes SetFormat et IAMStreamConfig::GetStreamCaps doivent retourner VFW_E_NOT_CONNECTED jusqu’à ce que la broche d’entrée soit connectée. Sinon, ces méthodes peuvent fonctionner comme d’habitude.
Dans certains cas, il est utile de reconnecter des broches lorsque vous proposez un format sur une connexion établie. Par exemple, supposons qu’un filtre puisse compresser une vidéo RVB 24 bits au format X et qu’il puisse compresser la vidéo RVB 8 bits au format Y. La broche de sortie peut effectuer l’une des opérations suivantes :
- Proposez toujours X et Y dans GetStreamCaps, et acceptez toujours X et Y dans SetFormat.
- Proposez et acceptez simplement le format X si le type d’entrée est RVB 24 bits. Proposez et acceptez simplement le format Y si le type d’entrée RVB 8 bits. Échec des deux méthodes si la broche d’entrée n’est pas connectée.
Dans les deux cas, vous aurez besoin d’un code de reconnexion qui ressemble à ceci :
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;
}