doubango-android/plugins/pluginWinAudioDSP/plugin_audio_dsp_resampler.cxx

/* Copyright (C) 2013 Mamadou DIOP
* Copyright (C) 2013 Doubango Telecom <http://www.doubango.org>
*
* This file is part of Open Source Doubango Framework.
*
* DOUBANGO is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* DOUBANGO is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with DOUBANGO.
*/
// MS Audio Resampler DSP: http://msdn.microsoft.com/en-us/library/windows/desktop/ff819070(v=vs.85).aspx
#include "plugin_audio_dsp_utils.h"

#include "tinymedia/tmedia_resampler.h"

#include "tsk_memory.h"
#include "tsk_debug.h"

#include <initguid.h>
#include <Wmcodecdsp.h>
#include <Mftransform.h>
#include <Mfapi.h>
#include <Mferror.h>

#if !defined(PLUGIN_AUDIO_DSP_RESAMPLER_MAX_QUALITY)
#	define PLUGIN_AUDIO_DSP_RESAMPLER_MAX_QUALITY 60 /* [1 - 60]: http://msdn.microsoft.com/en-us/library/windows/desktop/ff819449(v=vs.85).aspx */
#endif

static const UINT32 g_nBitsPerSample = 16;
static HRESULT ProcessOutput(struct plugin_audio_dsp_resampler_s *resampler, IMFSample **ppSample);

typedef struct plugin_audio_dsp_resampler_s {
    TMEDIA_DECLARE_RESAMPLER;

    bool bOpened;

    tsk_size_t in_size_samples;
    tsk_size_t in_size_bytes;
    tsk_size_t out_size_samples;
    tsk_size_t out_size_bytes;
    uint32_t in_channels;
    uint32_t out_channels;

    LONGLONG rtStart;
    UINT64 rtDuration;

    IMFTransform* pMFT;
    IMFSample *pSampleIn;
    IMFSample *pSampleOut;
}
plugin_audio_dsp_resampler_t;

// Doubango engine uses quality from [1 - 10].
static int plugin_audio_dsp_resampler_open(tmedia_resampler_t* self, uint32_t in_freq, uint32_t out_freq, uint32_t frame_duration, uint32_t in_channels, uint32_t out_channels, uint32_t quality)
{
    plugin_audio_dsp_resampler_t *resampler = (plugin_audio_dsp_resampler_t *)self;

    IMFMediaType* pTypeIn = NULL;
    IMFMediaType* pTypeOut = NULL;
    IWMResamplerProps* pProps = NULL;
    HRESULT hr = S_OK;

    if(in_channels != 1 && in_channels != 2) {
        TSK_DEBUG_ERROR("%d not valid as input channel", in_channels);
        CHECK_HR(hr = E_INVALIDARG);
    }
    if(out_channels != 1 && out_channels != 2) {
        TSK_DEBUG_ERROR("%d not valid as output channel", out_channels);
        CHECK_HR(hr = E_INVALIDARG);
    }

    if(resampler->bOpened) {
        TSK_DEBUG_ERROR("Resampler already opened");
        CHECK_HR(hr = E_FAIL);
    }

    resampler->in_size_samples  = ((in_freq * frame_duration) / 1000) << (in_channels == 2 ? 1 : 0);
    resampler->out_size_samples = ((out_freq * frame_duration) / 1000) << (out_channels == 2 ? 1 : 0);
    resampler->in_channels = in_channels;
    resampler->out_channels = out_channels;

    resampler->in_size_bytes = (resampler->in_size_samples * (g_nBitsPerSample >> 3));
    resampler->out_size_bytes = (resampler->out_size_samples * (g_nBitsPerSample >> 3));

    resampler->rtStart = 0;
    resampler->rtDuration = PLUGIN_AUDIO_DSP_MILLIS_TO_100NS(frame_duration); // milliseconds -> 100ns

    CHECK_HR(hr = CoCreateInstance(CLSID_CResamplerMediaObject, NULL,
                                   CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&resampler->pMFT)));

    CHECK_HR(hr = AudioDSPUtils::CreatePCMAudioType(in_freq, g_nBitsPerSample, in_channels, &pTypeIn));
    CHECK_HR(hr = AudioDSPUtils::CreatePCMAudioType(out_freq, g_nBitsPerSample, out_channels, &pTypeOut));

    CHECK_HR(hr = resampler->pMFT->SetInputType(0, pTypeIn, 0));
    CHECK_HR(hr = resampler->pMFT->SetOutputType(0, pTypeOut, 0));

    CHECK_HR(hr = resampler->pMFT->QueryInterface(IID_PPV_ARGS(&pProps)));
    CHECK_HR(hr = pProps->SetHalfFilterLength((quality * PLUGIN_AUDIO_DSP_RESAMPLER_MAX_QUALITY) / 10)); // [1 - 10] -> [1 - 60]

    CHECK_HR(hr = resampler->pMFT->ProcessMessage(MFT_MESSAGE_COMMAND_FLUSH, NULL));
    CHECK_HR(hr = resampler->pMFT->ProcessMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, NULL));
    CHECK_HR(hr = resampler->pMFT->ProcessMessage(MFT_MESSAGE_NOTIFY_START_OF_STREAM, NULL));

bail:
    resampler->bOpened = SUCCEEDED(hr);
    if(!resampler->bOpened) {
        SafeRelease(&resampler->pMFT);
    }
    SafeRelease(&pTypeIn);
    SafeRelease(&pTypeOut);
    SafeRelease(&pProps);
    return resampler->bOpened ? 0 : -1;
}

static tsk_size_t plugin_audio_dsp_resampler_process(tmedia_resampler_t* self, const uint16_t* in_data, tsk_size_t in_size, uint16_t* out_data, tsk_size_t out_size)
{
    plugin_audio_dsp_resampler_t *resampler = (plugin_audio_dsp_resampler_t *)self;

    HRESULT hr = S_OK;
    tsk_size_t retSize = 0;

    if(!resampler || !out_data) {
        CHECK_HR(hr = E_POINTER);
    }

    if(!resampler->bOpened) {
        TSK_DEBUG_ERROR("Resampler not opened");
        CHECK_HR(hr = E_FAIL);
    }

    if(in_size != resampler->in_size_samples) {
        TSK_DEBUG_ERROR("Input data has wrong size");
        CHECK_HR(hr = E_FAIL);
    }

    if(out_size < resampler->out_size_samples) {
        TSK_DEBUG_ERROR("Output data is too short");
        CHECK_HR(hr = E_FAIL);
    }

    IMFMediaBuffer* pBufferIn = NULL;
    IMFMediaBuffer* pBufferOut = NULL;
    IMFSample *pSampleOut = NULL;
    BYTE* pBufferPtr = NULL;

    if(!resampler->pSampleIn) {
        CHECK_HR(hr = AudioDSPUtils::CreateMediaSample(resampler->in_size_bytes, &resampler->pSampleIn));
        hr = resampler->pSampleIn->GetBufferByIndex(0, &pBufferIn);
        if(FAILED(hr)) {
            SafeRelease(&resampler->pSampleIn);
            CHECK_HR(hr);
        }
    }
    else {
        DWORD dwMaxLength = 0;
        CHECK_HR(hr = resampler->pSampleIn->GetBufferByIndex(0, &pBufferIn));
        CHECK_HR(hr = pBufferIn->GetMaxLength(&dwMaxLength));
        if(dwMaxLength < resampler->in_size_bytes) {
            CHECK_HR(hr = resampler->pSampleIn->RemoveAllBuffers());
            SafeRelease(&pBufferIn);
            CHECK_HR(hr = MFCreateMemoryBuffer(resampler->in_size_bytes, &pBufferIn));
            CHECK_HR(hr = resampler->pSampleIn->AddBuffer(pBufferIn));
        }
    }

    CHECK_HR(hr = pBufferIn->Lock(&pBufferPtr, NULL, NULL));
    memcpy(pBufferPtr, in_data, resampler->in_size_bytes);
    CHECK_HR(hr = pBufferIn->Unlock());
    CHECK_HR(hr = pBufferIn->SetCurrentLength(resampler->in_size_bytes));

    CHECK_HR(hr = resampler->pSampleIn->SetSampleDuration(resampler->rtDuration));
    CHECK_HR(hr = resampler->pSampleIn->SetSampleTime(resampler->rtStart));

    // Process input
    hr = resampler->pMFT->ProcessInput(0, resampler->pSampleIn, 0);
    if(hr == MF_E_NOTACCEPTING) {
        hr = S_OK;
    }
    CHECK_HR(hr);

    resampler->rtStart += resampler->rtDuration;

    // Process output
    CHECK_HR(hr = ProcessOutput(resampler, &pSampleOut));
    if(pSampleOut) {
        CHECK_HR(hr = pSampleOut->GetBufferByIndex(0, &pBufferOut));

        BYTE* pBufferOutPtr = NULL;
        DWORD dwDataLength = 0;
        CHECK_HR(hr = pBufferOut->GetCurrentLength(&dwDataLength));
        //if(dwDataLength == resampler->out_size_bytes)
        {
            CHECK_HR(hr = pBufferOut->Lock(&pBufferOutPtr, NULL, NULL));
            {
                memcpy(out_data, pBufferOutPtr, TSK_MIN(dwDataLength, resampler->out_size_bytes));
                if(dwDataLength < resampler->out_size_bytes) {
                    TSK_DEBUG_INFO("[MS Resampler DSP] Output too short filling with silence");
                    memset(&((uint8_t*)out_data)[dwDataLength], 0, (resampler->out_size_bytes - dwDataLength));
                }
                retSize = (tsk_size_t)resampler->out_size_bytes;
            }
            CHECK_HR(hr = pBufferOut->Unlock());
        }
    }


bail:
    SafeRelease(&pBufferIn);
    SafeRelease(&pBufferOut);
    SafeRelease(&pSampleOut);

    return retSize;
}

static int plugin_audio_dsp_resampler_close(tmedia_resampler_t* self)
{
    plugin_audio_dsp_resampler_t *resampler = (plugin_audio_dsp_resampler_t *)self;

    HRESULT hr = S_OK;

    if(resampler->pMFT) {
        hr = resampler->pMFT->ProcessMessage(MFT_MESSAGE_NOTIFY_END_OF_STREAM, NULL);
    }

    SafeRelease(&resampler->pMFT);
    SafeRelease(&resampler->pSampleIn);
    SafeRelease(&resampler->pSampleOut);

    resampler->bOpened = false;

    return 0;
}

static HRESULT ProcessOutput(plugin_audio_dsp_resampler_t *resampler, IMFSample **ppSample)
{
    *ppSample = NULL;

    IMFMediaBuffer* pBufferOut = NULL;

    DWORD dwStatus;

    HRESULT hr = S_OK;

    MFT_OUTPUT_DATA_BUFFER mftOutputData = { 0 };

    if(!resampler || !ppSample) {
        CHECK_HR(hr = E_POINTER);
    }

    if(!resampler->pSampleOut) {
        CHECK_HR(hr = AudioDSPUtils::CreateMediaSample(resampler->out_size_bytes, &resampler->pSampleOut));
        hr = resampler->pSampleOut->GetBufferByIndex(0, &pBufferOut);
        if(FAILED(hr)) {
            SafeRelease(&resampler->pSampleOut);
            CHECK_HR(hr);
        }
    }
    else {
        DWORD dwMaxLength = 0;
        CHECK_HR(hr = resampler->pSampleOut->GetBufferByIndex(0, &pBufferOut));
        CHECK_HR(hr = pBufferOut->GetMaxLength(&dwMaxLength));
        if(dwMaxLength < resampler->out_size_bytes) {
            CHECK_HR(hr = resampler->pSampleOut->RemoveAllBuffers());
            SafeRelease(&pBufferOut);
            CHECK_HR(hr = MFCreateMemoryBuffer(resampler->out_size_bytes, &pBufferOut));
            CHECK_HR(hr = resampler->pSampleOut->AddBuffer(pBufferOut));
        }
    }

    CHECK_HR(hr = pBufferOut->SetCurrentLength(0));

    //Set the output sample
    mftOutputData.pSample = resampler->pSampleOut;
    //Set the output id
    mftOutputData.dwStreamID = 0;

    //Generate the output sample
    hr = resampler->pMFT->ProcessOutput(0, 1, &mftOutputData, &dwStatus);
    if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
        hr = S_OK;
        goto bail;
    }

    // TODO: Handle MF_E_TRANSFORM_STREAM_CHANGE

    if (FAILED(hr)) {
        goto bail;
    }

    *ppSample = resampler->pSampleOut;
    (*ppSample)->AddRef();

bail:
    SafeRelease(&pBufferOut);
    return hr;
}



//
//	Speex resamplerr Plugin definition
//

/* constructor */
static tsk_object_t* plugin_audio_dsp_resampler_ctor(tsk_object_t * self, va_list * app)
{
    plugin_audio_dsp_resampler_t *resampler = (plugin_audio_dsp_resampler_t *)self;
    if(resampler) {
        AudioDSPUtils::Startup();

        /* init base */
        tmedia_resampler_init(TMEDIA_RESAMPLER(resampler));
        /* init self */
    }
    return self;
}
/* destructor */
static tsk_object_t* plugin_audio_dsp_resampler_dtor(tsk_object_t * self)
{
    plugin_audio_dsp_resampler_t *resampler = (plugin_audio_dsp_resampler_t *)self;
    if(resampler) {
        /* deinit base */
        tmedia_resampler_deinit(TMEDIA_RESAMPLER(resampler));
        /* deinit self */
        // tmedia_resampler_deinit() already closed the resampler and freed the resources...but do it again
        SafeRelease(&resampler->pMFT);
        SafeRelease(&resampler->pSampleIn);
        SafeRelease(&resampler->pSampleOut);

        TSK_DEBUG_INFO("*** MS Audio Resampler DSP (plugin) destroyed ***");
    }

    return self;
}
/* object definition */
static const tsk_object_def_t plugin_audio_dsp_resampler_def_s = {
    sizeof(plugin_audio_dsp_resampler_t),
    plugin_audio_dsp_resampler_ctor,
    plugin_audio_dsp_resampler_dtor,
    tsk_null,
};
/* plugin definition*/
static const tmedia_resampler_plugin_def_t plugin_audio_dsp_resampler_plugin_def_s = {
    &plugin_audio_dsp_resampler_def_s,

    "MS Audio Resampler DSP", /* http://msdn.microsoft.com/en-us/library/windows/desktop/ff819070(v=vs.85).aspx */

    plugin_audio_dsp_resampler_open,
    plugin_audio_dsp_resampler_process,
    plugin_audio_dsp_resampler_close,
};
const tmedia_resampler_plugin_def_t *plugin_audio_dsp_resampler_plugin_def_t = &plugin_audio_dsp_resampler_plugin_def_s;