/*

 *  LAME MP3 encoder for DirectShow

 *  DirectShow filter implementation

 *

 *  Copyright (c) 2000-2005 Marie Orlova, Peter Gubanov, Vitaly Ivanov, Elecard Ltd.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include <streams.h>

#include <olectl.h>

#include <initguid.h>

//#include <olectlid.h>

#include "uids.h"

#include "iaudioprops.h"

#include "mpegac.h"

#include "resource.h"

#include "PropPage.h"

#include "PropPage_adv.h"

#include "aboutprp.h"

#include "Encoder.h"

#include "Reg.h"

#ifndef _INC_MMREG

#include <mmreg.h>

#endif

// default parameters

#define         DEFAULT_LAYER               3

#define         DEFAULT_STEREO_MODE         JOINT_STEREO

#define         DEFAULT_FORCE_MS            0

#define         DEFAULT_MODE_FIXED          0

#define         DEFAULT_ENFORCE_MIN         0

#define         DEFAULT_VOICE               0

#define         DEFAULT_KEEP_ALL_FREQ       0

#define         DEFAULT_STRICT_ISO          0

#define         DEFAULT_DISABLE_SHORT_BLOCK 0

#define         DEFAULT_XING_TAG            0

#define         DEFAULT_SAMPLE_RATE         44100

#define         DEFAULT_BITRATE             128

#define         DEFAULT_VARIABLE            0

#define         DEFAULT_CRC                 0

#define         DEFAULT_FORCE_MONO          0

#define         DEFAULT_SET_DURATION        1

#define         DEFAULT_SAMPLE_OVERLAP      1

#define         DEFAULT_COPYRIGHT           0

#define         DEFAULT_ORIGINAL            0

#define         DEFAULT_VARIABLEMIN         80

#define         DEFAULT_VARIABLEMAX         160

#define         DEFAULT_ENCODING_QUALITY    5

#define         DEFAULT_VBR_QUALITY         4

#define         DEFAULT_PES                 0

#define         DEFAULT_FILTER_MERIT        MERIT_DO_NOT_USE                // Standard compressor merit value

#define GET_DATARATE(kbps) (kbps * 1000 / 8)

#define GET_FRAMELENGTH(bitrate, sample_rate) ((WORD)(((sample_rate < 32000 ? 72000 : 144000) * (bitrate))/(sample_rate)))

#define DECLARE_PTR(type, ptr, expr) type* ptr = (type*)(expr);

// Create a list of all (or mostly all) of the encoder CBR output capabilities which

// will be parsed into a list of capabilities used by the IAMStreamConfig Interface

output_caps_t OutputCapabilities[] = 

{ // {SampleRate, BitRate}

    { 48000, 320 },{ 48000, 256 },{ 48000, 224 },{ 48000, 192 },            // MPEG 1.0 Spec @ 48KHz

    { 48000, 160 },{ 48000, 128 },{ 48000, 112 },{ 48000, 96 },

    { 48000, 80 },{ 48000, 64 },{ 48000, 56 },{ 48000, 48 },

    { 48000, 40 },{ 48000, 32 },

    { 24000, 160 },{ 24000, 144 },{ 24000, 128 },{ 24000, 112 },            // MPEG 2.0 Spec @ 24KHz

    { 24000, 96 },{ 24000, 80 },{ 24000, 64 },{ 24000, 56 },

    { 24000, 48 },{ 24000, 40 },{ 24000, 32 },{ 24000, 24 },

    { 24000, 16 },{ 24000, 8 },

    { 12000, 64 },{ 12000, 56 },{ 12000, 48 },{ 12000, 40 },                // MPEG 2.5 Spec @ 12KHz

    { 12000, 32 },{ 12000, 24 },{ 12000, 16 },{ 12000, 8 },

    // ---------------------------                                          --------------------------

    { 44100, 320 },{ 44100, 256 },{ 44100, 224 },{ 44100, 192 },            // MPEG 1.0 Spec @ 44.1KHz

    { 44100, 160 },{ 44100, 128 },{ 44100, 112 },{ 44100, 96 },

    { 44100, 80 },{ 44100, 64 },{ 44100, 56 },{ 44100, 48 },

    { 44100, 40 },{ 44100, 32 },

    { 22050, 160 },{ 22050, 144 },{ 22050, 128 },{ 22050, 112 },            // MPEG 2.0 Spec @ 22.05KHz

    { 22050, 96 },{ 22050, 80 },{ 22050, 64 },{ 22050, 56 },

    { 22050, 48 },{ 22050, 40 },{ 22050, 32 },{ 22050, 24 },

    { 22050, 16 },{ 22050, 8 },

    { 11025, 64 },{ 11025, 56 },{ 11025, 48 },{ 11025, 40 },                // MPEG 2.5 Spec @ 11.025KHz

    { 11025, 32 },{ 11025, 24 },{ 11025, 16 },{ 11025, 8 },

    // ---------------------------                                          --------------------------

    { 32000, 320 },{ 32000, 256 },{ 32000, 224 },{ 32000, 192 },            // MPEG 1.0 Spec @ 32KHz

    { 32000, 160 },{ 32000, 128 },{ 32000, 112 },{ 32000, 96 },

    { 32000, 80 },{ 32000, 64 },{ 32000, 56 },{ 32000, 48 },

    { 32000, 40 },{ 32000, 32 },

    { 16000, 160 },{ 16000, 144 },{ 16000, 128 },{ 16000, 112 },            // MPEG 2.0 Spec @ 16KHz

    { 16000, 96 },{ 16000, 80 },{ 16000, 64 },{ 16000, 56 },

    { 16000, 48 },{ 16000, 40 },{ 16000, 32 },{ 16000, 24 },

    { 16000, 16 },{ 16000, 8 },

    { 8000, 64 },{ 8000, 56 },{ 8000, 48 },{ 8000, 40 },                    // MPEG 2.5 Spec @ 8KHz

    { 8000, 32 },{ 8000, 24 },{ 8000, 16 },{ 8000, 8 }

};

/*  Registration setup stuff */

//  Setup data

AMOVIESETUP_MEDIATYPE sudMpgInputType[] =

{

    { &MEDIATYPE_Audio, &MEDIASUBTYPE_PCM }

};

AMOVIESETUP_MEDIATYPE sudMpgOutputType[] =

{

    { &MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1AudioPayload },

    { &MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG2_AUDIO },

    { &MEDIATYPE_Audio, &MEDIASUBTYPE_MP3 },

    { &MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Audio }

};

AMOVIESETUP_PIN sudMpgPins[] =

{

    { L"PCM Input",

      FALSE,                               // bRendered

      FALSE,                               // bOutput

      FALSE,                               // bZero

      FALSE,                               // bMany

      &CLSID_NULL,                         // clsConnectsToFilter

      NULL,                                // ConnectsToPin

      NUMELMS(sudMpgInputType),            // Number of media types

      sudMpgInputType

    },

    { L"MPEG Output",

      FALSE,                               // bRendered

      TRUE,                                // bOutput

      FALSE,                               // bZero

      FALSE,                               // bMany

      &CLSID_NULL,                         // clsConnectsToFilter

      NULL,                                // ConnectsToPin

      NUMELMS(sudMpgOutputType),           // Number of media types

      sudMpgOutputType

    }

};

AMOVIESETUP_FILTER sudMpgAEnc =

{

	&CLSID_LAMEDShowFilter,

    L"LAME Audio Encoder",

    DEFAULT_FILTER_MERIT,                  // Standard compressor merit value

    NUMELMS(sudMpgPins),                   // 2 pins

    sudMpgPins

};

/*****************************************************************************/

// COM Global table of objects in this dll

static WCHAR g_wszName[] = L"LAME Audio Encoder";

CFactoryTemplate g_Templates[] = 

{

  { g_wszName, &CLSID_LAMEDShowFilter, CMpegAudEnc::CreateInstance, NULL, &sudMpgAEnc },

  { L"LAME Audio Encoder Property Page", &CLSID_LAMEDShow_PropertyPage, CMpegAudEncPropertyPage::CreateInstance},

  { L"LAME Audio Encoder Property Page", &CLSID_LAMEDShow_PropertyPageAdv, CMpegAudEncPropertyPageAdv::CreateInstance},

  { L"LAME Audio Encoder About", &CLSID_LAMEDShow_About, CMAEAbout::CreateInstance}

};

// Count of objects listed in g_cTemplates

int g_cTemplates = sizeof(g_Templates) / sizeof(g_Templates[0]);

////////////////////////////////////////////

// Declare the DirectShow filter information.

// Used by IFilterMapper2() in the call to DllRegisterServer()

// to register the filter in the CLSID_AudioCompressorCategory.

REGFILTER2 rf2FilterReg = {

    1,                     // Version number.

    DEFAULT_FILTER_MERIT,  // Merit. This should match the merit specified in the AMOVIESETUP_FILTER definition

    NUMELMS(sudMpgPins),   // Number of pins.

    sudMpgPins             // Pointer to pin information.

};

STDAPI DllRegisterServer(void)

{

    HRESULT hr = AMovieDllRegisterServer2(TRUE);

    if (FAILED(hr)) {

        return hr;

    }

    IFilterMapper2 *pFM2 = NULL;

    hr = CoCreateInstance(CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER, IID_IFilterMapper2, (void **)&pFM2);

    if (SUCCEEDED(hr)) {

        hr = pFM2->RegisterFilter(

            CLSID_LAMEDShowFilter,           // Filter CLSID. 

            g_wszName,                       // Filter name.

            NULL,                            // Device moniker. 

            &CLSID_AudioCompressorCategory,  // Audio compressor category.

            g_wszName,                       // Instance data.

            &rf2FilterReg                    // Filter information.

            );

        pFM2->Release();

    }

    return hr;

}

STDAPI DllUnregisterServer()

{

    HRESULT hr = AMovieDllRegisterServer2(FALSE);

    if (FAILED(hr)) {

        return hr;

    }

    IFilterMapper2 *pFM2 = NULL;

    hr = CoCreateInstance(CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER, IID_IFilterMapper2, (void **)&pFM2);

    if (SUCCEEDED(hr)) {

        hr = pFM2->UnregisterFilter(&CLSID_AudioCompressorCategory, g_wszName, CLSID_LAMEDShowFilter);

        pFM2->Release();

    }

    return hr;

}

CUnknown *CMpegAudEnc::CreateInstance(LPUNKNOWN lpunk, HRESULT *phr) 

{

    CMpegAudEnc *punk = new CMpegAudEnc(lpunk, phr);

    if (punk == NULL) 

        *phr = E_OUTOFMEMORY;

    return punk;

}

CMpegAudEnc::CMpegAudEnc(LPUNKNOWN lpunk, HRESULT *phr)

 :  CTransformFilter(NAME("LAME Audio Encoder"), lpunk, CLSID_LAMEDShowFilter),

    CPersistStream(lpunk, phr)

{

    // ENCODER OUTPUT PIN

    // Override the output pin with our own which will implement the IAMStreamConfig Interface

    CTransformOutputPin *pOut = new CMpegAudEncOutPin( this, phr );

    if (pOut == NULL) {

        *phr = E_OUTOFMEMORY;

        return;

    }

    else if (FAILED(*phr)) {             // A failed return code should delete the object

        delete pOut;

        return;

    }

    m_pOutput = pOut;

    // ENCODER INPUT PIN

    // Since we've created our own output pin we must also create

    // the input pin ourselves because the CTransformFilter base class 

    // will create an extra output pin if the input pin wasn't created.        

    CTransformInputPin *pIn = new CTransformInputPin(NAME("LameEncoderInputPin"),

                                                     this,              // Owner filter

                                                     phr,               // Result code

                                                     L"Input");         // Pin name

    if (pIn == NULL) {

        *phr = E_OUTOFMEMORY;

        return;

    }

    else if (FAILED(*phr)) {             // A failed return code should delete the object

        delete pIn;

        return;

    }

    m_pInput = pIn;

    MPEG_ENCODER_CONFIG mec;

    ReadPresetSettings(&mec;;

    m_Encoder.SetOutputType(mec);

    m_CapsNum = 0;

    m_hasFinished = TRUE;

    m_bStreamOutput = FALSE;

    m_currentMediaTypeIndex = 0;

}

CMpegAudEnc::~CMpegAudEnc(void)

{

}

LPAMOVIESETUP_FILTER CMpegAudEnc::GetSetupData()

{

    return &sudMpgAEnc;

}

HRESULT CMpegAudEnc::Receive(IMediaSample * pSample)

{

    CAutoLock lock(&m_cs);

    if (!pSample)

        return S_OK;

    BYTE * pSourceBuffer = NULL;

    if (pSample->GetPointer(&pSourceBuffer) != S_OK || !pSourceBuffer)

        return S_OK;

    long sample_size = pSample->GetActualDataLength();

    REFERENCE_TIME rtStart, rtStop;

    BOOL gotValidTime = (pSample->GetTime(&rtStart, &rtStop) != VFW_E_SAMPLE_TIME_NOT_SET);

    if (sample_size <= 0 || pSourceBuffer == NULL || m_hasFinished || (gotValidTime && rtStart < 0))

        return S_OK;

    if (gotValidTime)

    {

        if (m_rtStreamTime < 0)

        {

            m_rtStreamTime = rtStart;

            m_rtEstimated = rtStart;

        }

        else

        {

            resync_point_t * sync = m_sync + m_sync_in_idx;

            if (sync->applied)

            {

                REFERENCE_TIME rtGap = rtStart - m_rtEstimated;

                // if old sync data is applied and gap is greater than 1 ms

                // then make a new synchronization point

                if (rtGap > 10000 || (m_allowOverlap && rtGap < -10000))

                {

                    sync->sample    = m_samplesIn;

                    sync->delta     = rtGap;

                    sync->applied   = FALSE;

                    m_rtEstimated  += sync->delta;

                    if (m_sync_in_idx < (RESYNC_COUNT - 1))

                        m_sync_in_idx++;

                    else

                        m_sync_in_idx = 0;

                }

            }

        }

    }

    m_rtEstimated   += (LONGLONG)(m_bytesToDuration * sample_size);

    m_samplesIn     += sample_size / m_bytesPerSample;

    while (sample_size > 0)

    {

        int bytes_processed = m_Encoder.Encode((short *)pSourceBuffer, sample_size);

        if (bytes_processed <= 0)

            return S_OK;

        FlushEncodedSamples();

        sample_size     -= bytes_processed;

        pSourceBuffer   += bytes_processed;

    }

    return S_OK;

}

HRESULT CMpegAudEnc::FlushEncodedSamples()

{

    IMediaSample * pOutSample = NULL;

    BYTE * pDst = NULL;

	if(m_bStreamOutput)

	{

		HRESULT hr = S_OK;

		const unsigned char *   pblock      = NULL;

		int iBufferSize;

		int iBlockLength = m_Encoder.GetBlockAligned(&pblock, &iBufferSize, m_cbStreamAlignment);

		if(!iBlockLength)

			return S_OK;

		hr = m_pOutput->GetDeliveryBuffer(&pOutSample, NULL, NULL, 0);

		if (hr == S_OK && pOutSample)

		{

			hr = pOutSample->GetPointer(&pDst);

			if (hr == S_OK && pDst)

			{

				CopyMemory(pDst, pblock, iBlockLength);

				REFERENCE_TIME rtEndPos = m_rtBytePos + iBufferSize;

				EXECUTE_ASSERT(S_OK == pOutSample->SetTime(&m_rtBytePos, &rtEndPos));

				pOutSample->SetActualDataLength(iBufferSize);

				m_rtBytePos += iBlockLength;

				m_pOutput->Deliver(pOutSample);

			}

			pOutSample->Release();

		}

		return S_OK;

	}

    if (m_rtStreamTime < 0)

        m_rtStreamTime = 0;

    while (1)

    {

        const unsigned char *   pframe      = NULL;

        int                     frame_size  = m_Encoder.GetFrame(&pframe);

        if (frame_size <= 0 || !pframe)

            break;

        if (!m_sync[m_sync_out_idx].applied && m_sync[m_sync_out_idx].sample <= m_samplesOut)

        {

            m_rtStreamTime += m_sync[m_sync_out_idx].delta;

            m_sync[m_sync_out_idx].applied = TRUE;

            if (m_sync_out_idx < (RESYNC_COUNT - 1))

                m_sync_out_idx++;

            else

                m_sync_out_idx = 0;

        }

        REFERENCE_TIME rtStart = m_rtStreamTime;

        REFERENCE_TIME rtStop = rtStart + m_rtFrameTime;

		HRESULT hr = S_OK;

		hr = m_pOutput->GetDeliveryBuffer(&pOutSample, NULL, NULL, 0);

		if (hr == S_OK && pOutSample)

		{

			hr = pOutSample->GetPointer(&pDst);

			if (hr == S_OK && pDst)

			{

				CopyMemory(pDst, pframe, frame_size);

				pOutSample->SetActualDataLength(frame_size);

				pOutSample->SetSyncPoint(TRUE);

				pOutSample->SetTime(&rtStart, m_setDuration ? &rtStop : NULL);

				m_pOutput->Deliver(pOutSample);

			}

			pOutSample->Release();

		}

        m_samplesOut += m_samplesPerFrame;

        m_rtStreamTime = rtStop;

    }

    return S_OK;

}

////////////////////////////////////////////////////////////////////////////

//  StartStreaming - prepare to receive new data

////////////////////////////////////////////////////////////////////////////

HRESULT CMpegAudEnc::StartStreaming()

{

    WAVEFORMATEX * pwfxIn  = (WAVEFORMATEX *) m_pInput->CurrentMediaType().Format();

    m_bytesPerSample    = pwfxIn->nChannels * sizeof(short);

	DWORD dwOutSampleRate;

	if(MEDIATYPE_Stream == m_pOutput->CurrentMediaType().majortype)

	{

		MPEG_ENCODER_CONFIG mcfg;

		if(FAILED(m_Encoder.GetOutputType(&mcfg)))

			return E_FAIL;

		dwOutSampleRate = mcfg.dwSampleRate;

	}

	else

	{

		dwOutSampleRate = ((WAVEFORMATEX *) m_pOutput->CurrentMediaType().Format())->nSamplesPerSec;

	}

	m_samplesPerFrame   = (dwOutSampleRate >= 32000) ? 1152 : 576;

    m_rtFrameTime = MulDiv(10000000, m_samplesPerFrame, dwOutSampleRate);

    m_samplesIn = m_samplesOut = 0;

    m_rtStreamTime = -1;

	m_rtBytePos = 0;

    // initialize encoder

    m_Encoder.Init();

    m_hasFinished   = FALSE;

    for (int i = 0; i < RESYNC_COUNT; i++)

    {

        m_sync[i].sample   = 0;

        m_sync[i].delta    = 0;

        m_sync[i].applied  = TRUE;

    }

    m_sync_in_idx = 0;

    m_sync_out_idx = 0;

    get_SetDuration(&m_setDuration);

    get_SampleOverlap(&m_allowOverlap);

	return S_OK;

}

HRESULT CMpegAudEnc::StopStreaming()

{

	IStream *pStream = NULL;

	if(m_bStreamOutput && m_pOutput->IsConnected() != FALSE)

	{

		IPin * pDwnstrmInputPin = m_pOutput->GetConnected();

		if(pDwnstrmInputPin && FAILED(pDwnstrmInputPin->QueryInterface(IID_IStream, (LPVOID*)(&pStream))))

		{

			pStream = NULL;

		}

	}

	m_Encoder.Close(pStream);

	if(pStream)

		pStream->Release();

    return S_OK;

}

////////////////////////////////////////////////////////////////////////////

//  EndOfStream - stop data processing 

////////////////////////////////////////////////////////////////////////////

HRESULT CMpegAudEnc::EndOfStream()

{

    CAutoLock lock(&m_cs);

    // Flush data

    m_Encoder.Finish();

    FlushEncodedSamples();

	IStream *pStream = NULL;

    if(m_bStreamOutput && m_pOutput->IsConnected() != FALSE)

	{

		IPin * pDwnstrmInputPin = m_pOutput->GetConnected();

		if(pDwnstrmInputPin)

		{

			if(FAILED(pDwnstrmInputPin->QueryInterface(IID_IStream, (LPVOID*)(&pStream))))

			{

				pStream = NULL;	

			}

		}

	}

	if(pStream)

	{

		ULARGE_INTEGER size;

		size.QuadPart = m_rtBytePos;

		pStream->SetSize(size);	

	}

	m_Encoder.Close(pStream);

	if(pStream)

		pStream->Release();

    m_hasFinished = TRUE;

    return CTransformFilter::EndOfStream();

}

////////////////////////////////////////////////////////////////////////////

//  BeginFlush  - stop data processing 

////////////////////////////////////////////////////////////////////////////

HRESULT CMpegAudEnc::BeginFlush()

{

    HRESULT hr = CTransformFilter::BeginFlush();

    if (SUCCEEDED(hr))

    {

        CAutoLock lock(&m_cs);

        DWORD dwDstSize = 0;

        // Flush data

        m_Encoder.Finish();

        FlushEncodedSamples();

		IStream *pStream = NULL;

		if(m_bStreamOutput && m_pOutput->IsConnected() != FALSE)

		{

			IPin * pDwnstrmInputPin = m_pOutput->GetConnected();

			if(pDwnstrmInputPin && SUCCEEDED(pDwnstrmInputPin->QueryInterface(IID_IStream, (LPVOID*)(&pStream))))

			{

				ULARGE_INTEGER size;

				size.QuadPart = m_rtBytePos;

				pStream->SetSize(size);	

				pStream->Release();

			}

		}

	    m_rtStreamTime = -1;

		m_rtBytePos = 0;

    }

    return hr;

}

////////////////////////////////////////////////////////////////////////////

//	SetMediaType - called when filters are connecting

////////////////////////////////////////////////////////////////////////////

HRESULT CMpegAudEnc::SetMediaType(PIN_DIRECTION direction, const CMediaType * pmt)

{

    HRESULT hr = S_OK;

    if (direction == PINDIR_INPUT)

    {

		if (*pmt->FormatType() != FORMAT_WaveFormatEx)

        return VFW_E_INVALIDMEDIATYPE;

		if (pmt->FormatLength() < sizeof(WAVEFORMATEX))

			return VFW_E_INVALIDMEDIATYPE;

        DbgLog((LOG_TRACE,1,TEXT("CMpegAudEnc::SetMediaType(), direction = PINDIR_INPUT")));

        // Pass input media type to encoder

        m_Encoder.SetInputType((LPWAVEFORMATEX)pmt->Format());

        WAVEFORMATEX * pwfx = (WAVEFORMATEX *)pmt->Format();

        if (pwfx)

            m_bytesToDuration = (float)1.e7 / (float)(pwfx->nChannels * sizeof(short) * pwfx->nSamplesPerSec);

        else

            m_bytesToDuration = 0.0;

        // Parse the encoder output capabilities into the subset of capabilities that are supported 

        // for the current input format. This listing will be utilized by the IAMStreamConfig Interface.

        LoadOutputCapabilities(pwfx->nSamplesPerSec);

        Reconnect();

    }

    else if (direction == PINDIR_OUTPUT)

    {

        // Before we set the output type, we might need to reconnect 

        // the input pin with a new type.

        if (m_pInput && m_pInput->IsConnected()) 

        {

            // Check if the current input type is compatible.

            hr = CheckTransform(&m_pInput->CurrentMediaType(), &m_pOutput->CurrentMediaType());

            if (FAILED(hr)) {

                // We need to reconnect the input pin. 

                // Note: The CheckMediaType method has already called QueryAccept on the upstream filter. 

                hr = m_pGraph->Reconnect(m_pInput);

                return hr;

            }

        }

//        WAVEFORMATEX wfIn;

//        m_Encoder.GetInputType(&wfIn);

//        if (wfIn.nSamplesPerSec %

//            ((LPWAVEFORMATEX)pmt->Format())->nSamplesPerSec != 0)

//            return VFW_E_TYPE_NOT_ACCEPTED;

    }

    return hr;

}

////////////////////////////////////////////////////////////////////////////

// CheckInputType - check if you can support mtIn

////////////////////////////////////////////////////////////////////////////

HRESULT CMpegAudEnc::CheckInputType(const CMediaType* mtIn)

{

    if (*mtIn->Type() == MEDIATYPE_Audio && *mtIn->FormatType() == FORMAT_WaveFormatEx)

        if (mtIn->FormatLength() >= sizeof(WAVEFORMATEX))

            if (mtIn->IsTemporalCompressed() == FALSE)

                return m_Encoder.SetInputType((LPWAVEFORMATEX)mtIn->Format(), true);

    return E_INVALIDARG;

}

////////////////////////////////////////////////////////////////////////////

// CheckTransform - checks if we can support the transform from this input to this output

////////////////////////////////////////////////////////////////////////////

HRESULT CMpegAudEnc::CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut)

{

	if(MEDIATYPE_Stream != mtOut->majortype)

	{

		if (*mtOut->FormatType() != FORMAT_WaveFormatEx)

			return VFW_E_INVALIDMEDIATYPE;

		if (mtOut->FormatLength() < sizeof(WAVEFORMATEX))

			return VFW_E_INVALIDMEDIATYPE;

		MPEG_ENCODER_CONFIG	mec;

		if(FAILED(m_Encoder.GetOutputType(&mec)))

			return S_OK;

		if (((LPWAVEFORMATEX)mtIn->Format())->nSamplesPerSec % mec.dwSampleRate != 0)

			return S_OK;

		if (mec.dwSampleRate != ((LPWAVEFORMATEX)mtOut->Format())->nSamplesPerSec)

			return VFW_E_TYPE_NOT_ACCEPTED;

		return S_OK;

	}

	else if(mtOut->subtype == MEDIASUBTYPE_MPEG1Audio)

		return S_OK;

	return VFW_E_TYPE_NOT_ACCEPTED;

}

////////////////////////////////////////////////////////////////////////////

// DecideBufferSize - sets output buffers number and size

////////////////////////////////////////////////////////////////////////////

HRESULT CMpegAudEnc::DecideBufferSize(

                        IMemAllocator*		  pAllocator,

                        ALLOCATOR_PROPERTIES* pProperties)

{

    HRESULT hr = S_OK;

	if(m_bStreamOutput)

		m_cbStreamAlignment = pProperties->cbAlign;

    ///

    if (pProperties->cBuffers == 0) pProperties->cBuffers = 1;  // If downstream filter didn't suggest a buffer count then default to 1

    pProperties->cbBuffer = OUT_BUFFER_SIZE;

	//

	ASSERT(pProperties->cbBuffer);

    ALLOCATOR_PROPERTIES Actual;

    hr = pAllocator->SetProperties(pProperties,&Actual);

    if(FAILED(hr))

        return hr;

    if (Actual.cbBuffer < pProperties->cbBuffer ||

        Actual.cBuffers < pProperties->cBuffers) 

    {// can't use this allocator

        return E_INVALIDARG;

    }

    return S_OK;

}

////////////////////////////////////////////////////////////////////////////

// GetMediaType - overrideable for suggesting output pin media types

////////////////////////////////////////////////////////////////////////////

HRESULT CMpegAudEnc::GetMediaType(int iPosition, CMediaType *pMediaType)

{

    DbgLog((LOG_TRACE,1,TEXT("CMpegAudEnc::GetMediaType()")));

    return m_pOutput->GetMediaType(iPosition, pMediaType);

}

////////////////////////////////////////////////////////////////////////////

//  Reconnect - called after a manual change has been made to the 

//  encoder parameters to reset the filter output media type structure

//  to match the current encoder out MPEG audio properties 

////////////////////////////////////////////////////////////////////////////

HRESULT CMpegAudEnc::Reconnect()

{

    HRESULT hr = S_FALSE;

    if (m_pOutput && m_pOutput->IsConnected() && m_State == State_Stopped)

    {

        MPEG_ENCODER_CONFIG mec;

        hr = m_Encoder.GetOutputType(&mec;;

        if ((hr = m_Encoder.SetOutputType(mec)) == S_OK)

        {

            // Create an updated output MediaType using the current encoder settings

            CMediaType cmt;

			cmt.InitMediaType();

            m_pOutput->GetMediaType(m_currentMediaTypeIndex, &cmt);

            // If the updated MediaType matches the current output MediaType no reconnect is needed

            if (m_pOutput->CurrentMediaType() == cmt) return S_OK;

            // Attempt to reconnect the output pin using the updated MediaType

            if (S_OK == (hr = m_pOutput->GetConnected()->QueryAccept(&cmt))) {

                hr = m_pOutput->SetMediaType(&cmt);

                if ( FAILED(hr) ) { return(hr); }

                hr = m_pGraph->Reconnect(m_pOutput);

            }

            else

                hr = m_pOutput->SetMediaType(&cmt);

        }

    }

    return hr;

}

////////////////////////////////////////////////////////////////////////////

//  LoadOutputCapabilities - create a list of the currently supported output 

//  format capabilities which will be used by the IAMStreamConfig Interface

////////////////////////////////////////////////////////////////////////////

void CMpegAudEnc::LoadOutputCapabilities(DWORD sample_rate)

{

    m_CapsNum = 0;

    // Clear out any existing output capabilities

    ZeroMemory(OutputCaps, sizeof(OutputCaps));

    // Create the set of Constant Bit Rate output capabilities that are

    // supported for the current input pin sampling rate.

    for (int i = 0;  i < NUMELMS(OutputCapabilities); i++) {

        if (0 == sample_rate % OutputCapabilities[i].nSampleRate) {

            // Add this output capability to the OutputCaps list

            OutputCaps[m_CapsNum] = OutputCapabilities[i];

            m_CapsNum++;

            // Don't overrun the hard-coded capabilities array limit

            if (m_CapsNum > (int)MAX_IAMSTREAMCONFIG_CAPS) break;

        }

    }

}

//

// Read persistent configuration from Registry

//

void CMpegAudEnc::ReadPresetSettings(MPEG_ENCODER_CONFIG * pmec)

{

    DbgLog((LOG_TRACE,1,TEXT("CMpegAudEnc::ReadPresetSettings()")));

    Lame::CRegKey rk(HKEY_CURRENT_USER, KEY_LAME_ENCODER);

    pmec->dwBitrate         = rk.getDWORD(VALUE_BITRATE,DEFAULT_BITRATE);

    pmec->dwVariableMin     = rk.getDWORD(VALUE_VARIABLEMIN,DEFAULT_VARIABLEMIN);

    pmec->dwVariableMax     = rk.getDWORD(VALUE_VARIABLEMAX,DEFAULT_VARIABLEMAX);

    pmec->vmVariable        = rk.getDWORD(VALUE_VARIABLE, DEFAULT_VARIABLE) ? vbr_rh : vbr_off;

    pmec->dwQuality         = rk.getDWORD(VALUE_QUALITY,DEFAULT_ENCODING_QUALITY);

    pmec->dwVBRq            = rk.getDWORD(VALUE_VBR_QUALITY,DEFAULT_VBR_QUALITY);

    pmec->lLayer            = rk.getDWORD(VALUE_LAYER, DEFAULT_LAYER);

    pmec->bCRCProtect       = rk.getDWORD(VALUE_CRC, DEFAULT_CRC);

    pmec->bForceMono        = rk.getDWORD(VALUE_FORCE_MONO, DEFAULT_FORCE_MONO);

    pmec->bSetDuration      = rk.getDWORD(VALUE_SET_DURATION, DEFAULT_SET_DURATION);

    pmec->bSampleOverlap    = rk.getDWORD(VALUE_SAMPLE_OVERLAP, DEFAULT_SAMPLE_OVERLAP);

    pmec->bCopyright        = rk.getDWORD(VALUE_COPYRIGHT, DEFAULT_COPYRIGHT);

    pmec->bOriginal         = rk.getDWORD(VALUE_ORIGINAL, DEFAULT_ORIGINAL);

    pmec->dwSampleRate      = rk.getDWORD(VALUE_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);

    pmec->dwPES             = rk.getDWORD(VALUE_PES, DEFAULT_PES);

    pmec->ChMode            = (MPEG_mode)rk.getDWORD(VALUE_STEREO_MODE, DEFAULT_STEREO_MODE);

    pmec->dwForceMS         = rk.getDWORD(VALUE_FORCE_MS, DEFAULT_FORCE_MS);

    pmec->dwEnforceVBRmin   = rk.getDWORD(VALUE_ENFORCE_MIN, DEFAULT_ENFORCE_MIN);

    pmec->dwVoiceMode       = rk.getDWORD(VALUE_VOICE, DEFAULT_VOICE);

    pmec->dwKeepAllFreq     = rk.getDWORD(VALUE_KEEP_ALL_FREQ, DEFAULT_KEEP_ALL_FREQ);

    pmec->dwStrictISO       = rk.getDWORD(VALUE_STRICT_ISO, DEFAULT_STRICT_ISO);

    pmec->dwNoShortBlock    = rk.getDWORD(VALUE_DISABLE_SHORT_BLOCK, DEFAULT_DISABLE_SHORT_BLOCK);

    pmec->dwXingTag         = rk.getDWORD(VALUE_XING_TAG, DEFAULT_XING_TAG);

    pmec->dwModeFixed       = rk.getDWORD(VALUE_MODE_FIXED, DEFAULT_MODE_FIXED);

    rk.Close();

}

////////////////////////////////////////////////////////////////

//  Property page handling 

////////////////////////////////////////////////////////////////

HRESULT CMpegAudEnc::GetPages(CAUUID *pcauuid) 

{

    GUID *pguid;

    pcauuid->cElems = 3;

    pcauuid->pElems = pguid = (GUID *) CoTaskMemAlloc(sizeof(GUID) * pcauuid->cElems);