Codierung konstanter Bitrate

  • Artikel

Bei der CBR-Codierung (Constant Bit Rate) kennt der Encoder die Bitrate der Ausgabemedienbeispiele und das Pufferfenster (undichte Bucketparameter), bevor die Codierungssitzung beginnt. Der Encoder verwendet die gleiche Anzahl von Bits, um jede Sekunde des Beispiels während der gesamten Dauer der Datei zu codieren, um die Zielbitrate für einen Stream zu erreichen. Dadurch wird die Abweichung in der Größe der Streambeispiele begrenzt. Außerdem liegt die Bitrate während der Codierungssitzung nicht genau auf dem angegebenen Wert, bleibt aber nahe an der Zielbitrate.

CBR-Codierung ist hilfreich, wenn Sie die Bitrate oder die geschätzte Dauer einer Datei herausfinden möchten, ohne die gesamte Datei zu analysieren. Dies wird z. B. beim Livestreaming benötigt, wenn die Medieninhalte mit einer vorhersehbaren Bitrate und mit konstanter Bandbreitennutzung gestreamt werden müssen.

Der Nachteil der CBR-Codierung ist, dass die Qualität des codierten Inhalts nicht konstant ist. Da einige Inhalte schwieriger zu komprimieren sind, sind Teile eines CBR-Streams von geringerer Qualität als andere. Ein typischer Film hat beispielsweise einige Szenen, die ziemlich statisch sind, und einige Szenen, die voller Action sind. Wenn Sie einen Film mit CBR codieren, sind die Szenen, die statisch sind und daher einfach effizient zu codieren sind, von höherer Qualität als die Aktionsszenen, die höhere Stichprobengrößen erfordert hätten, um die gleiche Qualität beizubehalten.

Im Allgemeinen sind Qualitätsschwankungen einer CBR-Datei bei niedrigeren Bitraten ausgeprägter. Bei höheren Bitraten variiert die Qualität einer CBR-codierten Datei immer noch, aber die Qualitätsprobleme sind für den Benutzer weniger spürbar. Wenn Sie die CBR-Codierung verwenden, sollten Sie die Bandbreite so hoch festlegen, wie ihr Übermittlungsszenario dies zulässt.

CBR-Konfigurationseinstellungen

Sie müssen einen Encoder konfigurieren, indem Sie den Codierungstyp und die verschiedenen streamspezifischen Einstellungen vor der Codierungssitzung angeben.

So konfigurieren Sie den Encoder für die CBR-Codierung

  1. Geben Sie den CBR-Codierungsmodus an.

    Standardmäßig ist der Encoder für die Verwendung der CBR-Codierung konfiguriert. Die Encoderkonfiguration wird über Eigenschaftswerte festgelegt. Diese Eigenschaften werden in wmcodecdsp.h definiert. Sie können diesen Modus explizit angeben, indem Sie die eigenschaft MFPKEY_VBRENABLED auf VARIANT_FALSE festlegen. Informationen zum Festlegen von Eigenschaften für Encoder finden Sie unter Konfigurieren des Encoders.

  2. Wählen Sie die Codierungsbitrate aus.

    Für die CBR-Codierung müssen Sie die Bitrate kennen, mit der Sie den Stream codieren möchten, bevor die Codierungssitzung beginnt. Sie müssen die Bitrate während der Konfiguration des Encoders festlegen. Überprüfen Sie dazu während der Medientypaushandlung das MF_MT_AUDIO_AVG_BYTES_PER_SECOND-Attribut (für Audiodatenströme) oder das MF_MT_AVG_BITRATE-Attribut (für Videostreams) der verfügbaren Ausgabemedientypen, und wählen Sie einen Ausgabemedientyp mit der durchschnittlichen Bitrate aus, die der gewünschten Zielbitrate am nächsten ist. Weitere Informationen finden Sie unter Medientypverhandlung auf dem Encoder.

Das folgende Codebeispiel zeigt die Implementierung für SetEncodingProperties. Diese Funktion legt Codierungseigenschaften auf Streamebene für CBR und VBR fest.

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

Einstellungen für undichte Buckets

Bei der CBR-Codierung sind die durchschnittlichen und die maximalen Werte für undichte Buckets für den Stream identisch. Weitere Informationen zu diesen Parametern finden Sie unter The Leaky Bucket Buffer Model.

Für CBR-codierte Audiostreams müssen Sie die undichten Bucketwerte festlegen, nachdem sie den Ausgabemedientyp auf dem Encoder aushandeln. Der Encoder berechnet das Pufferfenster intern basierend auf der durchschnittlichen Bitrate, die für den Ausgabemedientyp festgelegt ist.

Wenn Sie undichte Bucketwerte festlegen möchten, können Sie ein Array von DWORDs erstellen, um die folgenden Werte in der MFPKEY_ASFSTREAMSINK_CORRECTED_LEAKYBUCKET-Eigenschaft im Eigenschaftenspeicher der Mediensenke festzulegen. Weitere Informationen finden Sie unter Festlegen von Eigenschaften in der Dateisenke.

ASF-Codierungstypen

Tutorial: 1-Pass-Windows Media-Codierung

Tutorial: Schreiben einer WMA-Datei mithilfe der CBR-Codierung