Tipos de mídia de vídeo não compactados

  • Artigo

Este tópico descreve como criar um tipo de mídia que descreve um formato de vídeo descompactado. Para obter mais informações sobre tipos de mídia em geral, consulte Sobre tipos de mídia.

Para criar um tipo de vídeo não compactado completo, defina os atributos a seguir no ponteiro da interface IMFMediaType .

Atributo Descrição
MF_MT_MAJOR_TYPE Tipo principal. Defina como MFMediaType_Video.
MF_MT_SUBTYPE Subtipo. Consulte GUIDs de subtipo de vídeo.
MF_MT_DEFAULT_STRIDE Avanço da superfície. O passo a passo é o número de bytes necessários para ir de uma linha de pixels para a próxima. Defina esse atributo se o passo em bytes não for o mesmo que a largura do vídeo em bytes. Caso contrário, você pode omitir esse atributo.
MF_MT_FRAME_RATE Taxa de quadros.
MF_MT_FRAME_SIZE Tamanho do quadro.
MF_MT_INTERLACE_MODE Modo de interlacagem.
MF_MT_ALL_SAMPLES_INDEPENDENT Especifica se cada amostra é independente. Defina como TRUE para formatos descompactados.
MF_MT_PIXEL_ASPECT_RATIO Taxa de proporção de pixel.

 

Além disso, defina os atributos a seguir se você souber os valores corretos. (Caso contrário, omita esses atributos.)

Atributo Descrição
MF_MT_VIDEO_PRIMARIES Primárias de cores.
MF_MT_TRANSFER_FUNCTION Função de transferência.
MF_MT_YUV_MATRIX Matriz de transferência.
MF_MT_VIDEO_CHROMA_SITING Chroma sentado.
MF_MT_VIDEO_NOMINAL_RANGE Intervalo nominal.

 

Para obter mais informações, consulte Informações de cor estendidas. Por exemplo, se você criar um tipo de mídia que descreva um padrão de vídeo e o padrão definir o chroma siting, adicione essas informações ao tipo de mídia. Isso ajuda a preservar a fidelidade de cores em todo o pipeline.

As funções a seguir podem ser úteis ao criar um tipo de mídia de vídeo.

Função Descrição
MFAverageTimePerFrameToFrameRate Calcula a taxa de quadros, dada a duração média do quadro.
MFCalculateImageSize Calcula o tamanho da imagem para um formato de vídeo não compactado.
MFFrameRateToAverageTimePerFrame Calcula a duração média de um quadro de vídeo, dada a taxa de quadros.
MFGetStrideForBitmapInfoHeader Retorna o passo mínimo da superfície para um formato de vídeo. Para obter mais informações, consulte Image Stride.
MFInitVideoFormat Inicializa uma estrutura MFVIDEOFORMAT para alguns formatos de vídeo padrão, como televisão NTSC. Em seguida, você pode usar a estrutura para inicializar um tipo de mídia.
MFIsFormatYUV Consulta se um formato de vídeo é um formato YUV.

 

Exemplos

Este exemplo mostra uma função que preenche as informações mais comuns para um formato de vídeo não compactado. A função retorna um ponteiro de interface IMFMediaType . Em seguida, você pode adicionar atributos adicionais ao tipo de mídia conforme necessário.

HRESULT CreateUncompressedVideoType(
    DWORD                fccFormat,  // FOURCC or D3DFORMAT value.     
    UINT32               width, 
    UINT32               height,
    MFVideoInterlaceMode interlaceMode,
    const MFRatio&       frameRate,
    const MFRatio&       par,
    IMFMediaType         **ppType
    )
{
    if (ppType == NULL)
    {
        return E_POINTER;
    }

    GUID    subtype = MFVideoFormat_Base;
    LONG    lStride = 0;
    UINT    cbImage = 0;

    IMFMediaType *pType = NULL;

    // Set the subtype GUID from the FOURCC or D3DFORMAT value.
    subtype.Data1 = fccFormat;

    HRESULT hr = MFCreateMediaType(&pType);
    if (FAILED(hr))
    {
        goto done;
    }

    hr = pType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
    if (FAILED(hr))
    {
        goto done;
    }

    hr = pType->SetGUID(MF_MT_SUBTYPE, subtype);
    if (FAILED(hr))
    {
        goto done;
    }

    hr = pType->SetUINT32(MF_MT_INTERLACE_MODE, interlaceMode);
    if (FAILED(hr))
    {
        goto done;
    }

    hr = MFSetAttributeSize(pType, MF_MT_FRAME_SIZE, width, height);
    if (FAILED(hr))
    {
        goto done;
    }

    // Calculate the default stride value.
    hr = pType->SetUINT32(MF_MT_DEFAULT_STRIDE, UINT32(lStride));
    if (FAILED(hr))
    {
        goto done;
    }

    // Calculate the image size in bytes.
    hr = MFCalculateImageSize(subtype, width, height, &cbImage);
    if (FAILED(hr))
    {
        goto done;
    }

    hr = pType->SetUINT32(MF_MT_SAMPLE_SIZE, cbImage);
    if (FAILED(hr))
    {
        goto done;
    }

    hr = pType->SetUINT32(MF_MT_FIXED_SIZE_SAMPLES, TRUE);
    if (FAILED(hr))
    {
        goto done;
    }

    hr = pType->SetUINT32(MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);
    if (FAILED(hr))
    {
        goto done;
    }

    // Frame rate
    hr = MFSetAttributeRatio(pType, MF_MT_FRAME_RATE, frameRate.Numerator, 
        frameRate.Denominator);
    if (FAILED(hr))
    {
        goto done;
    }

    // Pixel aspect ratio
    hr = MFSetAttributeRatio(pType, MF_MT_PIXEL_ASPECT_RATIO, par.Numerator, 
        par.Denominator);
    if (FAILED(hr))
    {
        goto done;
    }

    // Return the pointer to the caller.
    *ppType = pType;
    (*ppType)->AddRef();

done:
    SafeRelease(&pType);
    return hr;
}

O próximo exemplo usa um formato de vídeo codificado como entrada e cria um tipo de vídeo não compactado correspondente. Esse tipo seria adequado para definir em um codificador ou decodificador, por exemplo.

HRESULT ConvertVideoTypeToUncompressedType(
    IMFMediaType *pType,    // Pointer to an encoded video type.
    const GUID& subtype,    // Uncompressed subtype (eg, RGB-32, AYUV)
    IMFMediaType **ppType   // Receives a matching uncompressed video type.
    )
{
    IMFMediaType *pTypeUncomp = NULL;

    HRESULT hr = S_OK;
    GUID majortype = { 0 };
    MFRatio par = { 0 };

    hr = pType->GetMajorType(&majortype);

    if (majortype != MFMediaType_Video)
    {
        return MF_E_INVALIDMEDIATYPE;
    }

    // Create a new media type and copy over all of the items.
    // This ensures that extended color information is retained.

    if (SUCCEEDED(hr))
    {
        hr = MFCreateMediaType(&pTypeUncomp);
    }

    if (SUCCEEDED(hr))
    {
        hr = pType->CopyAllItems(pTypeUncomp);
    }

    // Set the subtype.
    if (SUCCEEDED(hr))
    {
        hr = pTypeUncomp->SetGUID(MF_MT_SUBTYPE, subtype);
    }

    // Uncompressed means all samples are independent.
    if (SUCCEEDED(hr))
    {
        hr = pTypeUncomp->SetUINT32(MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);
    }

    // Fix up PAR if not set on the original type.
    if (SUCCEEDED(hr))
    {
        hr = MFGetAttributeRatio(
            pTypeUncomp, 
            MF_MT_PIXEL_ASPECT_RATIO, 
            (UINT32*)&par.Numerator, 
            (UINT32*)&par.Denominator
            );

        // Default to square pixels.
        if (FAILED(hr))
        {
            hr = MFSetAttributeRatio(
                pTypeUncomp, 
                MF_MT_PIXEL_ASPECT_RATIO, 
                1, 1
                );
        }
    }

    if (SUCCEEDED(hr))
    {
        *ppType = pTypeUncomp;
        (*ppType)->AddRef();
    }

    SafeRelease(&pTypeUncomp);
    return hr;
}

Informações de cor estendidas

Imagem Passo a Passo

Tipos de mídia

Tipos de mídia de vídeo

GUIDs de subtipo de vídeo