Tipi di supporti audio non compressi

Per creare un tipo audio non compresso completo, impostare almeno gli attributi seguenti nel puntatore dell'interfaccia FMMediaType .

Attributo	Descrizione
MF_MT_MAJOR_TYPE	Tipo principale. Impostare su MFMediaType_Audio.
MF_MT_SUBTYPE	Sottotipo. Vedere GUID del sottotipo audio.
MF_MT_AUDIO_NUM_CHANNELS	Numero dei canali audio.
MF_MT_AUDIO_SAMPLES_PER_SECOND	Numero di campioni audio al secondo.
MF_MT_AUDIO_BLOCK_ALIGNMENT	Allineamento blocchi.
MF_MT_AUDIO_AVG_BYTES_PER_SECOND	Numero medio di byte al secondo.
MF_MT_AUDIO_BITS_PER_SAMPLE	Numero di bit per esempio audio.
MF_MT_ALL_SAMPLES_INDEPENDENT	Specifica se ogni esempio audio è indipendente. Impostare su TRUE per i formati MFAudioFormat_PCM e MFAudioFormat_Float.

 

Inoltre, gli attributi seguenti sono necessari per alcuni formati audio.

Attributo	Descrizione
MF_MT_AUDIO_VALID_BITS_PER_SAMPLE	Numero di bit validi di dati audio in ogni esempio audio. Impostare questo attributo se gli esempi audio hanno spaziatura interna, ovvero se il numero di bit validi in ogni esempio audio è minore delle dimensioni del campione di esempio.
MF_MT_AUDIO_CHANNEL_MASK	Assegnazione di canali audio alle posizioni dell'altoparlante. Impostare questo attributo per flussi audio multicanale, ad esempio 5.1. Questo attributo non è obbligatorio per l'audio mono o stereo.

 

Codice di esempio

Il codice seguente illustra come creare un tipo di supporto per l'audio PCM non compresso.

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

L'esempio successivo accetta un formato audio codificato come input e crea un tipo audio PCM corrispondente. Questo tipo sarebbe adatto per impostare su un codificatore o decodificatore, ad esempio.

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

Argomenti correlati

Tipi di supporti audio