/**

 *

 * Lame ACM wrapper, encode/decode MP3 based RIFF/AVI files in MS Windows

 *

 *  Copyright (c) 2002 Steve Lhomme <steve.lhomme at free.fr>

 *

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

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

 * License as published by the Free Software Foundation; either

 * version 2.1 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser 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

 *

 */

/*!

	\author Steve Lhomme

	\version \$Id: ACM.cpp,v 1.20 2007/05/17 22:25:40 robert Exp $

*/

#if !defined(STRICT)

#define STRICT

#endif // STRICT

#include <algorithm>

#include <windows.h>

#include <windowsx.h>

#include <intshcut.h>

#include <mmreg.h>

#include <msacm.h>

#include <msacmdrv.h>

#include <assert.h>

#include <lame.h>

#include "adebug.h"

#include "resource.h"

#include "ACMStream.h"

#ifdef ENABLE_DECODING

#include "DecodeStream.h"

#endif // ENABLE_DECODING

#include "ACM.h"

#ifndef IDC_HAND

#define IDC_HAND            MAKEINTRESOURCE(32649)

#endif // IDC_HAND

char ACM::VersionString[120];

const char ACM_VERSION[] = "0.9.2";

#ifdef WIN32

//

//  32-bit versions

//

#if (WINVER >= 0x0400)

 #define VERSION_ACM_DRIVER  MAKE_ACM_VERSION(4,  0, 0)

#else

#define VERSION_ACM_DRIVER  MAKE_ACM_VERSION(3, 51, 0)

#endif

#define VERSION_MSACM MAKE_ACM_VERSION(3, 50, 0)

#else

//

//  16-bit versions

//

#define VERSION_ACM_DRIVER MAKE_ACM_VERSION(1, 0, 0)

#define VERSION_MSACM MAKE_ACM_VERSION(2, 1, 0)

#endif

#define PERSONAL_FORMAT WAVE_FORMAT_MPEGLAYER3

#define SIZE_FORMAT_STRUCT sizeof(MPEGLAYER3WAVEFORMAT)

//#define SIZE_FORMAT_STRUCT 0

//static const char channel_mode[][13] = {"mono","stereo","joint stereo","dual channel"};

static const char channel_mode[][13] = {"mono","stereo"};

static const unsigned int mpeg1_freq[] = {48000,44100,32000};

static const unsigned int mpeg2_freq[] = {24000,22050,16000,12000,11025,8000};

static const unsigned int mpeg1_bitrate[] = {320, 256, 224, 192, 160, 128, 112, 96, 80, 64, 56, 48, 40, 32};

static const unsigned int mpeg2_bitrate[] = {160, 144, 128, 112,  96,  80,  64, 56, 48, 40, 32, 24, 16,  8};

#define SIZE_CHANNEL_MODE (sizeof(channel_mode)  / (sizeof(char) * 13))

#define SIZE_FREQ_MPEG1 (sizeof(mpeg1_freq)    / sizeof(unsigned int))

#define SIZE_FREQ_MPEG2 (sizeof(mpeg2_freq)    / sizeof(unsigned int))

#define SIZE_BITRATE_MPEG1 (sizeof(mpeg1_bitrate) / sizeof(unsigned int))

#define SIZE_BITRATE_MPEG2 (sizeof(mpeg2_bitrate) / sizeof(unsigned int))

static const int FORMAT_TAG_MAX_NB = 2; // PCM and PERSONAL (mandatory to have at least PCM and your format)

static const int FILTER_TAG_MAX_NB = 0; // this is a codec, not a filter

// number of supported PCM formats

static const int FORMAT_MAX_NB_PCM =

	2 *                                           // number of PCM channel mode (stereo/mono)

		(SIZE_FREQ_MPEG1 + // number of MPEG 1 sampling freq

		SIZE_FREQ_MPEG2); // number of MPEG 2 sampling freq

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

//

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

bool bitrate_item::operator<(const bitrate_item & other_bitrate) const

{

	return (other_bitrate.frequency < frequency ||

		    (other_bitrate.frequency == frequency &&

			 (other_bitrate.bitrate < bitrate ||

			  (other_bitrate.bitrate == bitrate &&

			   (other_bitrate.channels < channels)))));

}

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

// Configuration Dialog

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

/*

static CALLBACK ConfigProc(

  HWND hwndDlg,  // handle to dialog box

UINT uMsg,     // message

WPARAM wParam, // first message parameter

LPARAM lParam  // second message parameter

)

{

	BOOL bResult;

	switch (uMsg) {

		case WM_COMMAND:

			UINT command;

			command = GET_WM_COMMAND_ID(wParam, lParam);

            if (IDOK == command)

            {

                EndDialog(hwndDlg, (IDOK == command));

            } else if (IDCANCEL == command)

            {

                EndDialog(hwndDlg, (IDOK == command));

            }

            bResult = FALSE;

			break;

		default:

			bResult = FALSE; // will be treated by DefWindowProc

}

	return bResult;

}

inline DWORD ACM::Configure(HWND hParentWindow, LPDRVCONFIGINFO pConfig)

{

	my_debug.OutPut(DEBUG_LEVEL_FUNC_START, "ACM : Configure (Parent Window = 0x%08X)",hParentWindow);

	DialogBoxParam( my_hModule, MAKEINTRESOURCE(IDD_CONFIG), hParentWindow, ::ConfigProc , (LPARAM)this);

	return DRVCNF_OK; // Can also return

					// DRVCNF_CANCEL

					// and DRVCNF_RESTART

}

*/

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

// About Dialog

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

static BOOL CALLBACK AboutProc(

  HWND hwndDlg,  // handle to dialog box

UINT uMsg,     // message

WPARAM wParam, // first message parameter

LPARAM lParam  // second message parameter

)

{

	static HBRUSH hBrushStatic = NULL;

//	static LOGFONT lf;  // structure for font information  

//	static HFONT hfnt;

	static HCURSOR hcOverCursor = NULL;

	BOOL bResult;

	switch (uMsg) {

		case WM_INITDIALOG:

			char tmp[150];

			wsprintf(tmp,"LAME MP3 codec v%s", ACM::GetVersionString());

			::SetWindowText(GetDlgItem( hwndDlg, IDC_STATIC_ABOUT_TITLE), tmp);

/*

			::GetObject(::GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), &lf); 

			lf.lfUnderline = TRUE;

			hfnt = ::CreateFontIndirect(&lf);

			::SendMessage(::GetDlgItem(hwndDlg,IDC_STATIC_ABOUT_URL), WM_SETFONT, (WPARAM) hfnt, TRUE);

* /

			hBrushStatic = ::CreateSolidBrush(::GetSysColor (COLOR_BTNFACE));

*/			hcOverCursor = ::LoadCursor(NULL,(LPCTSTR)IDC_HAND); 

			if (hcOverCursor == NULL)

				hcOverCursor = ::LoadCursor(NULL,(LPCTSTR)IDC_CROSS); 

			bResult = TRUE;

			break;

/*

		case WM_CTLCOLORSTATIC:

			/// \todo only if there are URLs

			if ((HWND)lParam == ::GetDlgItem(hwndDlg,IDC_STATIC_ABOUT_URL))

			{

				::SetTextColor((HDC)wParam, ::GetSysColor (COLOR_HIGHLIGHT));

				::SetBkColor((HDC)wParam, ::GetSysColor (COLOR_BTNFACE));

				return (LRESULT) hBrushStatic;

			}

			else

				return (LRESULT) NULL;

*/

		case WM_MOUSEMOVE:

			{

				POINT pnt;

				::GetCursorPos(&pnt);

				RECT rect;

				::GetWindowRect( ::GetDlgItem(hwndDlg,IDC_STATIC_ABOUT_URL), &rect);

				if (  ::PtInRect(&rect,pnt)  )

				{

					::SetCursor(hcOverCursor);

				}

			}

			break;

		case WM_LBUTTONUP:

			{

				POINT pnt;

				::GetCursorPos(&pnt);

				RECT rect;

				::GetWindowRect( ::GetDlgItem(hwndDlg,IDC_STATIC_ABOUT_URL), &rect);

				TCHAR Url[200];

				bool bUrl = false;

				if (::PtInRect(&rect,pnt))

				{

					wsprintf(Url,get_lame_url());

					bUrl = true;

				}

				if (bUrl)

				{

					LPSTR tmpStr;

					HRESULT hresult = ::TranslateURL(Url, TRANSLATEURL_FL_GUESS_PROTOCOL|TRANSLATEURL_FL_GUESS_PROTOCOL, &tmpStr);

					if (hresult == S_OK)

						::ShellExecute(hwndDlg,"open",tmpStr,NULL,"",SW_SHOWMAXIMIZED );

					else if (hresult == S_FALSE)

						::ShellExecute(hwndDlg,"open",Url,NULL,"",SW_SHOWMAXIMIZED );

				}

			}

			break;

		case WM_COMMAND:

			UINT command;

			command = GET_WM_COMMAND_ID(wParam, lParam);

            if (IDOK == command)

            {

                EndDialog(hwndDlg, TRUE);

            }

            bResult = FALSE;

			break;

		case IDC_STATIC_ABOUT_URL:

			break;

		default:

			bResult = FALSE; // will be treated by DefWindowProc

}

	return bResult;

}

inline DWORD ACM::About(HWND hParentWindow)

{

	my_debug.OutPut(DEBUG_LEVEL_FUNC_START, "ACM : About (Parent Window = 0x%08X)",hParentWindow);

	DialogBoxParam( my_hModule, MAKEINTRESOURCE(IDD_ABOUT), hParentWindow, ::AboutProc , (LPARAM)this);

	return DRVCNF_OK; // Can also return

// DRVCNF_CANCEL

// and DRVCNF_RESTART

}

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

// Construction/Destruction

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

ACM::ACM( HMODULE hModule )

 :my_hModule(hModule),

  my_hIcon(NULL),

  my_debug(ADbg(DEBUG_LEVEL_CREATION)),

  my_EncodingProperties(hModule)

{

	my_EncodingProperties.ParamsRestore();

	/// \todo get the debug level from the registry

	unsigned char DebugFileName[512];

	char tmp[128];

	wsprintf(tmp,"LAMEacm 0x%08X",this);

	my_debug.setPrefix(tmp); /// \todo get it from the registry

	my_debug.setIncludeTime(true);  /// \todo get it from the registry

	// Check in the registry if we have to Output Debug information

	DebugFileName[0] = '\0';

	HKEY OssKey;

	if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, "SOFTWARE\\MUKOLI", 0, KEY_READ , &OssKey ) == ERROR_SUCCESS) {

		DWORD DataType;

		DWORD DebugFileNameSize = 512;

		if (RegQueryValueEx( OssKey, "DebugFile", NULL, &DataType, DebugFileName, &DebugFileNameSize ) == ERROR_SUCCESS) {

			if (DataType == REG_SZ) {

				my_debug.setUseFile(true);

				my_debug.setDebugFile((char *)DebugFileName);

				my_debug.OutPut("Debug file is %s",(char *)DebugFileName);

			}

		}

	}

        wsprintf(VersionString,"%s - %s", ACM_VERSION, get_lame_version() );

	BuildBitrateTable();

	my_debug.OutPut(DEBUG_LEVEL_FUNC_START, "New ACM Creation (0x%08X)",this);

}

ACM::~ACM()

{

// not used, it's done automatically when closing the driver	if (my_hIcon != NULL)

//		CloseHandle(my_hIcon);

	bitrate_table.clear();

	my_debug.OutPut(DEBUG_LEVEL_FUNC_START, "ACM Deleted (0x%08X)",this);

}

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

// Main message handler

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

LONG ACM::DriverProcedure(const HDRVR hdrvr, const UINT msg, LONG lParam1, LONG lParam2)

{

    DWORD dwRes = 0L;

//my_debug.OutPut(DEBUG_LEVEL_MSG, "message 0x%08X for ThisACM 0x%08X", msg, this);

switch (msg) {

    case DRV_INSTALL:

		my_debug.OutPut(DEBUG_LEVEL_MSG, "DRV_INSTALL");

		// Sent when the driver is installed.

		dwRes = DRVCNF_OK;  // Can also return 

		break;              // DRVCNF_CANCEL

							// and DRV_RESTART

	case DRV_REMOVE:

		// Sent when the driver is removed.

		my_debug.OutPut(DEBUG_LEVEL_MSG, "DRV_REMOVE");

		dwRes = 1L;  // return value ignored

		break;

    case DRV_QUERYCONFIGURE:

		my_debug.OutPut(DEBUG_LEVEL_MSG, "DRV_QUERYCONFIGURE");

		// Sent to determine if the driver can be

		// configured.

		dwRes = 1L;  // Zero indicates configuration

		break;       // NOT supported

	case DRV_CONFIGURE:

		my_debug.OutPut(DEBUG_LEVEL_MSG, "DRV_CONFIGURE");

		// Sent to display the configuration

		// dialog box for the driver.

//		dwRes = Configure( (HWND) lParam1, (LPDRVCONFIGINFO) lParam2 );

		if (my_EncodingProperties.Config(my_hModule, (HWND) lParam1))

		{

			dwRes = DRVCNF_OK; // Can also return

					// DRVCNF_CANCEL

					// and DRVCNF_RESTART

		} else {

			dwRes = DRVCNF_CANCEL;

		}

		break;

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

	// ACM additional messages

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

	case ACMDM_DRIVER_ABOUT:

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_DRIVER_ABOUT");

		dwRes = About( (HWND) lParam1 );

        break;

	case ACMDM_DRIVER_DETAILS: // acmDriverDetails

		// Fill-in general informations about the driver/codec

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_DRIVER_DETAILS");

		dwRes = OnDriverDetails(hdrvr, (LPACMDRIVERDETAILS) lParam1);

		break;

	case ACMDM_FORMATTAG_DETAILS: // acmFormatTagDetails

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_FORMATTAG_DETAILS");

		dwRes = OnFormatTagDetails((LPACMFORMATTAGDETAILS) lParam1, lParam2);

        break;

	case ACMDM_FORMAT_DETAILS: // acmFormatDetails

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_FORMAT_DETAILS");

		dwRes = OnFormatDetails((LPACMFORMATDETAILS) lParam1, lParam2);

        break;           

    case ACMDM_FORMAT_SUGGEST: // acmFormatSuggest

		// Sent to determine if the driver can be

		// configured.

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_FORMAT_SUGGEST");

		dwRes = OnFormatSuggest((LPACMDRVFORMATSUGGEST) lParam1);

        break; 

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

	// ACM stream messages

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

	case ACMDM_STREAM_OPEN:

	// Sent to determine if the driver can be

	// configured.

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_OPEN");

		dwRes = OnStreamOpen((LPACMDRVSTREAMINSTANCE) lParam1);

        break; 

	case ACMDM_STREAM_SIZE:

	// returns a recommended size for a source 

	// or destination buffer on an ACM stream

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_SIZE");

		dwRes = OnStreamSize((LPACMDRVSTREAMINSTANCE)lParam1, (LPACMDRVSTREAMSIZE)lParam2);

        break; 

	case ACMDM_STREAM_PREPARE:

	// prepares an ACMSTREAMHEADER structure for

	// an ACM stream conversion

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_PREPARE");

		dwRes = OnStreamPrepareHeader((LPACMDRVSTREAMINSTANCE)lParam1, (LPACMSTREAMHEADER) lParam2);

        break; 

	case ACMDM_STREAM_UNPREPARE:

	// cleans up the preparation performed by

	// the ACMDM_STREAM_PREPARE message for an ACM stream

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_UNPREPARE");

		dwRes = OnStreamUnPrepareHeader((LPACMDRVSTREAMINSTANCE)lParam1, (LPACMSTREAMHEADER) lParam2);

        break; 

	case ACMDM_STREAM_CONVERT:

	// perform a conversion on the specified conversion stream

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_CONVERT");

		dwRes = OnStreamConvert((LPACMDRVSTREAMINSTANCE)lParam1, (LPACMDRVSTREAMHEADER) lParam2);

        break; 

	case ACMDM_STREAM_CLOSE:

	// closes an ACM conversion stream

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_CLOSE");

		dwRes = OnStreamClose((LPACMDRVSTREAMINSTANCE)lParam1);

        break;

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

	// Unknown message

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

	default:

	// Process any other messages.

		my_debug.OutPut(DEBUG_LEVEL_MSG, "ACM::DriverProc unknown message (0x%08X), lParam1 = 0x%08X, lParam2 = 0x%08X", msg, lParam1, lParam2);

		return DefDriverProc ((DWORD)this, hdrvr, msg, lParam1, lParam2);

    }

    return dwRes;

}

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

// Special message handlers

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

/*!

	Retreive the config details of this ACM driver

	The index represent the specified format

	\param a_FormatDetails will be filled with all the corresponding data

*/

inline DWORD ACM::OnFormatDetails(LPACMFORMATDETAILS a_FormatDetails, const LPARAM a_Query)

{

	DWORD Result = ACMERR_NOTPOSSIBLE;

	my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "ACM_FORMATDETAILS a_Query = 0x%08X",a_Query);

	switch (a_Query & ACM_FORMATDETAILSF_QUERYMASK) {

		// Fill-in the informations corresponding to the FormatDetails->dwFormatTagIndex

		case ACM_FORMATDETAILSF_INDEX :

			my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "enter ACM_FORMATDETAILSF_INDEX for index 0x%04X:%03d",a_FormatDetails->dwFormatTag,a_FormatDetails->dwFormatIndex);

			if (a_FormatDetails->dwFormatTag == PERSONAL_FORMAT) {

				if (a_FormatDetails->dwFormatIndex < GetNumberEncodingFormats()) {

					LPWAVEFORMATEX WaveExt;

					WaveExt = a_FormatDetails->pwfx;

					WaveExt->wFormatTag = PERSONAL_FORMAT;

					my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "format in  : channels %d, sample rate %d", WaveExt->nChannels, WaveExt->nSamplesPerSec);

					GetMP3FormatForIndex(a_FormatDetails->dwFormatIndex, *WaveExt, a_FormatDetails->szFormat);

					my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "format out : channels %d, sample rate %d", WaveExt->nChannels, WaveExt->nSamplesPerSec);

					Result = MMSYSERR_NOERROR;

				}

				else

				{

					my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "ACM_FORMATDETAILSF_INDEX unknown index 0x%04X:%03d",a_FormatDetails->dwFormatTag,a_FormatDetails->dwFormatIndex);

				}

			}

			else if (a_FormatDetails->dwFormatTag == WAVE_FORMAT_PCM) {

				if (a_FormatDetails->dwFormatIndex < FORMAT_MAX_NB_PCM) {

					LPWAVEFORMATEX WaveExt;

					WaveExt = a_FormatDetails->pwfx;

					WaveExt->wFormatTag = WAVE_FORMAT_PCM;

					my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "format in  : channels %d, sample rate %d", WaveExt->nChannels, WaveExt->nSamplesPerSec);

					GetPCMFormatForIndex(a_FormatDetails->dwFormatIndex, *WaveExt, a_FormatDetails->szFormat);

					my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "format out : channels %d, sample rate %d", WaveExt->nChannels, WaveExt->nSamplesPerSec);

					Result = MMSYSERR_NOERROR;

				}

				else

				{

					my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "ACM_FORMATDETAILSF_INDEX unknown index 0x%04X:%03d",a_FormatDetails->dwFormatTag,a_FormatDetails->dwFormatIndex);

				}

			}

			else

			{

				my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "Unknown a_FormatDetails->dwFormatTag = 0x%08X",a_FormatDetails->dwFormatTag);

			}

		case ACM_FORMATDETAILSF_FORMAT :

			/// \todo we may output the corresponding strong (only for personal format)

			LPWAVEFORMATEX WaveExt;

			WaveExt = a_FormatDetails->pwfx;

			my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "enter ACM_FORMATDETAILSF_FORMAT : 0x%04X:%03d, format in : channels %d, sample rate %d",a_FormatDetails->dwFormatTag,a_FormatDetails->dwFormatIndex, WaveExt->nChannels, WaveExt->nSamplesPerSec);

			Result = MMSYSERR_NOERROR;

			break;

		default:

			Result = ACMERR_NOTPOSSIBLE;

			break;

	}

	a_FormatDetails->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;

	return Result;

}

/*!

	Retreive the details of each known format by this ACM driver

	The index represent the specified format (0 = MP3 / 1 = PCM)

	\param a_FormatTagDetails will be filled with all the corresponding data

*/

inline DWORD ACM::OnFormatTagDetails(LPACMFORMATTAGDETAILS a_FormatTagDetails, const LPARAM a_Query)

{

	DWORD Result;

	DWORD the_format = WAVE_FORMAT_UNKNOWN; // the format to give details

	if (a_FormatTagDetails->cbStruct >= sizeof(*a_FormatTagDetails)) {

		my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "ACMDM_FORMATTAG_DETAILS, a_Query = 0x%08X",a_Query);

		switch(a_Query & ACM_FORMATTAGDETAILSF_QUERYMASK) {

			case ACM_FORMATTAGDETAILSF_INDEX:

			// Fill-in the informations corresponding to the a_FormatDetails->dwFormatTagIndex

				my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "get ACM_FORMATTAGDETAILSF_INDEX for index %03d",a_FormatTagDetails->dwFormatTagIndex);

				if (a_FormatTagDetails->dwFormatTagIndex < FORMAT_TAG_MAX_NB) {

					switch (a_FormatTagDetails->dwFormatTagIndex)

					{

					case 0:

						the_format = PERSONAL_FORMAT;

						break;

					default :

						the_format = WAVE_FORMAT_PCM;

						break;

					}

				}

				else

				{

					my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "ACM_FORMATTAGDETAILSF_INDEX for unsupported index %03d",a_FormatTagDetails->dwFormatTagIndex);

					Result = ACMERR_NOTPOSSIBLE;

				}

				break;

			case ACM_FORMATTAGDETAILSF_FORMATTAG:

			// Fill-in the informations corresponding to the a_FormatDetails->dwFormatTagIndex and hdrvr given

				switch (a_FormatTagDetails->dwFormatTag)

				{

				case WAVE_FORMAT_PCM:

					the_format = WAVE_FORMAT_PCM;

					break;

				case PERSONAL_FORMAT:

					the_format = PERSONAL_FORMAT;

					break;

				default:

                    return (ACMERR_NOTPOSSIBLE);

				}

				my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "get ACM_FORMATTAGDETAILSF_FORMATTAG for index 0x%02X, cStandardFormats = %d",a_FormatTagDetails->dwFormatTagIndex,a_FormatTagDetails->cStandardFormats);

				break;

			case ACM_FORMATTAGDETAILSF_LARGESTSIZE:

				my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "ACM_FORMATTAGDETAILSF_LARGESTSIZE not used");

				Result = 0L;

				break;

			default:

				my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "OnFormatTagDetails Unknown Format tag query");

				Result = MMSYSERR_NOTSUPPORTED;

				break;

		}

		my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "OnFormatTagDetails the_format = 0x%08X",the_format);

		switch(the_format)

		{

			case WAVE_FORMAT_PCM:

				a_FormatTagDetails->dwFormatTag      = WAVE_FORMAT_PCM;

				a_FormatTagDetails->dwFormatTagIndex = 0;

				a_FormatTagDetails->cbFormatSize     = sizeof(PCMWAVEFORMAT);

				/// \note 0 may mean we don't know how to decode

				a_FormatTagDetails->fdwSupport       = ACMDRIVERDETAILS_SUPPORTF_CODEC;

				a_FormatTagDetails->cStandardFormats = FORMAT_MAX_NB_PCM;

				// should be filled by Windows				a_FormatTagDetails->szFormatTag[0] = '\0';

				Result = MMSYSERR_NOERROR;

				break;

			case PERSONAL_FORMAT:

				a_FormatTagDetails->dwFormatTag      = PERSONAL_FORMAT;

				a_FormatTagDetails->dwFormatTagIndex = 1;

				a_FormatTagDetails->cbFormatSize     = SIZE_FORMAT_STRUCT;

				a_FormatTagDetails->fdwSupport       = ACMDRIVERDETAILS_SUPPORTF_CODEC;

				a_FormatTagDetails->cStandardFormats = GetNumberEncodingFormats();

				lstrcpyW( a_FormatTagDetails->szFormatTag, L"Lame MP3" );

				Result = MMSYSERR_NOERROR;

				break;

			default:

				my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "OnFormatTagDetails Unknown format 0x%08X",the_format);

				return (ACMERR_NOTPOSSIBLE);

		}

		my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "OnFormatTagDetails %d possibilities for format 0x%08X",a_FormatTagDetails->cStandardFormats,the_format);

	}

	else

	{

		my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "a_FormatTagDetails->cbStruct < sizeof(*a_FormatDetails)");

		Result = ACMERR_NOTPOSSIBLE;

	}

	return Result;

}

/*!

	Retreive the global details of this ACM driver

	\param a_DriverDetail will be filled with all the corresponding data

*/

inline DWORD ACM::OnDriverDetails(const HDRVR hdrvr, LPACMDRIVERDETAILS a_DriverDetail)

{

	if (my_hIcon == NULL)

		my_hIcon = LoadIcon(GetDriverModuleHandle(hdrvr), MAKEINTRESOURCE(IDI_ICON));

	a_DriverDetail->hicon       = my_hIcon;

	a_DriverDetail->fccType     = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;

	a_DriverDetail->fccComp     = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;

	/// \note this is an explicit hack of the FhG values

	/// \note later it could be a new value when the decoding is done

	a_DriverDetail->wMid        = MM_FRAUNHOFER_IIS;

	a_DriverDetail->wPid        = MM_FHGIIS_MPEGLAYER3;

	a_DriverDetail->vdwACM      = VERSION_MSACM;

	a_DriverDetail->vdwDriver   = VERSION_ACM_DRIVER;

	a_DriverDetail->fdwSupport  = ACMDRIVERDETAILS_SUPPORTF_CODEC;

	a_DriverDetail->cFormatTags = FORMAT_TAG_MAX_NB; // 2 : MP3 and PCM

//	a_DriverDetail->cFormatTags = 1; // 2 : MP3 and PCM

	a_DriverDetail->cFilterTags = FILTER_TAG_MAX_NB;

	lstrcpyW( a_DriverDetail->szShortName, L"LAME MP3" );

	char tmpStr[128];

	wsprintf(tmpStr, "LAME MP3 Codec v%s", GetVersionString());

	int u = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, tmpStr, -1, a_DriverDetail->szLongName, 0);

	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, tmpStr, -1, a_DriverDetail->szLongName, u);

	lstrcpyW( a_DriverDetail->szCopyright, L"2002 Steve Lhomme" );

	lstrcpyW( a_DriverDetail->szLicensing, L"LGPL (see gnu.org)" );

	/// \todo update this part when the code changes

	lstrcpyW( a_DriverDetail->szFeatures , L"only CBR implementation" );

    return MMSYSERR_NOERROR;  // Can also return DRVCNF_CANCEL

}

/*!

	Suggest an output format for the specified input format

	\param a_FormatSuggest will be filled with all the corresponding data

*/

inline DWORD ACM::OnFormatSuggest(LPACMDRVFORMATSUGGEST a_FormatSuggest)

{

	DWORD Result = MMSYSERR_NOTSUPPORTED;

    DWORD fdwSuggest = (ACM_FORMATSUGGESTF_TYPEMASK & a_FormatSuggest->fdwSuggest);

my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "Suggest %s%s%s%s (0x%08X)",

				 (fdwSuggest & ACM_FORMATSUGGESTF_NCHANNELS) ? "channels, ":"",

				 (fdwSuggest & ACM_FORMATSUGGESTF_NSAMPLESPERSEC) ? "samples/sec, ":"",

				 (fdwSuggest & ACM_FORMATSUGGESTF_WBITSPERSAMPLE) ? "bits/sample, ":"",

				 (fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG) ? "format, ":"",

				 fdwSuggest);

my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "Suggest for source format = 0x%04X, channels = %d, Samples/s = %d, AvgB/s = %d, BlockAlign = %d, b/sample = %d",

				 a_FormatSuggest->pwfxSrc->wFormatTag,

				 a_FormatSuggest->pwfxSrc->nChannels,

				 a_FormatSuggest->pwfxSrc->nSamplesPerSec,

				 a_FormatSuggest->pwfxSrc->nAvgBytesPerSec,

				 a_FormatSuggest->pwfxSrc->nBlockAlign,

				 a_FormatSuggest->pwfxSrc->wBitsPerSample);

my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "Suggested destination format = 0x%04X, channels = %d, Samples/s = %d, AvgB/s = %d, BlockAlign = %d, b/sample = %d",

			 a_FormatSuggest->pwfxDst->wFormatTag,

			 a_FormatSuggest->pwfxDst->nChannels,

			 a_FormatSuggest->pwfxDst->nSamplesPerSec,

			 a_FormatSuggest->pwfxDst->nAvgBytesPerSec,

			 a_FormatSuggest->pwfxDst->nBlockAlign,

			 a_FormatSuggest->pwfxDst->wBitsPerSample);

	switch (a_FormatSuggest->pwfxSrc->wFormatTag)

	{

        case WAVE_FORMAT_PCM:

			/// \todo handle here the decoding ?

			my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "Suggest for PCM source");

            //

			//  if the destination format tag is restricted, verify that

			//  it is within our capabilities...

			//

			//  this driver is able to decode to PCM

			//

			if (ACM_FORMATSUGGESTF_WFORMATTAG & fdwSuggest)

            {

                if (PERSONAL_FORMAT != a_FormatSuggest->pwfxDst->wFormatTag)

                    return (ACMERR_NOTPOSSIBLE);

            }

            else

			{

                a_FormatSuggest->pwfxDst->wFormatTag = PERSONAL_FORMAT;

            }

my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "Suggest succeed A");

            //

			//  if the destination channel count is restricted, verify that

			//  it is within our capabilities...

			//

			//  this driver is not able to change the number of channels

			//

			if (ACM_FORMATSUGGESTF_NCHANNELS & fdwSuggest)

            {

                if (a_FormatSuggest->pwfxSrc->nChannels != a_FormatSuggest->pwfxDst->nChannels)

                    return (ACMERR_NOTPOSSIBLE);

            }

            else

			{

                a_FormatSuggest->pwfxDst->nChannels = a_FormatSuggest->pwfxSrc->nChannels;

            }

			if (a_FormatSuggest->pwfxSrc->nChannels != 1 && a_FormatSuggest->pwfxSrc->nChannels != 2)

				return MMSYSERR_INVALPARAM;

my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "Suggest succeed B");

            //

			//  if the destination samples per second is restricted, verify

			//  that it is within our capabilities...

			//

			//  this driver is not able to change the sample rate

			//

			if (ACM_FORMATSUGGESTF_NSAMPLESPERSEC & fdwSuggest)

            {

                if (a_FormatSuggest->pwfxSrc->nSamplesPerSec != a_FormatSuggest->pwfxDst->nSamplesPerSec)

                    return (ACMERR_NOTPOSSIBLE);

            }

            else

			{

                a_FormatSuggest->pwfxDst->nSamplesPerSec = a_FormatSuggest->pwfxSrc->nSamplesPerSec;

            }

my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "Suggest succeed C");

            //

			//  if the destination bits per sample is restricted, verify

			//  that it is within our capabilities...

			//

			//  We prefer decoding to 16-bit PCM.

			//

			if (ACM_FORMATSUGGESTF_WBITSPERSAMPLE & fdwSuggest)

            {

                if ( (16 != a_FormatSuggest->pwfxDst->wBitsPerSample) && (8 != a_FormatSuggest->pwfxDst->wBitsPerSample) )

                    return (ACMERR_NOTPOSSIBLE);

            }

            else

			{

                a_FormatSuggest->pwfxDst->wBitsPerSample = 16;

            }

			//			a_FormatSuggest->pwfxDst->nBlockAlign = FORMAT_BLOCK_ALIGN;

			a_FormatSuggest->pwfxDst->nBlockAlign = a_FormatSuggest->pwfxDst->nChannels * a_FormatSuggest->pwfxDst->wBitsPerSample / 8;

			a_FormatSuggest->pwfxDst->nAvgBytesPerSec = a_FormatSuggest->pwfxDst->nChannels * 64000 / 8;

			my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "Suggest succeed");

			Result = MMSYSERR_NOERROR;

			break;

		case PERSONAL_FORMAT:

			my_debug.OutPut(DEBUG_LEVEL_FUNC_CODE, "Suggest for PERSONAL source");

            //

			//  if the destination format tag is restricted, verify that

			//  it is within our capabilities...

			//

			//  this driver is able to decode to PCM

			//

			if (ACM_FORMATSUGGESTF_WFORMATTAG & fdwSuggest)

            {

                if (WAVE_FORMAT_PCM != a_FormatSuggest->pwfxDst->wFormatTag)

                    return (ACMERR_NOTPOSSIBLE);

            }

            else

			{

                a_FormatSuggest->pwfxDst->wFormatTag = WAVE_FORMAT_PCM;

            }

            //

			//  if the destination channel count is restricted, verify that

			//  it is within our capabilities...

			//

			//  this driver is not able to change the number of channels

			//

			if (ACM_FORMATSUGGESTF_NCHANNELS & fdwSuggest)

            {

                if (a_FormatSuggest->pwfxSrc->nChannels != a_FormatSuggest->pwfxDst->nChannels)

                    return (ACMERR_NOTPOSSIBLE);

            }

            else

			{

                a_FormatSuggest->pwfxDst->nChannels = a_FormatSuggest->pwfxSrc->nChannels;

            }

            //

			//  if the destination samples per second is restricted, verify

			//  that it is within our capabilities...

			//

			//  this driver is not able to change the sample rate

			//

			if (ACM_FORMATSUGGESTF_NSAMPLESPERSEC & fdwSuggest)

            {

                if (a_FormatSuggest->pwfxSrc->nSamplesPerSec != a_FormatSuggest->pwfxDst->nSamplesPerSec)

                    return (ACMERR_NOTPOSSIBLE);

            }

            else

			{

                a_FormatSuggest->pwfxDst->nSamplesPerSec = a_FormatSuggest->pwfxSrc->nSamplesPerSec;

            }

            //

			//  if the destination bits per sample is restricted, verify