Nicht komprimierte Audiomedientypen

Um einen vollständigen unkomprimierten Audiotyp zu erstellen, legen Sie mindestens die folgenden Attribute auf dem IMFMediaType-Schnittstellenzeiger fest.

attribute	BESCHREIBUNG
MF_MT_MAJOR_TYPE	Haupttyp. Legen Sie auf MFMediaType_Audio fest.
MF_MT_SUBTYPE	Untertyp. Weitere Informationen finden Sie unter Audiountertyp-GUIDs.
MF_MT_AUDIO_NUM_CHANNELS	Anzahl der Audiokanäle.
MF_MT_AUDIO_SAMPLES_PER_SECOND	Anzahl der Audiobeispiele pro Sekunde.
MF_MT_AUDIO_BLOCK_ALIGNMENT	Blockausrichtung.
MF_MT_AUDIO_AVG_BYTES_PER_SECOND	Durchschnittliche Anzahl von Bytes pro Sekunde.
MF_MT_AUDIO_BITS_PER_SAMPLE	Anzahl der Bits pro Audiobeispiel.
MF_MT_ALL_SAMPLES_INDEPENDENT	Gibt an, ob jedes Audiobeispiel unabhängig ist. Legen Sie für MFAudioFormat_PCM- und MFAudioFormat_Float-Formate auf TRUE fest.

 

Darüber hinaus sind die folgenden Attribute für einige Audioformate erforderlich.

attribute	BESCHREIBUNG
MF_MT_AUDIO_VALID_BITS_PER_SAMPLE	Anzahl der gültigen Bits von Audiodaten in jedem Audiobeispiel. Legen Sie dieses Attribut fest, wenn die Audiobeispiele eine Auffüllung aufweisen, d. h. wenn die Anzahl der gültigen Bits in jedem Audiobeispiel kleiner als die Samplegröße ist.
MF_MT_AUDIO_CHANNEL_MASK	Die Zuweisung von Audiokanälen zu Sprecherpositionen. Legen Sie dieses Attribut für mehrkanalige Audiostreams fest, z. B. 5.1. Dieses Attribut ist für Mono- oder Stereoaudio nicht erforderlich.

 

Beispielcode

Der folgende Code zeigt, wie Sie einen Medientyp für nicht komprimierte PCM-Audiodaten erstellen.

HRESULT CreatePCMAudioType(
    UINT32 sampleRate,        // Samples per second
    UINT32 bitsPerSample,     // Bits per sample
    UINT32 cChannels,         // Number of channels
    IMFMediaType **ppType     // Receives a pointer to the media type.
    )
{
    HRESULT hr = S_OK;

    IMFMediaType *pType = NULL;

    // Calculate derived values.
    UINT32 blockAlign = cChannels * (bitsPerSample / 8);
    UINT32 bytesPerSecond = blockAlign * sampleRate;

    // Create the empty media type.
    hr = MFCreateMediaType(&pType);
    if (FAILED(hr))
    {
        goto done;
    }

    // Set attributes on the type.
    hr = pType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio);
    if (FAILED(hr))
    {
        goto done;
    }

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

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

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

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

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

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

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

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

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

Im nächsten Beispiel wird ein codiertes Audioformat als Eingabe verwendet und ein entsprechender PCM-Audiotyp erstellt. Dieser Typ eignet sich beispielsweise für die Einstellung für einen Encoder oder Decoder.

//-------------------------------------------------------------------
// ConvertAudioTypeToPCM
//
// Given an audio media type (which might describe a compressed audio
// format), returns a media type that describes the equivalent
// uncompressed PCM format.
//-------------------------------------------------------------------

HRESULT ConvertAudioTypeToPCM(
    IMFMediaType *pType,        // Pointer to an encoded audio type.
    IMFMediaType **ppType       // Receives a matching PCM audio type.
    )
{
    HRESULT hr = S_OK;

    GUID majortype = { 0 };
    GUID subtype = { 0 };

    UINT32 cChannels = 0;
    UINT32 samplesPerSec = 0;
    UINT32 bitsPerSample = 0;

    hr = pType->GetMajorType(&majortype);
    if (FAILED(hr)) 
    { 
        return hr;
    }

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

    // Get the audio subtype.
    hr = pType->GetGUID(MF_MT_SUBTYPE, &subtype);
    if (FAILED(hr)) 
    { 
        return hr;
    }

    if (subtype == MFAudioFormat_PCM)
    {
        // This is already a PCM audio type. Return the same pointer.

        *ppType = pType;
        (*ppType)->AddRef();

        return S_OK;
    }

    // Get the sample rate and other information from the audio format.

    cChannels = MFGetAttributeUINT32(pType, MF_MT_AUDIO_NUM_CHANNELS, 0);
    samplesPerSec = MFGetAttributeUINT32(pType, MF_MT_AUDIO_SAMPLES_PER_SECOND, 0);
    bitsPerSample = MFGetAttributeUINT32(pType, MF_MT_AUDIO_BITS_PER_SAMPLE, 16);

    // Note: Some encoded audio formats do not contain a value for bits/sample.
    // In that case, use a default value of 16. Most codecs will accept this value.

    if (cChannels == 0 || samplesPerSec == 0)
    {
        return MF_E_INVALIDTYPE;
    }

    // Create the corresponding PCM audio type.
    hr = CreatePCMAudioType(samplesPerSec, bitsPerSample, cChannels, ppType);

    return hr;
}

Zugehörige Themen

Audiomedientypen