#include "stdafx.h"

#include <mfapi.h>

#include <wmcodecdsp.h>

#include <Mferror.h>

#include <stdexcept>

#include <propvarutil.h>

#include "AudioEncoder.h"

static void SetBooleanPropertyStoreValue(IPropertyStore* propertyStore, const PROPERTYKEY& key, BOOL value)

}

static void SetUint32PropertyStoreValue(IPropertyStore* propertyStore, const PROPERTYKEY& key, UINT32 value)

}

AudioEncoderParameters::AudioEncoderParameters(CompressionFamily compressionFamily, UINT32 qualityLevel, UINT32 channelCount, UINT32 samplesPerSecond, UINT32 bitsPerSample)

}

AudioEncoderParameters* AudioEncoderParameters::CreateQualityBasedVbrParameters(UINT32 qualityLevel, UINT32 channelCount, UINT32 samplesPerSecond, UINT32 bitsPerSample)

{

// TODO add parameter validation

return new AudioEncoderParameters(CompressionFamily::QualityBasedVariableBitRate, qualityLevel, channelCount, samplesPerSecond, bitsPerSample);

}

AudioEncoderParameters* AudioEncoderParameters::CreateLosslessEncoderParameters(UINT32 channelCount, UINT32 samplesPerSecond, UINT32 bitsPerSample)

{

return new AudioEncoderParameters(CompressionFamily::Lossless, 100, channelCount, samplesPerSecond, bitsPerSample);

}

BOOL AudioEncoderParameters::IsLossless()

{

return _compressionFamily == CompressionFamily::Lossless;

}

BOOL AudioEncoderParameters::IsQualityBasedVbr()

{

return (_compressionFamily == CompressionFamily::QualityBasedVariableBitRate) || (_compressionFamily == CompressionFamily::Lossless);

}

UINT32 AudioEncoderParameters::GetQualityLevel()

{

return _qualityLevel;

}

UINT32 AudioEncoderParameters::GetChannelCount()

{

return _channelCount;

}

UINT32 AudioEncoderParameters::GetBitsPerSample()

{

return _bitsPerSample;

}

UINT32 AudioEncoderParameters::GetSamplesPerSecond()

{

return _samplesPerSecond;

}

IMFMediaType* AudioEncoder::GetEncoderMediaType(AudioEncoderParameters* encoderParameters)

{

IMFMediaType* result;

IPropertyStore *propertyStore = nullptr; // TODO when can this be released safely?

//We need to find a suitable output media type

//We need to create the encoder to get the available output types

//and discard the instance.

IMFActivate **transformActivationObjs;

UINT32 transformCount;

MFT_REGISTER_TYPE_INFO regTypeInfo;

regTypeInfo.guidMajorType = MFMediaType_Audio;

regTypeInfo.guidSubtype = (encoderParameters->IsLossless()) ? MFAudioFormat_WMAudio_Lossless : MFAudioFormat_WMAudioV8;

// Look for an encoder.

HRESULT hr = MFTEnumEx(MFT_CATEGORY_AUDIO_ENCODER, MFT_ENUM_FLAG_TRANSCODE_ONLY, nullptr, &regTypeInfo, &transformActivationObjs, &transformCount);

if ((hr != S_OK) || (transformCount < 1))

throw std::exception("No Media Foundation encoders found");

// Regardless how many activation objects returned, just instantiate the first one

// (would I want to instantiate another? Why? Which one?)

IMFActivate *activationObj = *transformActivationObjs;

IMFTransform *mfEncoder = nullptr;

WCHAR transformName[128];

UINT32 nameLen;

do

{

if (!SUCCEEDED(hr = activationObj->GetString(MFT_FRIENDLY_NAME_Attribute, transformName, sizeof(transformName), &nameLen)))

break;

if (!SUCCEEDED(activationObj->ActivateObject(IID_PPV_ARGS(&mfEncoder))))

break;

if (encoderParameters->IsQualityBasedVbr())

{

if (!SUCCEEDED(hr = mfEncoder->QueryInterface(IID_PPV_ARGS(&propertyStore))))

break;

SetEncoderPropertiesForQualityBasedVbr(propertyStore, encoderParameters->GetQualityLevel());

}

} while (0);

if (FAILED(hr))

throw std::exception("Unable to activate encoder MFT");

// enumerate output types and try to find the appropriate one for our purposes

UINT32 channelCount, samplesPerSecond, bitsPerSample;

DWORD index = 0;

int desiredChannelCount = encoderParameters->GetChannelCount();

int desiredSamplesPerSecond = encoderParameters->GetSamplesPerSecond();

int desiredBitsPerSample = encoderParameters->GetBitsPerSample();

while (true)

{

IMFMediaType *mediaType;

hr = mfEncoder->GetOutputAvailableType(0, index++, &mediaType);

if (hr == MF_E_NO_MORE_TYPES)

break;

// Get the AM_MEDIA_TYPE structure from the media type, in case we want to need

// to differentiate between Standard and Pro WMA codecs in the future...

AM_MEDIA_TYPE *amMediaType;

mediaType->GetRepresentation(AM_MEDIA_TYPE_REPRESENTATION, (LPVOID *)&amMediaType);

WAVEFORMATEX *waveFormat = (WAVEFORMATEX *)amMediaType->pbFormat;

// there's only a few things we're interested in with the output type, so only bother grabbing those values

hr = mediaType->GetUINT32(MF_MT_AUDIO_NUM_CHANNELS, &channelCount);

hr = mediaType->GetUINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, &samplesPerSecond);

hr = mediaType->GetUINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, &bitsPerSample);

if ((channelCount == desiredChannelCount) && (samplesPerSecond == desiredSamplesPerSecond) && (bitsPerSample == desiredBitsPerSample))

{

result = mediaType;

break;

}

else

{

mediaType->Release();

}

}

if (propertyStore) propertyStore->Release();

if (mfEncoder) mfEncoder->Release();

activationObj->ShutdownObject();

// release all the activation pointers that got allocated...

for (UINT32 i = 0; i < transformCount; i++)

{

IMFActivate *temp = *(transformActivationObjs + i);

temp->Release();

}

// ...and free the activation array object

CoTaskMemFree(transformActivationObjs);

return result;

}

void AudioEncoder::SetEncoderPropertiesForQualityBasedVbr(IPropertyStore* propertyStore, UINT32 quality)

}

static IMFTopology* BuildEncodingTopography(MediaSource* source, IMFTransform* audioEncoder, MediaSink* sink)

{

IMFTopology* mfTopology = nullptr;

IMFTopologyNode* encoderNode = nullptr;

IMFTopologyNode* sourceNode = nullptr;

IMFTopologyNode* outputNode = nullptr;

//Create the topology that represents the encoding pipeline

HRESULT hr = MFCreateTopology(&mfTopology);

do {

// Add source node

sourceNode = source->CreateTopologySourceNode();

if (!SUCCEEDED(hr = mfTopology->AddNode(sourceNode)))

break;

// Add encoder node

// this is a little more convoluted than hoped for, but bear with me.

// at first glance it seems odd that we'd create the compressor transform

// through the MediaSink object. But, it turns

// out the the media sink holds the two main ingredients needed to

// create the encoder: the output stream MediaType, and, crucially,

// the EncodingConfigurationPropertyStore that's a requirement if

// you want to do quality-based VBR.

//

// Originally I had a method in MediaSink that functioned similiar to the

// MediaSource::CreateTopologySourceNode() and MediaSink::CreateTopologyOutputNode().

// This worked ok, but another problem with quality-based VBR is (apparently)

// you're supposed to set some properties on the output stream,

// based on values computed by the encoder during compressions.

// The original example code jumped thorugh hoops to get back a reference

// to the encoder by traversing the full topology, but I felt

// it was much more understandable to first save a reference to

// the actual encoder object, and use that for the post-processing

// property patch.

//

// Say that ten times quick!

hr = MFCreateTopologyNode(MF_TOPOLOGY_TRANSFORM_NODE, &encoderNode);

// Set the object pointer.

hr = encoderNode->SetObject(audioEncoder);

if (!SUCCEEDED(hr = mfTopology->AddNode(encoderNode)))

break;

// connect the source node to the encoder

if (!SUCCEEDED(hr = sourceNode->ConnectOutput(0, encoderNode, 0)))

break;

// Add sink node

outputNode = sink->CreateTopologyOutputNode(1);

if (!SUCCEEDED(hr = mfTopology->AddNode(outputNode)))

break;

// connect the transform node to the output node

if (!SUCCEEDED(hr = encoderNode->ConnectOutput(0, outputNode, 0)))

break;

} while (0);

if (sourceNode) sourceNode->Release();

if (outputNode) outputNode->Release();

if (encoderNode) encoderNode->Release();

if (FAILED(hr))

throw std::exception("Unable to construct topology");

return mfTopology;

}

static HRESULT UpdateVbrStreamProperties(IMFTransform* audioEncoder, MediaSink* mediaSink)

}

static HRESULT GetNextMediaSessionEvent(IMFMediaSession* mfMediaSession, MediaEventType* mediaEventType, MF_TOPOSTATUS* eventTopologyStatus)

}

void AudioEncoder::Encode(MediaSource* mediaSource, MediaSink* mediaSink, AudioEncoderParameters* encoderParameters)