Codierung der konstanten Bitrate

Bei der CBR-Codierung (Constant Bit Rate) kennt der Encoder die Bitrate der Ausgabemedienbeispiele und des Pufferfensters (Leaky Bucket-Parameter), bevor die Codierungssitzung beginnt. Der Encoder verwendet die gleiche Anzahl von Bits, um jede Sekunde der Stichprobe während der gesamten Dauer der Datei zu codieren, um die Zielbitrate für einen Stream zu erreichen. Dies schränkt die Variation der Größe der Streambeispiele ein. Außerdem liegt die Bitrate während der Codierungssitzung nicht genau bei dem angegebenen Wert, sondern 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, haben Teile eines CBR-Streams eine niedrigere Qualität als andere. Ein typischer Film enthält z. B. einige Szenen, die ziemlich statisch sind, und einige Szenen, die voll von Aktion sind. Wenn Sie einen Film mit CBR codieren, haben die statischen und daher einfach zu codierenden Szenen eine höhere Qualität als die Aktionsszenen, für die höhere Stichprobengrößen erforderlich wären, um die gleiche Qualität zu erhalten.

Im Allgemeinen sind Variationen in der Qualität einer CBR-Datei mit niedrigeren Bitraten deutlicher. Bei höheren Bitraten variiert die Qualität einer CBR-codierten Datei weiterhin, 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 Bereitstellungsszenario es zulässt.

CBR-Einstellungen

Sie müssen einen Encoder konfigurieren, indem Sie vor der Codierungssitzung den Typ der Codierung und die verschiedenen streamspezifischen Einstellungen 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 MFPKEY _ VBRENABLED-Eigenschaft 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 hierzu während der Medientypaushandlung das MF _ MT AUDIO _ _ AVG BYTES PER _ _ _ SECOND-Attribut (für Audiostreams) oder das MF MT _ _ AVG _ BITRATE-Attribut (für Videostreams) der verfügbaren Ausgabemedientypen, und wählen Sie einen Ausgabemedientyp aus, der die durchschnittliche Bitrate auf hat, die der zu erreichenden Zielbitrate am nächsten kommt. Weitere Informationen finden Sie unter Media Type Negotiation (Medientypaushandlung) 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;
}

Leaky Bucket Einstellungen

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

Um Audiostreams cbr-codieren zu können, müssen Sie die Bucketwerte für die Lecks festlegen, nachdem Sie den Ausgabemedientyp für den Encoder aushandelt haben. Der Encoder berechnet das Pufferfenster intern basierend auf der durchschnittlichen Bitrate, die für den Ausgabemedientyp festgelegt ist.

Erstellen Sie zum Festlegen von Bucketwerten mit Datenlecks ein Array von DWORDs, die die folgenden Werte in der MFPKEY _ ASFSTREAMSINK _ CORRECTED _ LEAKYBUCKET-Eigenschaft im Eigenschaftenspeicher der Mediensenke festlegen können. Weitere Informationen finden Sie unter Festlegen von Eigenschaften in der Dateisenke.

ASF-Codierungstypen

Tutorial: 1-Pass-Windows-Mediencodierung

Tutorial: Schreiben einer WMA-Datei mit CBR-Codierung