Controlando um gráfico de captura

[O recurso associado a esta página, DirectShow, é um recurso herdado. Foi substituído por MediaPlayer, IMFMediaEnginee Audio/Video Capture in Media Foundation. Esses recursos foram otimizados para Windows 10 e Windows 11. A Microsoft recomenda vivamente que o novo código utilize MediaPlayer, IMFMediaEngine e Captura de Áudio/Vídeo no Media Foundation em vez de DirectShow, quando possível. A Microsoft sugere que o código existente que usa as APIs herdadas seja reescrito para usar as novas APIs, se possível.]

A interfaceIMediaControl do Filter Graph Managertem métodos para executar, parar e pausar todo o gráfico. Se o gráfico de filtro tiver fluxos de captura e visualização, no entanto, você provavelmente deseja controlar os dois fluxos independentemente. Por exemplo, talvez você queira visualizar o vídeo sem capturá-lo. Você pode fazer isso através do ICaptureGraphBuilder2::ControlStream método.

Controlando o fluxo de captura

O código a seguir define o fluxo de captura de vídeo para ser executado por quatro segundos, começando um segundo após a execução do gráfico:

// 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();

O primeiro parâmetro especifica qual fluxo controlar, como um GUID de categoria de pino. O segundo parâmetro fornece o tipo de mídia. O terceiro parâmetro é um ponteiro para o filtro de captura. Para controlar todos os fluxos de captura no gráfico, defina o segundo e terceiro parâmetros como NULL.

Os dois parâmetros seguintes definem os momentos em que o fluxo começará e parará, em relação ao momento em que o gráfico começa a ser executado. Chame IMediaControl::Run para executar o gráfico. Até que você execute o gráfico, o ControlStream método não tem efeito. Se o gráfico já estiver em execução, as configurações entrarão em vigor imediatamente.

Os dois últimos parâmetros são usados para obter notificações de eventos quando o fluxo é iniciado e interrompido. Para cada fluxo que você controla usando esse método, o gráfico de filtro envia um par de eventos: EC_STREAM_CONTROL_STARTED quando o fluxo é iniciado e EC_STREAM_CONTROL_STOPPED quando o fluxo para. Os valores de wStartCookie e wStopCookie são usados como o segundo parâmetro de evento. Assim, lParam2 no evento de início é igual a wStartCookie, e lParam2 no evento de paragem é igual a wStopCookie. O código a seguir mostra como obter esses eventos:

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);
}

O método ControlStream define alguns valores especiais para os tempos de início e parada.

Por exemplo, o código a seguir interrompe o fluxo de captura imediatamente:

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

Embora você possa parar o fluxo de captura e reiniciá-lo mais tarde, isso criará uma lacuna nos carimbos de data/hora. Na reprodução, o vídeo parecerá estagnar durante o intervalo (dependendo do formato do arquivo).

Controlar o fluxo de pré-visualização

Para controlar o pino de visualização, chame ControlStream e defina o primeiro parâmetro como PIN_CATEGORY_PREVIEW. Isso funciona exatamente como para PIN_CATEGORY_CAPTURE, exceto que você não pode usar tempos de referência para especificar o início e parada, porque os quadros de visualização não têm carimbos de data/hora. Portanto, deve usar NULL ou ou MAXLONGLONG. Use NULL para iniciar o fluxo de visualização:

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

Use MAXLONGLONG para parar o fluxo de visualização:

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

Não importa se o fluxo de visualização vem de um pino de visualização no filtro de captura ou do filtro Smart Tee. O método ControlStream funciona de qualquer maneira.

Para pinos de porta de vídeo, no entanto, o método falhará. Nesse caso, outra abordagem é ocultar a janela de vídeo. Consulte o grafo para IVideoWindow e use o método IVideoWindow::put_Visible para mostrar ou ocultar a janela.

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

Além disso, se tu chamares IVideoWindow::put_AutoShow com o valor OAFALSE antes de executar o gráfico, o filtro Video Renderer ocultará a janela até que especifiques o contrário. Por padrão, o renderizador de vídeo mostra a janela quando você executa o gráfico.

Comentários sobre o Stream Control

O comportamento padrão de um pino é entregar amostras quando o gráfico é executado. Por exemplo, suponha que você chame ControlStream com PIN_CATEGORY_CAPTURE mas não com PIN_CATEGORY_PREVIEW. Quando você executa o gráfico, o fluxo de visualização será executado imediatamente, enquanto o fluxo de captura será executado a qualquer momento especificado no ControlStream.

Se você estiver capturando mais de um fluxo e enviando-os para um filtro mux — por exemplo, se estiver capturando áudio e vídeo para um arquivo AVI — você deve controlar ambos os fluxos em conjunto. Caso contrário, o filtro mux pode bloquear a espera por um fluxo, enquanto tenta intercalar os dois fluxos. Defina os mesmos tempos de início e parada em todos os fluxos de captura antes de executar o gráfico:

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

Internamente, o método ControlStream usa a interface IAMStreamControl, que é exposta nos pinos do filtro de captura, no filtro Smart Tee (se estiver presente) e, possivelmente, no filtro mux. Você pode usar essa interface diretamente, em vez de chamar ControlStream, embora não haja nenhuma vantagem específica em fazê-lo.

Tópicos relacionados

Captura de Vídeo