Contrôle d’un graphe de capture

[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.]

L’interface IMediaControl du Gestionnaire de graphes de filtres dispose de méthodes permettant d’exécuter, d’arrêter et de suspendre l’ensemble du graphique. Toutefois, si le graphique de filtre contient des flux de capture et d’aperçu, vous souhaiterez probablement contrôler les deux flux indépendamment. Par exemple, vous souhaiterez peut-être afficher un aperçu de la vidéo sans la capturer. Pour ce faire, utilisez la méthode ICaptureGraphBuilder2::ControlStream .

Notes

Cette méthode ne fonctionne pas lors de la capture dans un fichier ASF (Advanced Systems Format).

 

Contrôle du flux de capture

Le code suivant définit l’exécution du flux de capture vidéo pendant quatre secondes, en commençant une seconde après l’exécution du graphique :

// Control the video capture stream. 
REFERENCE_TIME rtStart = 10000000, rtStop = 50000000;
const WORD wStartCookie = 1, wStopCookie = 2;  // Arbitrary values.
hr = pBuild->ControlStream(
    &PIN_CATEGORY_CAPTURE, // Pin category.
    &MEDIATYPE_Video,      // Media type.
    pCap,                 // Capture filter.
    &rtStart, &rtStop,     // Start and stop times.
    wStartCookie, wStopCookie  // Values for the start and stop events.
);
pControl->Run();

Le premier paramètre spécifie le flux à contrôler, en tant que GUID de catégorie d’épingle. Le deuxième paramètre donne le type de média. Le troisième paramètre est un pointeur vers le filtre de capture. Pour contrôler tous les flux de capture dans le graphique, définissez les deuxième et troisième paramètres sur NULL.

Les deux paramètres suivants définissent les heures de démarrage et d’arrêt du flux, par rapport à l’heure à laquelle le graphique commence à s’exécuter. Appelez IMediaControl::Run pour exécuter le graphique. Tant que vous n’avez pas exécuté le graphique, la méthode ControlStream n’a aucun effet. Si le graphique est déjà en cours d’exécution, les paramètres prennent effet immédiatement.

Les deux derniers paramètres sont utilisés pour recevoir des notifications d’événements lorsque le flux démarre et s’arrête. Pour chaque flux que vous contrôlez à l’aide de cette méthode, le graphique de filtre envoie une paire d’événements : EC_STREAM_CONTROL_STARTED au démarrage du flux et EC_STREAM_CONTROL_STOPPED lorsque le flux s’arrête. Les valeurs de wStartCookie et wStopCookie sont utilisées comme deuxième paramètre d’événement. Ainsi, lParam2 dans l’événement start est égal à wStartCookie, et lParam2 dans l’événement stop est égal à wStopCookie. Le code suivant montre comment obtenir ces événements :

while (hr = pEvent->GetEvent(&evCode, &param1, &param2, 0), SUCCEEDED(hr))
{
    switch (evCode)
    {
    case EC_STREAM_CONTROL_STARTED: 
    // param2 == wStartCookie
    break;

    case EC_STREAM_CONTROL_STOPPED: 
    // param2 == wStopCookie
    break;
    
    } 
    pEvent->FreeEventParams(evCode, param1, param2);
}

La méthode ControlStream définit des valeurs spéciales pour les heures de début et d’arrêt.

Valeur	Démarrer	Arrêter
MAXLONGLONG	Ne démarrez jamais ce flux.	Ne vous arrêtez pas tant que le graphique n’est pas arrêté.
NULL	Démarrez immédiatement lorsque le graphique s’exécute.	Arrêtez immédiatement.

 

Par exemple, le code suivant arrête immédiatement le flux de capture :

pBuild->ControlStream(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, pCap,
    0, 0,     // Start and stop times.
    wStartCookie, wStopCookie); 

Bien que vous puissiez arrêter le flux de capture et le redémarrer ultérieurement, cela crée un écart dans les horodatages. Lors de la lecture, la vidéo semble se bloquer pendant l’intervalle (en fonction du format de fichier).

Contrôle du flux d’aperçu

Pour contrôler l’épingle d’aperçu, appelez ControlStream , mais définissez le premier paramètre sur PIN_CATEGORY_PREVIEW. Cela fonctionne de la même façon que pour PIN_CATEGORY_CAPTURE, sauf que vous ne pouvez pas utiliser les heures de référence pour spécifier le début et l’arrêt, car les images d’aperçu n’ont pas d’horodatages. Par conséquent, vous devez utiliser NULL ou MAXLONGLONG. Utilisez NULL pour démarrer le flux d’aperçu :

pBuild->ControlStream(&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, pCap,
    NULL,    // Start now.
    0,       // (Don't care.)
    wStartCookie, wStopCookie); 

Utilisez MAXLONGLONG pour arrêter le flux d’aperçu :

pBuild->ControlStream(&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, pCap,
    0,               // (Don't care.)
    MAXLONGLONG,     // Stop now.
    wStartCookie, wStopCookie); 

Peu importe que le flux d’aperçu provient d’une épingle d’aperçu sur le filtre de capture ou du filtre Smart Tee. La méthode ControlStream fonctionne dans les deux sens.

Toutefois, pour les broches de port vidéo, la méthode échoue. Dans ce cas, une autre approche consiste à masquer la fenêtre vidéo. Interrogez le graphique pour IVideoWindow et utilisez la méthode IVideoWindow::p ut_Visible pour afficher ou masquer la fenêtre.

// Hide the video window.
IVideoWindow *pVidWin = 0;
hr = pGraph->QueryInterface(IID_IVideoWindow, (void**)&pVidWin);
if (SUCCEEDED(hr))
{
    pVidWin->put_Visible(OAFALSE);
    pVidWin->Release();
}

En outre, si vous appelez IVideoWindow::p ut_AutoShow avec la valeur OAFALSE avant d’exécuter le graphique, le filtre Video Renderer masque la fenêtre jusqu’à ce que vous spécifiez le contraire. Par défaut, le convertisseur vidéo affiche la fenêtre lorsque vous exécutez le graphique.

Remarques sur le contrôle de flux de données

Le comportement par défaut d’une broche consiste à fournir des exemples lors de l’exécution du graphique. Par exemple, supposons que vous appeliez ControlStream avec PIN_CATEGORY_CAPTURE mais pas avec PIN_CATEGORY_PREVIEW. Lorsque vous exécutez le graphe, le flux d’aperçu s’exécute immédiatement, tandis que le flux de capture s’exécute à l’heure spécifiée dans ControlStream.

Si vous capturez plusieurs flux et les envoyez à un filtre mux (par exemple, si vous capturez de l’audio et de la vidéo dans un fichier AVI), vous devez contrôler les deux flux en tandem. Sinon, le filtre mux peut bloquer l’attente d’un flux, car il tente d’entrelacer les deux flux. Définissez les mêmes heures de début et d’arrêt sur tous les flux de capture avant d’exécuter le graphique :

pBuild->ControlStream(&PIN_CATEGORY_CAPTURE, 
    
NULL, NULL,       // All capture streams.
    &rtStart, rtStop, 
    wStartCookie, wStopCookie); 

En interne, la méthode ControlStream utilise l’interface IAMStreamControl , qui est exposée sur les broches du filtre de capture, du filtre Smart Tee (le cas échéant) et éventuellement du filtre mux. Vous pouvez utiliser cette interface directement, au lieu d’appeler ControlStream, bien qu’il n’y ait aucun avantage particulier à le faire.

Rubriques connexes

Capture vidéo