You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
967 lines
31 KiB
967 lines
31 KiB
//==========================================================================;
|
|
//
|
|
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
|
|
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
|
|
// PURPOSE.
|
|
//
|
|
// Copyright (c) 1992-1998 Microsoft Corporation
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// config.c
|
|
//
|
|
// Description:
|
|
// IMA ADPCM codec configuration init and dialog
|
|
//
|
|
//
|
|
// The configuration parameters for this codec are:
|
|
//
|
|
// MaxRTEncodeSetting:
|
|
// MaxRTDecodeSetting:
|
|
// These determine the highest mono sample rate that
|
|
// the codec will attempt to convert in real-time.
|
|
//
|
|
// PercentCPU:
|
|
// This configuration parameter is not normally changed
|
|
// by the user and is not presented in the config dialog.
|
|
// This value affects the config dialog's 'Auto-Config'
|
|
// calculation of MaxRTXxcodeSetting.
|
|
//
|
|
// These parameters may be set in the registry, using the imaadpcm subkey
|
|
// (which corresponds to the alias name used for installation) under
|
|
// the following key:
|
|
//
|
|
// HKEY_CURRENT_USER\Software\Microsoft\Multimedia
|
|
//
|
|
//
|
|
// Note: The configuration dialog is only compiled into the code if the
|
|
// IMAADPCM_USECONFIG symbol is defined. This is designed to make it
|
|
// easy to remove the dialog box completely for certain platforms,
|
|
// such as MIPS and Alpha under Windows NT.
|
|
//
|
|
//==========================================================================;
|
|
|
|
#include <windows.h>
|
|
#include <windowsx.h>
|
|
#include <mmsystem.h>
|
|
#include <mmreg.h>
|
|
#include <msacm.h>
|
|
#include <msacmdrv.h>
|
|
|
|
#include "muldiv32.h"
|
|
|
|
#include "codec.h"
|
|
#include "imaadpcm.h"
|
|
#include "debug.h"
|
|
|
|
#ifdef WIN32
|
|
#include <tchar.h>
|
|
#else
|
|
#define _tcstoul strtoul
|
|
#define _tcsncpy _fstrncpy
|
|
#endif
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
|
|
#ifndef WIN32
|
|
#error Win16 support has been dropped from this codec! Compile for Win32.
|
|
#endif
|
|
|
|
|
|
#ifdef IMAADPCM_USECONFIG
|
|
|
|
|
|
//
|
|
// Strings required to access configuration information in the registry.
|
|
//
|
|
const TCHAR BCODE gszMaxRTEncodeSetting[] = TEXT("MaxRTEncodeSetting");
|
|
const TCHAR BCODE gszMaxRTDecodeSetting[] = TEXT("MaxRTDecodeSetting");
|
|
const TCHAR BCODE gszPercentCPU[] = TEXT("PercentCPU");
|
|
const TCHAR gszMultimediaKey[] = TEXT("Software\\Microsoft\\Multimedia\\");
|
|
|
|
|
|
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
//
|
|
// Be careful changing the following!
|
|
//
|
|
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
//
|
|
// Data required to access the dialog box help.
|
|
//
|
|
// Note that you must write your own help file for your codec, even if
|
|
// the configuration dialog box looks identical. If you use the file
|
|
// listed here, then the title will say "IMA ADPCM" or something.
|
|
//
|
|
// Note: the number HELPCONTEXT_IMAADPCM must be unique in the file
|
|
// gszHelpFilename, and the number must defined in the [MAP]
|
|
// section of the .hpj help project file. Then the .rtf file
|
|
// will reference that number (using the keyword defined in
|
|
// the .hpj file). Then when we call WinHelp with the number,
|
|
// WinHelp will go to the right help entry.
|
|
//
|
|
const TCHAR BCODE gszHelpFilename[] = TEXT("audiocdc.hlp");
|
|
#define HELPCONTEXT_IMAADPCM 1001
|
|
#define IDH_AUDIOCDC_COMPRESSION 100
|
|
#define IDH_AUDIOCDC_DECOMPRESSION 200
|
|
#define IDH_AUDIOCDC_AUTOCONFIGURE 300
|
|
static int aKeyWordIds[] = {
|
|
IDC_COMBO_MAXRTENCODE, IDH_AUDIOCDC_COMPRESSION,
|
|
IDC_STATIC_COMPRESS, IDH_AUDIOCDC_COMPRESSION,
|
|
IDC_COMBO_MAXRTDECODE, IDH_AUDIOCDC_DECOMPRESSION,
|
|
IDC_STATIC_DECOMPRESS, IDH_AUDIOCDC_DECOMPRESSION,
|
|
IDC_BTN_AUTOCONFIG, IDH_AUDIOCDC_AUTOCONFIGURE,
|
|
0, 0
|
|
};
|
|
|
|
|
|
|
|
|
|
//==========================================================================;
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================;
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// VOID configWriteConfiguration
|
|
//
|
|
// Description:
|
|
//
|
|
// This routine writes the configuration data in PDI to the registry.
|
|
// This consists of the max real-time Encode and Decode settings.
|
|
//
|
|
// Arguments:
|
|
// PDRIVERINSTANCE pdi
|
|
//
|
|
// Return (VOID): None.
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
VOID configWriteConfiguration
|
|
(
|
|
PDRIVERINSTANCE pdi
|
|
)
|
|
{
|
|
DWORD dw;
|
|
|
|
|
|
if( NULL != pdi->hkey )
|
|
{
|
|
dw = (DWORD)pdi->nConfigMaxRTEncodeSetting;
|
|
(void)RegSetValueEx( pdi->hkey, (LPTSTR)gszMaxRTEncodeSetting, 0,
|
|
REG_DWORD, (LPBYTE)&dw, sizeof(DWORD) );
|
|
|
|
dw = (DWORD)pdi->nConfigMaxRTDecodeSetting;
|
|
(void)RegSetValueEx( pdi->hkey, (LPTSTR)gszMaxRTDecodeSetting, 0,
|
|
REG_DWORD, (LPBYTE)&dw, sizeof(DWORD) );
|
|
}
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// DWORD dwReadRegistryDefault
|
|
//
|
|
// Description:
|
|
//
|
|
// This routine reads a given value from the registry, and returns a
|
|
// default value if the read is not successful.
|
|
//
|
|
// Arguments:
|
|
// HKEY hkey: Registry key to read from.
|
|
// LPTSTR lpszEntry:
|
|
// DWORD dwDefault:
|
|
//
|
|
// Return (DWORD):
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
INLINE DWORD dwReadRegistryDefault
|
|
(
|
|
HKEY hkey,
|
|
LPTSTR lpszEntry,
|
|
DWORD dwDefault
|
|
)
|
|
{
|
|
DWORD dwType = (DWORD)~REG_DWORD; // Init to anything but REG_DWORD.
|
|
DWORD cbSize = sizeof(DWORD);
|
|
DWORD dwRet;
|
|
LONG lError;
|
|
|
|
ASSERT( NULL != hkey );
|
|
ASSERT( NULL != lpszEntry );
|
|
|
|
|
|
lError = RegQueryValueEx( hkey,
|
|
lpszEntry,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)&dwRet,
|
|
&cbSize );
|
|
|
|
if( ERROR_SUCCESS != lError || REG_DWORD != dwType )
|
|
dwRet = dwDefault;
|
|
|
|
return dwRet;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// VOID configSetDefaults
|
|
//
|
|
// Description:
|
|
//
|
|
// This routine sets the configuration parameters to their default
|
|
// values.
|
|
//
|
|
// Arguments:
|
|
// PDRIVERINSTANCE pdi:
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
VOID configSetDefaults
|
|
(
|
|
PDRIVERINSTANCE pdi
|
|
)
|
|
{
|
|
pdi->nConfigMaxRTEncodeSetting =
|
|
IMAADPCM_CONFIG_DEFAULT_MAXRTENCODESETTING;
|
|
|
|
pdi->nConfigMaxRTDecodeSetting =
|
|
IMAADPCM_CONFIG_DEFAULT_MAXRTDECODESETTING;
|
|
|
|
pdi->nConfigPercentCPU =
|
|
IMAADPCM_CONFIG_DEFAULT_PERCENTCPU;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// UINT configAutoConfig
|
|
//
|
|
// Description:
|
|
//
|
|
// We will determine how much time it takes to encode and then decode
|
|
// 2 seconds of data and use this to guess at the max sample
|
|
// rate we can convert in real-time.
|
|
//
|
|
// The max is computed with essentially 100% of the CPU. Practically,
|
|
// we won't have 100% of the CPU available. So we take a percentage
|
|
// of the computed max and use that as the max in the config dialog.
|
|
//
|
|
// The percentage that we use can be set in the ini file imaadpcm
|
|
// section by PercentCPU=xx.
|
|
//
|
|
//
|
|
// Arguments:
|
|
// HWND hwnd:
|
|
//
|
|
// Return (UINT): String identifier (IDS) of error message, or zero if
|
|
// the call succeeded.
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
UINT FNLOCAL configAutoConfig
|
|
(
|
|
PDRIVERINSTANCE pdi,
|
|
UINT *pnEncodeSetting,
|
|
UINT *pnDecodeSetting
|
|
)
|
|
{
|
|
LPPCMWAVEFORMAT pwfPCM = NULL;
|
|
LPIMAADPCMWAVEFORMAT pwfADPCM = NULL;
|
|
LPACMDRVFORMATSUGGEST padfs = NULL;
|
|
LPACMDRVSTREAMINSTANCE padsi = NULL;
|
|
LPACMDRVSTREAMHEADER padsh = NULL;
|
|
LPACMDRVSTREAMSIZE padss = NULL;
|
|
PSTREAMINSTANCE psi = NULL;
|
|
|
|
LPBYTE pBufPCM;
|
|
LPBYTE pBufADPCM;
|
|
DWORD cbPCM;
|
|
DWORD cbADPCM;
|
|
|
|
DWORD dwEncodeTime;
|
|
DWORD dwDecodeTime;
|
|
DWORD dwStartTime;
|
|
DWORD dwMaxEncodeRate;
|
|
DWORD dwMaxDecodeRate;
|
|
|
|
UINT nConfig;
|
|
|
|
UINT uIDS;
|
|
HCURSOR hCursorSave;
|
|
|
|
|
|
//
|
|
// We divide by this!
|
|
//
|
|
ASSERT( 0 != pdi->nConfigPercentCPU );
|
|
|
|
|
|
uIDS = 0; // No errors yet - this is our "success" return.
|
|
|
|
|
|
//
|
|
// This function may take a while. Set hour glass cursor
|
|
//
|
|
hCursorSave = SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
|
|
|
|
//
|
|
// Set up the input PCM wave format structure.
|
|
//
|
|
pwfPCM = (LPPCMWAVEFORMAT)GlobalAllocPtr( GPTR, sizeof(*pwfPCM) );
|
|
if( NULL == pwfPCM )
|
|
{
|
|
uIDS = IDS_ERROR_NOMEM;
|
|
goto errReturn;
|
|
}
|
|
|
|
pwfPCM->wf.wFormatTag = WAVE_FORMAT_PCM; // Mono 16-bit!!!
|
|
pwfPCM->wf.nChannels = 1;
|
|
pwfPCM->wf.nSamplesPerSec = 8000;
|
|
pwfPCM->wf.nBlockAlign = 2;
|
|
pwfPCM->wBitsPerSample = 16;
|
|
pwfPCM->wf.nAvgBytesPerSec = pwfPCM->wf.nSamplesPerSec *
|
|
pwfPCM->wf.nBlockAlign;
|
|
|
|
|
|
//
|
|
// Get this driver to suggest a format to convert to. Note: we may
|
|
// want to constrain the suggestion partly, depending on the
|
|
// capabilities of the codec. We should always choose the most
|
|
// complex conversion if there are several possibilities.
|
|
//
|
|
padfs = (LPACMDRVFORMATSUGGEST)GlobalAllocPtr( GPTR, sizeof(*padfs) );
|
|
pwfADPCM = (LPIMAADPCMWAVEFORMAT)GlobalAllocPtr( GPTR, sizeof(*pwfADPCM) );
|
|
if( NULL == padfs || NULL == pwfADPCM )
|
|
{
|
|
uIDS = IDS_ERROR_NOMEM;
|
|
goto errReturn;
|
|
}
|
|
|
|
padfs->cbStruct = sizeof(*padfs);
|
|
padfs->fdwSuggest = 0; // Default everything.
|
|
padfs->pwfxSrc = (LPWAVEFORMATEX)pwfPCM;
|
|
padfs->cbwfxSrc = sizeof(*pwfPCM);
|
|
padfs->pwfxDst = (LPWAVEFORMATEX)pwfADPCM;
|
|
padfs->cbwfxDst = sizeof(*pwfADPCM);
|
|
|
|
(void)acmdFormatSuggest( pdi, padfs ); // This will always work, right?
|
|
|
|
|
|
//
|
|
// Set stream instance data. Note: we assume that the members that
|
|
// we don't set here never actually get used. Make sure that this
|
|
// is really true!
|
|
//
|
|
padsi = (LPACMDRVSTREAMINSTANCE)GlobalAllocPtr( GPTR, sizeof(*padsi) );
|
|
psi = (PSTREAMINSTANCE)LocalAlloc( LPTR, sizeof(*psi) );
|
|
if( NULL == padsi || NULL == psi )
|
|
{
|
|
uIDS = IDS_ERROR_NOMEM;
|
|
goto errReturn;
|
|
}
|
|
|
|
// Make sure that psi->fnConvert matches the PCM format in pwfPCM!!!
|
|
psi->fnConvert = imaadpcmEncode4Bit_M16;
|
|
psi->fdwConfig = pdi->fdwConfig;
|
|
psi->nStepIndexL = 0;
|
|
psi->nStepIndexR = 0;
|
|
|
|
// Make sure that no other members of padsi are used!!!
|
|
padsi->cbStruct = sizeof(*padsi);
|
|
padsi->pwfxSrc = (LPWAVEFORMATEX)pwfPCM;
|
|
padsi->pwfxDst = (LPWAVEFORMATEX)pwfADPCM;
|
|
padsi->dwDriver = (DWORD_PTR)psi;
|
|
|
|
|
|
//
|
|
// Now, get the driver to tell us how much space is required for the
|
|
// destination buffer.
|
|
//
|
|
cbPCM = IMAADPCM_CONFIGTESTTIME * pwfPCM->wf.nAvgBytesPerSec;
|
|
|
|
padss = (LPACMDRVSTREAMSIZE)GlobalAllocPtr( GPTR, sizeof(*padss) );
|
|
if( NULL == padss )
|
|
{
|
|
uIDS = IDS_ERROR_NOMEM;
|
|
goto errReturn;
|
|
}
|
|
|
|
padss->cbStruct = sizeof(padss);
|
|
padss->fdwSize = ACM_STREAMSIZEF_SOURCE;
|
|
padss->cbSrcLength = cbPCM;
|
|
|
|
(void)acmdStreamSize( padsi, padss ); // This will always work, right?
|
|
|
|
|
|
//
|
|
// Allocate source and destination buffers. Note that we specifically
|
|
// don't zero-initialize them, so that we will get random PCM data in
|
|
// the PCM buffer.
|
|
//
|
|
cbADPCM = padss->cbDstLength;
|
|
pBufPCM = (LPBYTE)GlobalAllocPtr( GMEM_FIXED, (UINT)cbPCM );
|
|
pBufADPCM = (LPBYTE)GlobalAllocPtr( GMEM_FIXED, (UINT)cbADPCM );
|
|
if( NULL == pBufPCM || NULL == pBufADPCM )
|
|
{
|
|
uIDS = IDS_ERROR_NOMEM;
|
|
goto errReturn;
|
|
}
|
|
|
|
|
|
//
|
|
// Now, tell the driver to convert our buffer and measure the time.
|
|
// Note that we don't care what is in the source buffer, we only
|
|
// care how long it takes.
|
|
//
|
|
padsh = (LPACMDRVSTREAMHEADER)GlobalAllocPtr( GPTR, sizeof(*padsh) );
|
|
if( NULL == padsh )
|
|
{
|
|
uIDS = IDS_ERROR_NOMEM;
|
|
goto errReturn;
|
|
}
|
|
|
|
// Make sure that no other members of padsh are used!!!
|
|
padsh->cbStruct = sizeof(*padsh);
|
|
padsh->pbSrc = pBufPCM;
|
|
padsh->cbSrcLength = cbPCM;
|
|
padsh->pbDst = pBufADPCM;
|
|
padsh->cbDstLength = cbADPCM;
|
|
padsh->fdwConvert = 0; // Should be 0 already, but...
|
|
|
|
dwStartTime = timeGetTime();
|
|
(void)acmdStreamConvert( pdi, padsi, padsh ); // Won't fail?!
|
|
dwEncodeTime = timeGetTime() - dwStartTime;
|
|
|
|
|
|
//
|
|
// Now, we have an encoded IMA ADPCM buffer. Tell the driver to
|
|
// convert it back to PCM, measuring the time. First we reset the
|
|
// size of the ADPCM buffer to correspond with the buffer returned
|
|
// by the convert. Then we zero out our structure buffers and reset
|
|
// them for the new conversion. Note: we assume that the PCM buffer
|
|
// is already large enough to handle the conversion.
|
|
//
|
|
cbADPCM = padsh->cbDstLengthUsed;
|
|
|
|
#ifdef WIN32
|
|
ZeroMemory( psi, sizeof(*psi) );
|
|
ZeroMemory( padsi, sizeof(*padsi) );
|
|
ZeroMemory( padsh, sizeof(*padsh) );
|
|
#else
|
|
_fmemset( psi, 0, sizeof(*psi) );
|
|
_fmemset( padsi, 0, sizeof(*padsi) );
|
|
_fmemset( padsh, 0, sizeof(*padsh) );
|
|
#endif
|
|
|
|
// Make sure that psi->fnConvert matches the format in pfwADPCM!!!
|
|
psi->fnConvert = imaadpcmDecode4Bit_M16;
|
|
psi->fdwConfig = pdi->fdwConfig;
|
|
psi->nStepIndexL = 0;
|
|
psi->nStepIndexR = 0;
|
|
|
|
// Make sure that no other members of padsi are used!!!
|
|
padsi->cbStruct = sizeof(*padsi);
|
|
padsi->pwfxSrc = (LPWAVEFORMATEX)pwfADPCM;
|
|
padsi->pwfxDst = (LPWAVEFORMATEX)pwfPCM;
|
|
padsi->dwDriver = (DWORD_PTR)psi;
|
|
|
|
// Make sure that no other members of padsh are used!!!
|
|
padsh->cbStruct = sizeof(*padsh);
|
|
padsh->pbSrc = pBufADPCM;
|
|
padsh->cbSrcLength = cbADPCM;
|
|
padsh->pbDst = pBufPCM;
|
|
padsh->cbDstLength = cbPCM;
|
|
padsh->fdwConvert = 0; // Should be 0 already, but...
|
|
|
|
dwStartTime = timeGetTime();
|
|
(void)acmdStreamConvert( pdi, padsi, padsh ); // Won't fail?!
|
|
dwDecodeTime = timeGetTime() - dwStartTime;
|
|
|
|
|
|
//
|
|
// Now, figure out the max encode and decode rates implied by the
|
|
// times required by the conversions.
|
|
//
|
|
if( dwEncodeTime == 0 )
|
|
dwMaxEncodeRate = 0xFFFFFFFFL;
|
|
else
|
|
dwMaxEncodeRate = MulDiv32( pwfPCM->wf.nSamplesPerSec,
|
|
1000L * IMAADPCM_CONFIGTESTTIME,
|
|
dwEncodeTime ) *
|
|
pdi->nConfigPercentCPU / 100;
|
|
|
|
if( dwDecodeTime == 0 )
|
|
dwMaxDecodeRate = 0xFFFFFFFFL;
|
|
else
|
|
dwMaxDecodeRate = MulDiv32( pwfPCM->wf.nSamplesPerSec,
|
|
1000L * IMAADPCM_CONFIGTESTTIME,
|
|
dwDecodeTime ) *
|
|
pdi->nConfigPercentCPU / 100;
|
|
|
|
DPF(1,"dwEncodeTime=%d, dwMaxEncodeRate=%d", dwEncodeTime,dwMaxEncodeRate);
|
|
DPF(1,"dwDecodeTime=%d, dwMaxDecodeRate=%d", dwDecodeTime,dwMaxDecodeRate);
|
|
|
|
|
|
//
|
|
// Now set the configuration based on these values. We scan the
|
|
// gaRateListFormat[] array looking at the dwMonoRate to determine
|
|
// the appropriate setting.
|
|
//
|
|
// Encode.
|
|
//
|
|
nConfig = 0;
|
|
while( gaRateListFormat[nConfig].dwMonoRate < dwMaxEncodeRate &&
|
|
IMAADPCM_CONFIG_NUMSETTINGS > nConfig )
|
|
{
|
|
nConfig++;
|
|
}
|
|
*pnEncodeSetting = nConfig - 1; // We went too far.
|
|
|
|
//
|
|
// Decode.
|
|
//
|
|
nConfig = 0;
|
|
while( gaRateListFormat[nConfig].dwMonoRate < dwMaxDecodeRate &&
|
|
IMAADPCM_CONFIG_NUMSETTINGS > nConfig )
|
|
{
|
|
nConfig++;
|
|
}
|
|
*pnDecodeSetting = nConfig - 1; // We went too far.
|
|
|
|
|
|
//
|
|
// Free structure allocations and exit.
|
|
//
|
|
//
|
|
errReturn:
|
|
|
|
if( NULL != pwfPCM )
|
|
GlobalFreePtr( pwfPCM );
|
|
|
|
if( NULL != pwfADPCM )
|
|
GlobalFreePtr( pwfADPCM );
|
|
|
|
if( NULL != padfs )
|
|
GlobalFreePtr( padfs );
|
|
|
|
if( NULL != padsi )
|
|
GlobalFreePtr( padsi );
|
|
|
|
if( NULL != padsh )
|
|
GlobalFreePtr( padsh );
|
|
|
|
if( NULL != padss )
|
|
GlobalFreePtr( padss );
|
|
|
|
if( NULL != psi )
|
|
LocalFree( (HLOCAL)psi );
|
|
|
|
SetCursor( hCursorSave );
|
|
|
|
return uIDS;
|
|
}
|
|
|
|
|
|
//==========================================================================;
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================;
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// INT_PTR acmdDlgProcConfigure
|
|
//
|
|
// Description:
|
|
// This routine handles the configuration dialog box.
|
|
//
|
|
// Arguments:
|
|
// HWND hwnd:
|
|
//
|
|
// UINT uMsg:
|
|
//
|
|
// WPARAM wParam:
|
|
//
|
|
// LPARAM lParam:
|
|
//
|
|
// Return (BOOL):
|
|
//
|
|
//
|
|
// Note: In order to avoid using a static fHelpRunning flag which will
|
|
// still be here after we exit, we allocate an fHelpRunning
|
|
// variable in the DRIVERINSTANCE structure. This is purely to
|
|
// avoid static variables (which force us to have a data segment
|
|
// of 4K); the fHelpRunning is not used in any other procedures.
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
INT_PTR FNWCALLBACK acmdDlgProcConfigure
|
|
(
|
|
HWND hwnd,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
PDRIVERINSTANCE pdi;
|
|
|
|
HWND hctrlEnc;
|
|
HWND hctrlDec;
|
|
UINT uCmdId;
|
|
UINT u;
|
|
int n;
|
|
TCHAR szFormat[IMAADPCM_CONFIG_TEXTLEN];
|
|
TCHAR szOutput[IMAADPCM_CONFIG_TEXTLEN];
|
|
|
|
UINT nConfigMaxRTEncodeSetting;
|
|
UINT nConfigMaxRTDecodeSetting;
|
|
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
|
|
pdi = (PDRIVERINSTANCE)(UINT_PTR)lParam;
|
|
pdi->fHelpRunning = FALSE; // Used only in this procedure.
|
|
|
|
#ifdef WIN4
|
|
//
|
|
// This driver is marked Windows Subsystem version 3.5 in order
|
|
// that it be compatible with Daytona - however, that means that
|
|
// Chicago will think it is a Win 3.1 application and give it
|
|
// Win 3.1 default colors. This makes the config dialog look
|
|
// white, whereas the Chicago default uses 3DFACE. This code
|
|
// (and the CTLCOLOR messages) sets the colors explicitly.
|
|
//
|
|
pdi->hbrDialog = CreateSolidBrush( GetSysColor(COLOR_3DFACE) );
|
|
#endif
|
|
|
|
SetWindowLongPtr(hwnd, DWLP_USER, lParam);
|
|
|
|
nConfigMaxRTEncodeSetting = pdi->nConfigMaxRTEncodeSetting;
|
|
nConfigMaxRTDecodeSetting = pdi->nConfigMaxRTDecodeSetting;
|
|
|
|
hctrlEnc = GetDlgItem(hwnd, IDC_COMBO_MAXRTENCODE);
|
|
hctrlDec = GetDlgItem(hwnd, IDC_COMBO_MAXRTDECODE);
|
|
|
|
for( u=0; u<IMAADPCM_CONFIG_NUMSETTINGS; u++ )
|
|
{
|
|
LoadString( pdi->hinst, gaRateListFormat[u].idsFormat,
|
|
szFormat, SIZEOF(szFormat) );
|
|
|
|
switch( gaRateListFormat[u].uFormatType )
|
|
{
|
|
case CONFIG_RLF_NONUMBER:
|
|
lstrcpy( szOutput, szFormat );
|
|
break;
|
|
|
|
case CONFIG_RLF_MONOONLY:
|
|
wsprintf( szOutput, szFormat,
|
|
gaRateListFormat[u].dwMonoRate );
|
|
break;
|
|
|
|
case CONFIG_RLF_STEREOONLY:
|
|
wsprintf( szOutput, szFormat,
|
|
gaRateListFormat[u].dwMonoRate / 2 );
|
|
break;
|
|
|
|
case CONFIG_RLF_MONOSTEREO:
|
|
wsprintf( szOutput, szFormat,
|
|
gaRateListFormat[u].dwMonoRate,
|
|
gaRateListFormat[u].dwMonoRate / 2 );
|
|
break;
|
|
}
|
|
|
|
ComboBox_AddString(hctrlEnc, szOutput);
|
|
ComboBox_AddString(hctrlDec, szOutput);
|
|
}
|
|
|
|
ComboBox_SetCurSel( hctrlEnc, nConfigMaxRTEncodeSetting );
|
|
ComboBox_SetCurSel( hctrlDec, nConfigMaxRTDecodeSetting );
|
|
|
|
return (TRUE);
|
|
|
|
case WM_DESTROY:
|
|
|
|
pdi = (PDRIVERINSTANCE)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
if (pdi->fHelpRunning)
|
|
{
|
|
WinHelp(hwnd, gszHelpFilename, HELP_QUIT, 0L);
|
|
}
|
|
#ifdef WIN4
|
|
DeleteObject( pdi->hbrDialog );
|
|
#endif
|
|
|
|
//
|
|
// Let dialog box process this message
|
|
//
|
|
//
|
|
return (FALSE);
|
|
|
|
#ifdef WIN4
|
|
//
|
|
// Handle CTLCOLOR messages to get the dialog boxes to the default
|
|
// Chicago colors. See the INITDIALOG message, above.
|
|
//
|
|
case WM_CTLCOLORSTATIC:
|
|
case WM_CTLCOLORDLG:
|
|
case WM_CTLCOLORBTN:
|
|
SetTextColor( (HDC)wParam, GetSysColor(COLOR_WINDOWTEXT) );
|
|
SetBkColor( (HDC)wParam, GetSysColor(COLOR_3DFACE) );
|
|
pdi = (PDRIVERINSTANCE)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
return (UINT_PTR)pdi->hbrDialog;
|
|
#endif
|
|
|
|
case WM_HELP:
|
|
WinHelp(((LPHELPINFO)lParam)->hItemHandle, gszHelpFilename,
|
|
HELP_WM_HELP, (ULONG_PTR)aKeyWordIds);
|
|
return (TRUE);
|
|
|
|
case WM_COMMAND:
|
|
|
|
pdi = (PDRIVERINSTANCE)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
|
|
uCmdId = (UINT) wParam;
|
|
|
|
switch (uCmdId)
|
|
{
|
|
case IDC_BTN_AUTOCONFIG:
|
|
{
|
|
UINT uErrorIDS;
|
|
|
|
uErrorIDS = configAutoConfig( pdi,
|
|
&nConfigMaxRTEncodeSetting,
|
|
&nConfigMaxRTDecodeSetting );
|
|
if( 0==uErrorIDS )
|
|
{
|
|
//
|
|
// No error - set dialog box settings.
|
|
//
|
|
hctrlEnc = GetDlgItem( hwnd, IDC_COMBO_MAXRTENCODE );
|
|
ComboBox_SetCurSel( hctrlEnc, nConfigMaxRTEncodeSetting );
|
|
hctrlDec = GetDlgItem( hwnd, IDC_COMBO_MAXRTDECODE );
|
|
ComboBox_SetCurSel( hctrlDec, nConfigMaxRTDecodeSetting );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Display error message.
|
|
//
|
|
TCHAR tstrErr[200];
|
|
TCHAR tstrErrTitle[200];
|
|
|
|
if (0 == LoadString(pdi->hinst, IDS_ERROR, tstrErrTitle, SIZEOF(tstrErrTitle)))
|
|
break;
|
|
if (0 == LoadString(pdi->hinst, uErrorIDS, tstrErr, SIZEOF(tstrErr)))
|
|
break;
|
|
MessageBox(hwnd, tstrErr, tstrErrTitle, MB_ICONEXCLAMATION | MB_OK);
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case IDOK:
|
|
n = DRVCNF_CANCEL;
|
|
|
|
//
|
|
// RT Encode setting
|
|
//
|
|
hctrlEnc = GetDlgItem(hwnd, IDC_COMBO_MAXRTENCODE);
|
|
nConfigMaxRTEncodeSetting = ComboBox_GetCurSel( hctrlEnc );
|
|
if (nConfigMaxRTEncodeSetting != pdi->nConfigMaxRTEncodeSetting)
|
|
{
|
|
pdi->nConfigMaxRTEncodeSetting = nConfigMaxRTEncodeSetting;
|
|
n = DRVCNF_OK;
|
|
}
|
|
|
|
//
|
|
// RT Decode setting
|
|
//
|
|
hctrlDec = GetDlgItem(hwnd, IDC_COMBO_MAXRTDECODE);
|
|
nConfigMaxRTDecodeSetting = ComboBox_GetCurSel( hctrlDec );
|
|
if (nConfigMaxRTDecodeSetting != pdi->nConfigMaxRTDecodeSetting)
|
|
{
|
|
pdi->nConfigMaxRTDecodeSetting = nConfigMaxRTDecodeSetting;
|
|
n = DRVCNF_OK;
|
|
}
|
|
|
|
//
|
|
// If we changed something, write the data to the
|
|
// registry.
|
|
//
|
|
if( DRVCNF_OK == n )
|
|
{
|
|
configWriteConfiguration( pdi );
|
|
}
|
|
|
|
EndDialog(hwnd, DRVCNF_OK);
|
|
break;
|
|
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hwnd, DRVCNF_CANCEL);
|
|
break;
|
|
|
|
case IDC_BTN_HELP:
|
|
pdi->fHelpRunning = TRUE;
|
|
WinHelp(hwnd, gszHelpFilename, HELP_CONTEXT, HELPCONTEXT_IMAADPCM);
|
|
break;
|
|
}
|
|
return (TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
} // acmdDlgProcConfigure()
|
|
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// BOOL acmdDriverConfigInit
|
|
//
|
|
// Description:
|
|
// This routine initializes the configuration parameters by reading them
|
|
// from the registry. If there are no entries in the registry, this
|
|
// codec auto-configures itself and writes the results to the registry.
|
|
// If the auto-configure fails, or if we don't know our alias name,
|
|
// then we set the configuration to default values.
|
|
//
|
|
// Arguments:
|
|
// PDRIVERINSTANCE pdi:
|
|
//
|
|
// LPCTSTR pszAliasName:
|
|
//
|
|
// Return (BOOL):
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
BOOL FNGLOBAL acmdDriverConfigInit
|
|
(
|
|
PDRIVERINSTANCE pdi,
|
|
LPCTSTR pszAliasName
|
|
)
|
|
{
|
|
HKEY hkey;
|
|
UINT nEncodeSetting;
|
|
UINT nDecodeSetting;
|
|
UINT uErrorIDS;
|
|
|
|
|
|
//
|
|
// If pszAliasName is NULL then just set all defaults
|
|
//
|
|
//
|
|
if (NULL == pszAliasName)
|
|
{
|
|
DPF(2,"acmdDriverConfigInit: no alias name; using default settings.");
|
|
|
|
configSetDefaults( pdi );
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
//
|
|
// If we haven't got an open hkey, then open it. Note that this routine
|
|
// may be called more than once; on the second time, we should not
|
|
// re-open the key.
|
|
//
|
|
if( NULL == pdi->hkey )
|
|
{
|
|
RegCreateKeyEx( IMAADPCM_CONFIG_DEFAULTKEY, gszMultimediaKey, 0,
|
|
NULL, 0, KEY_CREATE_SUB_KEY, NULL, &hkey, NULL );
|
|
|
|
if( NULL != hkey )
|
|
{
|
|
ASSERT( NULL != pszAliasName );
|
|
|
|
RegCreateKeyEx( hkey, pszAliasName, 0, NULL, 0,
|
|
KEY_SET_VALUE | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
|
|
NULL, &pdi->hkey, NULL );
|
|
|
|
RegCloseKey( hkey );
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Read configuration data from registry.
|
|
//
|
|
if( NULL == pdi->hkey )
|
|
{
|
|
configSetDefaults( pdi );
|
|
}
|
|
else
|
|
{
|
|
pdi->nConfigMaxRTEncodeSetting =
|
|
(UINT)dwReadRegistryDefault( pdi->hkey,
|
|
(LPTSTR)gszMaxRTEncodeSetting,
|
|
IMAADPCM_CONFIG_UNCONFIGURED );
|
|
|
|
pdi->nConfigMaxRTDecodeSetting =
|
|
(UINT)dwReadRegistryDefault( pdi->hkey,
|
|
(LPTSTR)gszMaxRTDecodeSetting,
|
|
IMAADPCM_CONFIG_UNCONFIGURED );
|
|
|
|
pdi->nConfigPercentCPU =
|
|
(UINT)dwReadRegistryDefault( pdi->hkey,
|
|
(LPTSTR)gszPercentCPU,
|
|
IMAADPCM_CONFIG_DEFAULT_PERCENTCPU );
|
|
|
|
//
|
|
// Check that nConfigPercentCPU is a valid value.
|
|
//
|
|
if( pdi->nConfigPercentCPU <= 0 )
|
|
{
|
|
pdi->nConfigPercentCPU = IMAADPCM_CONFIG_DEFAULT_PERCENTCPU;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// If either the encode or decode setting is out of range, then
|
|
// we call the auto-configure routine and write out the results.
|
|
// This should only happen the first time the codec is run.
|
|
//
|
|
if( IMAADPCM_CONFIG_NUMSETTINGS <= pdi->nConfigMaxRTEncodeSetting ||
|
|
IMAADPCM_CONFIG_NUMSETTINGS <= pdi->nConfigMaxRTDecodeSetting )
|
|
{
|
|
DPF( 1, "acmdDriverConfigInit: performing initial auto-config." );
|
|
uErrorIDS = configAutoConfig( pdi,
|
|
&nEncodeSetting,
|
|
&nDecodeSetting );
|
|
|
|
if( 0 != uErrorIDS )
|
|
{
|
|
//
|
|
// Error in auto-config. Use defaults instead.
|
|
//
|
|
nEncodeSetting = IMAADPCM_CONFIG_DEFAULT_MAXRTENCODESETTING;
|
|
nDecodeSetting = IMAADPCM_CONFIG_DEFAULT_MAXRTDECODESETTING;
|
|
}
|
|
|
|
pdi->nConfigMaxRTEncodeSetting = nEncodeSetting;
|
|
pdi->nConfigMaxRTDecodeSetting = nDecodeSetting;
|
|
|
|
//
|
|
// Always write the results to the registry, even if we hit an
|
|
// error, so we won't hit the automatic auto-config next
|
|
// time we run. One failure is enough!
|
|
//
|
|
configWriteConfiguration( pdi );
|
|
}
|
|
|
|
return (TRUE);
|
|
} // acmdDriverConfigInit()
|
|
|
|
#endif // IMAADPCM_USECONFIG
|