Para enumerar formatos de entrada

[O recurso associado a esta página, Windows Media Format 11 SDK, é um recurso herdado. Ele foi substituído por Leitor de Origem e Gravador de Coletor. O Leitor de Origem e o Gravador de Coletor foram otimizados para Windows 10 e Windows 11. A Microsoft recomenda fortemente que o novo código use o Leitor de Origem e o Gravador de Coletor em vez do SDK do Windows Media Format 11, 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.]

Cada um dos codecs do Windows Media aceita um ou mais tipos de mídia de entrada para compactação. O SDK de Formato de Mídia do Windows permite que você insira uma variedade mais ampla de formatos do que aqueles compatíveis com os codecs. O SDK faz isso executando transformações de pré-processamento nas entradas quando necessário, como redimensionamento de quadros de vídeo ou resampação de áudio. De qualquer forma, você deve garantir que os formatos de entrada para os arquivos gravados correspondam aos dados enviados ao gravador. Cada codec tem um formato de mídia de entrada padrão definido no gravador quando o perfil é carregado. Você pode examinar o formato de entrada padrão chamando IWMWriter::GetInputProps.

Os codecs de vídeo dão suporte aos seguintes formatos: IYUV, I420, YV12, YUY2, UYVY, YVYU, YVU9, RGB 32, RGB 24, RGB 565, RGB 555 e RGB 8. Os codecs de áudio dão suporte ao áudio PCM.

Para enumerar os formatos de entrada compatíveis com um codec, execute as seguintes etapas:

1. Crie um objeto gravador e defina um perfil a ser usado. Para obter mais informações sobre como definir perfis no gravador, consulte Para usar perfis com o gravador.
2. Identifique o número de entrada para o qual você deseja marcar os formatos. Para obter mais informações sobre como identificar números de entrada, consulte Para identificar entradas por número.
3. Recupere o número total de formatos de entrada compatíveis com a entrada desejada chamando IWMWriter::GetInputFormatCount.
4. Faça um loop em todos os formatos de entrada com suporte, executando as etapas a seguir para cada um.
   • Recupere a interface IWMInputMediaProps para o formato de entrada chamando IWMWriter::GetInputFormat.
   • Recupere a estrutura de WM_MEDIA_TYPE para o formato de entrada. Chame IWMMediaProps::GetMediaType, passando NULL para o parâmetro pType para obter o tamanho da estrutura. Em seguida, aloque memória para manter a estrutura e chame GetMediaType novamente para obter a estrutura. IWMInputMediaProps herda de IWMMediaProps, para que você possa fazer as chamadas para GetMediaType da instância de IWMInputMediaProps recuperada na etapa anterior.
   • O formato descrito na estrutura WM_MEDIA_TYPE contém todas as informações pertinentes sobre o formato de entrada. O formato básico da mídia é identificado por WM_MEDIA_TYPE.subtype. Para fluxos de vídeo, o membro pbFormat aponta para uma estrutura WMVIDEOINFOHEADER alocada dinamicamente que contém mais detalhes sobre o fluxo, incluindo o tamanho do retângulo. O tamanho dos quadros de entrada não é necessário para corresponder exatamente a um tamanho compatível com o codec. Se eles não corresponderem, os componentes de tempo de execução do SDK, em muitos casos, redimensionarão automaticamente os quadros de vídeo de entrada para algo que o codec pode aceitar.

O código de exemplo a seguir localiza o formato de entrada do subtipo passado como um parâmetro. Para obter mais informações sobre como usar esse código, consulte Usando os exemplos de código.

HRESULT FindInputFormat(IWMWriter* pWriter, 
                       DWORD dwInput,
                       GUID guidSubType,
                       IWMInputMediaProps** ppProps)
{
    DWORD   cFormats = 0;
    DWORD   cbSize   = 0;

    WM_MEDIA_TYPE*      pType  = NULL;
    IWMInputMediaProps* pProps = NULL;

    // Set the ppProps parameter to point to NULL. This will
    //  be used to check the results of the function later.
    *ppProps = NULL;

    // Find the number of formats supported by this input.
    HRESULT hr = pWriter->GetInputFormatCount(dwInput, &cFormats);
    if (FAILED(hr))
    {
        goto Exit;
    }
    // Loop through all of the supported formats.
    for (DWORD formatIndex = 0; formatIndex < cFormats; formatIndex++)
    {
        // Get the input media properties for the input format.
        hr = pWriter->GetInputFormat(dwInput, formatIndex, &pProps);
        if (FAILED(hr))
        {
            goto Exit;
        }
        // Get the size of the media type structure.
        hr = pProps->GetMediaType(NULL, &cbSize);
        if (FAILED(hr))
        {
            goto Exit;
        }
        // Allocate memory for the media type structure.
        pType = (WM_MEDIA_TYPE*) new (std::nothrow) BYTE[cbSize];
        if (pType == NULL)
        {
            hr = E_OUTOFMEMORY;
            goto Exit;
        }
        
        // Get the media type structure.
        hr = pProps->GetMediaType(pType, &cbSize);
        if (FAILED(hr))
        {
            goto Exit;
        }

        if(pType->subtype == guidSubType)
        {
            *ppProps = pProps;
            (*ppProps)->AddRef();
            goto Exit;
        }

        // Clean up for next iteration.
        delete [] pType;
        pType = NULL;
        SAFE_RELEASE(pProps);
    } // End for formatIndex.

    // If execution made it to this point, no matching format was found.
    hr = NS_E_INVALID_INPUT_FORMAT;

Exit:
    delete [] pType;
    SAFE_RELEASE(pProps);
    return hr;
}

Tópicos relacionados

IWMWriter Interface

Gravando arquivos ASF