Compartilhar via


Codificação de taxa de bit constante

Na codificação CBR (taxa de bits constante), o codificador conhece a taxa de bits dos exemplos de mídia de saída e a janela de buffer (parâmetros de bucket com vazamento) antes do início da sessão de codificação. O codificador usa o mesmo número de bits para codificar cada segundo de exemplo durante toda a duração do arquivo para alcançar a taxa de bits de destino para um fluxo. Isso limita a variação no tamanho dos exemplos de fluxo. Além disso, durante a sessão de codificação, a taxa de bits não está exatamente no valor especificado, mas permanece próxima à taxa de bits de destino.

A codificação CBR é útil quando você deseja saber a taxa de bits ou a duração aproximada de um arquivo sem analisar todo o arquivo. Isso é necessário em cenários de transmissão ao vivo em que o conteúdo da mídia precisa ser transmitido a uma taxa de bits previsível e com uso consistente de largura de banda.

A desvantagem da codificação CBR é que a qualidade do conteúdo codificado não será constante. Como algum conteúdo é mais difícil de compactar, partes de um fluxo CBR serão de menor qualidade do que outras. Por exemplo, um filme típico tem algumas cenas que são bastante estáticas e algumas cenas que estão cheias de ação. Se você codificar um filme usando CBR, as cenas que são estáticas e, portanto, fáceis de codificar com eficiência, serão de maior qualidade do que as cenas de ação, o que exigiria tamanhos de exemplo mais altos para manter a mesma qualidade.

Em geral, as variações na qualidade de um arquivo CBR são mais pronunciadas a taxas de bits mais baixas. Com taxas de bits mais altas, a qualidade de um arquivo codificado em CBR ainda variará, mas os problemas de qualidade serão menos perceptíveis para o usuário. Ao usar a codificação CBR, você deve definir a largura de banda tão alta quanto o cenário de entrega permitir.

Configurações do CBR

Você deve configurar um codificador especificando o tipo de codificação e as várias configurações específicas do fluxo antes da sessão de codificação.

Para configurar o codificador para codificação CBR

  1. Especifique o modo de codificação CBR.

    Por padrão, o codificador é configurado para usar a codificação CBR. A configuração do codificador é definida por meio de valores de propriedade. Essas propriedades são definidas em wmcodecdsp.h. Você pode especificar explicitamente esse modo definindo a propriedade MFPKEY_VBRENABLED como VARIANT_FALSE. Para obter informações sobre como definir propriedades em codificadores, consulte Configuring the Encoder.

  2. Escolha a taxa de bits de codificação.

    Para codificação CBR, você deve saber a taxa de bits na qual deseja codificar o fluxo antes do início da sessão de codificação. Você deve definir a taxa de bits durante a configuração do codificador. Para fazer isso, enquanto você estiver executando a negociação de tipo de mídia, verifique o atributo MF_MT_AUDIO_AVG_BYTES_PER_SECOND (para fluxos de áudio) ou o atributo MF_MT_AVG_BITRATE (para fluxos de vídeo) dos tipos de mídia de saída disponíveis e escolha um tipo de mídia de saída que tenha a taxa de bits média mais próxima da taxa de bits de destino que você deseja alcançar. Para obter mais informações, consulte Media Type Negotiation on the Encoder.

O exemplo de código a seguir mostra a implementação de SetEncodingProperties. Essa função define as propriedades de codificação no nível do fluxo para CBR e VBR.

//-------------------------------------------------------------------
//  SetEncodingProperties
//  Create a media source from a URL.
//
//  guidMT:  Major type of the stream, audio or video
//  pProps:  A pointer to the property store in which 
//           to set the required encoding properties.
//-------------------------------------------------------------------

HRESULT SetEncodingProperties (const GUID guidMT, IPropertyStore* pProps)
{
    if (!pProps)
    {
        return E_INVALIDARG;
    }

    if (EncodingMode == NONE)
    {
        return MF_E_NOT_INITIALIZED;
    }
   
    HRESULT hr = S_OK;

    PROPVARIANT var;

    switch (EncodingMode)
    {
        case CBR:
            // Set VBR to false.
            hr = InitPropVariantFromBoolean(FALSE, &var);
            if (FAILED(hr))
            {
                goto done;
            }

            hr = pProps->SetValue(MFPKEY_VBRENABLED, var);
            if (FAILED(hr))
            {
                goto done;
            }

            // Set the video buffer window.
            if (guidMT == MFMediaType_Video)
            {
                hr = InitPropVariantFromInt32(VIDEO_WINDOW_MSEC, &var);
                if (FAILED(hr))
                {
                    goto done;
                }

                hr = pProps->SetValue(MFPKEY_VIDEOWINDOW, var);    
                if (FAILED(hr))
                {
                    goto done;
                }
            }
            break;

        case VBR:
            //Set VBR to true.
            hr = InitPropVariantFromBoolean(TRUE, &var);
            if (FAILED(hr))
            {
                goto done;
            }

            hr = pProps->SetValue(MFPKEY_VBRENABLED, var);
            if (FAILED(hr))
            {
                goto done;
            }

            // Number of encoding passes is 1.

            hr = InitPropVariantFromInt32(1, &var);
            if (FAILED(hr))
            {
                goto done;
            }

            hr = pProps->SetValue(MFPKEY_PASSESUSED, var);
            if (FAILED(hr))
            {
                goto done;
            }

            // Set the quality level.

            if (guidMT == MFMediaType_Audio)
            {
                hr = InitPropVariantFromUInt32(98, &var);
                if (FAILED(hr))
                {
                    goto done;
                }

                hr = pProps->SetValue(MFPKEY_DESIRED_VBRQUALITY, var);    
                if (FAILED(hr))
                {
                    goto done;
                }
            }
            else if (guidMT == MFMediaType_Video)
            {
                hr = InitPropVariantFromUInt32(95, &var);
                if (FAILED(hr))
                {
                    goto done;
                }

                hr = pProps->SetValue(MFPKEY_VBRQUALITY, var);    
                if (FAILED(hr))
                {
                    goto done;
                }
            }
            break;

        default:
            hr = E_UNEXPECTED;
            break;
    }    

done:
    PropVariantClear(&var);
    return hr;
}

Configurações de bucket com vazamento

Para codificação CBR, a média e os valores máximos de bucket com vazamento para o fluxo são os mesmos. Para obter mais informações sobre esses parâmetros, consulte o modelo de buffer de bucket vazado.

Para codificar fluxos de áudio cbr, você precisa definir os valores de bucket com vazamento depois de negociar o tipo de mídia de saída no codificador. O codificador calcula a janela de buffer internamente com base na taxa média de bits definida no tipo de mídia de saída.

Para definir valores de bucket com vazamento, crie uma matriz de DWORDs pode definir os seguintes valores na propriedade MFPKEY_ASFSTREAMSINK_CORRECTED_LEAKYBUCKET no repositório de propriedades do coletor de mídia. Para obter mais informações, consulte Propriedades de Configuração no coletor de arquivos.

  • Taxa média de bits: obtenha a taxa média de bits do tipo de mídia de saída selecionado durante a negociação de tipo de mídia. Use o atributo MF_MT_AUDIO_AVG_BYTES_PER_SECOND.
  • Janela do buffer: consulte o codificador para a interfaceIWMCodecLeakyBucket e chame IWMCodecLeakyBucket::GetBufferSizeBits (wmcodecifaces.h, wmcodecdspuuid.lib).
  • Tamanho inicial do buffer: definido como 0.

tipos de codificação ASF

Tutorial : codificação de mídia do Windows de 1 passagem

Tutorial: Escrevendo um arquivo WMA usando a codificação CBR