Freigeben über

Konstante Bitrate-Codierung

Bei der Codierung mit konstanter Bitrate (CBR) kennt der Encoder die Bitrate der Ausgabemedienbeispiele und das Pufferfenster (Lecky Bucket-Parameter), 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 Datenstrom zu erreichen. Dadurch wird die Variation der Größe der Datenstrombeispiele begrenzt. Außerdem liegt die Bitrate während der Codierungssitzung nicht genau am angegebenen Wert, sondern bleibt nahe an der Zielbitrate.

CBR-Codierung ist nützlich, wenn Sie die Bitrate oder ungefähre Dauer einer Datei kennen möchten, ohne die gesamte Datei zu analysieren. Dies ist in Livestreaming-Szenarien erforderlich, in denen medieninhalte mit einer vorhersehbaren Bitrate und einer konsistenten Bandbreitennutzung gestreamt werden müssen.

Der Nachteil der CBR-Codierung besteht darin, dass die Qualität des codierten Inhalts nicht konstant ist. Da einige Inhalte schwieriger zu komprimieren sind, sind Teile eines CBR-Datenstroms von geringerer Qualität als andere. Beispielsweise enthält ein typischer Film einige Szenen, die ziemlich statisch sind und einige Szenen voller Action sind. Wenn Sie einen Film mit CBR codieren, werden die szenen, die statisch sind und daher effizient codiert werden, von höherer Qualität sein als die Aktionsszenen, die höhere Beispielgrößen benötigt hätten, um die gleiche Qualität zu erhalten.

Im Allgemeinen sind Variationen in der Qualität einer CBR-Datei bei niedrigeren Bitraten ausgeprägter. 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 CBR-Codierung verwenden, sollten Sie die Bandbreite so hoch festlegen, wie Ihr Übermittlungsszenario 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 Configuring the Encoder.

  2. Wählen Sie die Codierungsbitrate aus.

    Für die CBR-Codierung müssen Sie die Bitrate kennen, mit der Sie den Datenstrom 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 attribut MF_MT_AUDIO_AVG_BYTES_PER_SECOND (für Audiodatenströme) oder das attribut MF_MT_AVG_BITRATE (für Videostreams) der verfügbaren Ausgabemedientypen, und wählen Sie einen Ausgabemedientyp aus, der die durchschnittliche Bitrate am nächsten mit der Zielbitrate aufweist, die Sie erreichen möchten. Weitere Informationen finden Sie unter Medientypverhandlung im 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;
}

Leckige Bucketeinstellungen

Für die CBR-Codierung sind der Mittelwert und die maximalen Leck-Bucketwerte für den Datenstrom identisch. Weitere Informationen zu diesen Parametern finden Sie unter Das Leaky Bucket Buffer Model.

Um CBR-codierte Audiodatenströme zu codieren, müssen Sie die Leck-Bucketwerte festlegen, nachdem Sie den Ausgabemedientyp auf dem Encoder verhandelt haben. Der Encoder berechnet das Pufferfenster intern basierend auf der für den Ausgabemedientyp festgelegten durchschnittlichen Bitrate.

Um leckige Bucketwerte festzulegen, können Sie ein Array von DWORDs erstellen, die folgenden Werte in der eigenschaft MFPKEY_ASFSTREAMSINK_CORRECTED_LEAKYBUCKET im Eigenschaftenspeicher der Mediensenke festlegen. Weitere Informationen finden Sie unter Festlegen von Eigenschaften in der Dateisenken-.

ASF-Codierungstypen

Lernprogramm: 1-Pass Windows Media Encoding

Lernprogramm: Schreiben einer WMA-Datei mithilfe von CBR-Codierungs-