1819 lines
53 KiB
C++
1819 lines
53 KiB
C++
/*
|
||
* File: msiacaps.cpp
|
||
*
|
||
* ACM implementation of Microsoft Network Audio capability object.
|
||
*
|
||
* Revision History:
|
||
*
|
||
* 06/06/96 mikev created
|
||
*/
|
||
|
||
|
||
#include "precomp.h"
|
||
|
||
//Prototypes....
|
||
ULONG ReadRegistryFormats (LPCSTR lpszKeyName,CHAR ***pppName,BYTE ***pppData,PUINT pnFormats,DWORD dwDebugSize);
|
||
void FreeRegistryFormats (PRRF_INFO pRegFmts);
|
||
|
||
static BOOL bUseDefault;
|
||
|
||
|
||
#define szRegMSIPAndH323Encodings TEXT("ACMH323Encodings")
|
||
|
||
|
||
AUDCAP_DETAILS default_id_table[] =
|
||
{
|
||
|
||
|
||
{WAVE_FORMAT_ADPCM, NONSTD_TERMCAP, STD_CHAN_PARAMS, {RTP_DYNAMIC_MIN, 0, 8000, 4},
|
||
0, TRUE, TRUE, 500, 32000,32000,50,0,PREF_ORDER_UNASSIGNED,0,NULL,0, NULL,
|
||
"Microsoft ADPCM"},
|
||
|
||
|
||
{WAVE_FORMAT_LH_CELP, NONSTD_TERMCAP, STD_CHAN_PARAMS,{RTP_DYNAMIC_MIN, 0, 8000, 16},
|
||
0, TRUE, TRUE, 640, 5600,5600,LNH_48_CPU,0,3,0,NULL,0,NULL,
|
||
"Lernout & Hauspie CELP 4.8kbit/s"},
|
||
{WAVE_FORMAT_LH_SB8, NONSTD_TERMCAP, STD_CHAN_PARAMS,{RTP_DYNAMIC_MIN, 0, 8000, 16},
|
||
0, TRUE, TRUE, 640, 8000,8000,LNH_8_CPU,0,0,0,NULL,0,NULL,
|
||
"Lernout & Hauspie SBC 8kbit/s"},
|
||
{WAVE_FORMAT_LH_SB12, NONSTD_TERMCAP, STD_CHAN_PARAMS, {RTP_DYNAMIC_MIN, 0, 8000, 16},
|
||
0, TRUE, TRUE, 640, 12000,12000,LNH_12_CPU,0,1,0,NULL,0,NULL,
|
||
"Lernout & Hauspie SBC 12kbit/s"},
|
||
{WAVE_FORMAT_LH_SB16, NONSTD_TERMCAP, STD_CHAN_PARAMS,{RTP_DYNAMIC_MIN, 0, 8000, 16},
|
||
0, TRUE, TRUE, 640, 16000,16000,LNH_16_CPU,0,2,0,NULL,0,NULL,
|
||
"Lernout & Hauspie SBC 16kbit/s"},
|
||
{WAVE_FORMAT_MSRT24, NONSTD_TERMCAP, STD_CHAN_PARAMS,{RTP_DYNAMIC_MIN, 0, 8000, 16},
|
||
0, TRUE, TRUE, 720, 2400,2400,MSRT24_CPU,0,4,0,NULL,0,NULL,
|
||
"Voxware RT 2.4kbit/s"},
|
||
{WAVE_FORMAT_MSG723, STD_TERMCAP(H245_CLIENT_AUD_G723), // client type H245_CLIENT_AUD_G723,
|
||
STD_CHAN_PARAMS, {RTP_PAYLOAD_G723, 0, 8000, 0},
|
||
0, TRUE, TRUE, 960, 5600,5600,MS_G723_CPU,0,
|
||
0, // priority
|
||
0,NULL,0,NULL, "Microsoft G.723.1"},
|
||
{WAVE_FORMAT_ALAW, STD_TERMCAP( H245_CLIENT_AUD_G711_ALAW64),
|
||
STD_CHAN_PARAMS, {RTP_PAYLOAD_G711_ALAW, 0, 8000, 8},
|
||
0, TRUE, TRUE, 500, 64000,64000,CCITT_A_CPU,0,0,
|
||
0, NULL, 0, NULL, "CCITT A-Law"},
|
||
{WAVE_FORMAT_MULAW, STD_TERMCAP( H245_CLIENT_AUD_G711_ULAW64),
|
||
STD_CHAN_PARAMS, {RTP_PAYLOAD_G711_MULAW, 0, 8000, 8},
|
||
0, TRUE, TRUE, 500, 64000,64000,CCITT_U_CPU,0,0,
|
||
0, NULL, 0, NULL, "CCITT u-Law"},
|
||
|
||
#if(0)
|
||
// do not use this version of the G.723 codec
|
||
{WAVE_FORMAT_INTELG723, STD_TERMCAP(H245_CLIENT_AUD_G723), // client type H245_CLIENT_AUD_G723,
|
||
STD_CHAN_PARAMS, {RTP_DYNAMIC_MIN, 0, 8000, 0},
|
||
0, TRUE, TRUE, 960, 16000,16000,99,0,
|
||
0, // priority
|
||
0,NULL,0,NULL, "G.723"},
|
||
|
||
{WAVE_FORMAT_DSPGROUP_TRUESPEECH, {
|
||
NONSTD_TERMCAP, {RTP_DYNAMIC_MIN, 0, 5510, 4},
|
||
0, TRUE, TRUE, 500, 5510,5510,50,0,0,0,NULL},
|
||
"DSP Group TrueSpeech(TM)"},
|
||
{WAVE_FORMAT_PCM, {{RTP_DYNAMIC_MIN, 0, 8000, 8}, TRUE, TRUE, 160, 64000,64000,50,0,0,0,NULL,0,NULL}, "MS-ADPCM"},
|
||
{WAVE_FORMAT_PCM, {{RTP_DYNAMIC_MIN, 0, 5510, 8}, TRUE, TRUE, 160, 44080,44080,50,0,0,0,NULL,0,NULL}, "MS-ADPCM"},
|
||
{WAVE_FORMAT_PCM, {{RTP_DYNAMIC_MIN, 0, 11025, 8}, TRUE, TRUE, 160, 88200,88200,50,0,0,0,NULL,0,NULL},"MS-ADPCM"},
|
||
{WAVE_FORMAT_PCM, {{RTP_DYNAMIC_MIN, 0, 8000, 16}, TRUE, TRUE, 160, 128000,128000,50,0,0,0,NULL,0,NULL},"MS-ADPCM"},
|
||
{WAVE_FORMAT_ADPCM, {{RTP_DYNAMIC_MIN, 0, 8000, 4}, TRUE, TRUE, 500, 16000,16000,50,0,,0,0,NULL,0,NULL}, "MS-ADPCM"},
|
||
{WAVE_FORMAT_GSM610, STD_CHAN_PARAMS,{RTP_DYNAMIC_MIN, 0, 8000, 0},
|
||
0, TRUE, TRUE, 320, 8000,8000,96,0,PREF_ORDER_UNASSIGNED,0,NULL,0,NULL,
|
||
//"Microsoft GSM 6.10"
|
||
"GSM 6.10"},
|
||
#endif // DEF_USE_ALLPCM
|
||
|
||
|
||
};
|
||
|
||
|
||
UINT uDefTableEntries = sizeof(default_id_table) /sizeof(AUDCAP_DETAILS);
|
||
static BOOL bCreateDefTable = FALSE;
|
||
|
||
|
||
//
|
||
// static members of CMsiaCapability
|
||
//
|
||
|
||
MEDIA_FORMAT_ID CMsiaCapability::IDsByRank[MAX_CAPS_PRESORT];
|
||
UINT CMsiaCapability::uNumLocalFormats = 0; // # of active entries in pLocalFormats
|
||
UINT CMsiaCapability::uStaticRef = 0; // global ref count
|
||
UINT CMsiaCapability::uCapIDBase = 0; // rebase capability ID to index into IDsByRank
|
||
UINT CMsiaCapability::uLocalFormatCapacity = 0; // size of pLocalFormats (in multiples of AUDCAP_DETAILS)
|
||
AUDCAP_DETAILS * CMsiaCapability::pLocalFormats = NULL;
|
||
|
||
CMsiaCapability::CMsiaCapability()
|
||
:uRef(1),
|
||
wMaxCPU(95),
|
||
m_uPacketDuration(90),
|
||
uNumRemoteDecodeFormats(0),
|
||
uRemoteDecodeFormatCapacity(0),
|
||
pRemoteDecodeFormats(NULL),
|
||
bPublicizeTXCaps(FALSE),
|
||
bPublicizeTSTradeoff(FALSE),
|
||
pRegFmts(NULL)
|
||
|
||
{
|
||
m_IAppCap.Init(this);
|
||
}
|
||
|
||
CMsiaCapability::~CMsiaCapability()
|
||
{
|
||
CloseACMDriver();
|
||
UINT u;
|
||
AUDCAP_DETAILS *pDetails;
|
||
// release global static memory (the local capabilities) if this is the last delete
|
||
if(uStaticRef <= 1)
|
||
{
|
||
if (pLocalFormats)
|
||
{
|
||
pDetails = pLocalFormats;
|
||
for(u=0; u <uNumLocalFormats; u++)
|
||
{
|
||
if(pDetails->lpLocalFormatDetails)
|
||
{
|
||
MEMFREE(pDetails->lpLocalFormatDetails);
|
||
}
|
||
// there really should never be remote details associated with the local
|
||
// formats........
|
||
if(pDetails->lpRemoteFormatDetails)
|
||
{
|
||
MEMFREE(pDetails->lpRemoteFormatDetails);
|
||
}
|
||
|
||
pDetails++;
|
||
}
|
||
MEMFREE(pLocalFormats);
|
||
pLocalFormats=NULL;
|
||
uLocalFormatCapacity = 0;
|
||
}
|
||
uStaticRef--;
|
||
|
||
//Clean up the format cache. - This was the audio format information that
|
||
//Was in the registry. A list of names, ptrs to AUDCAP_DETAILS blocks
|
||
//and a count of formats. Memory is allocated in ReadRegistryFormats,
|
||
//called from ReInit()
|
||
|
||
}
|
||
else
|
||
{
|
||
uStaticRef--;
|
||
}
|
||
|
||
if (pRemoteDecodeFormats)
|
||
{
|
||
pDetails = pRemoteDecodeFormats;
|
||
for(u=0; u <uNumRemoteDecodeFormats; u++)
|
||
{
|
||
if(pDetails->lpLocalFormatDetails)
|
||
{
|
||
MEMFREE(pDetails->lpLocalFormatDetails);
|
||
}
|
||
// there really should never be remote details associated with the local
|
||
// formats........
|
||
if(pDetails->lpRemoteFormatDetails)
|
||
{
|
||
MEMFREE(pDetails->lpRemoteFormatDetails);
|
||
}
|
||
|
||
pDetails++;
|
||
}
|
||
MEMFREE(pRemoteDecodeFormats);
|
||
pRemoteDecodeFormats=NULL;
|
||
uRemoteDecodeFormatCapacity = 0;
|
||
}
|
||
|
||
FreeRegistryFormats(pRegFmts);
|
||
}
|
||
|
||
BOOL CMsiaCapability::Init()
|
||
{
|
||
BOOL bRet;
|
||
if(uStaticRef == 0)
|
||
{
|
||
if(bRet = ReInit())
|
||
{
|
||
uStaticRef++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
uStaticRef++;
|
||
bRet = TRUE;
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
|
||
BOOL CMsiaCapability::ReInit()
|
||
{
|
||
SYSTEM_INFO si;
|
||
DWORD dwDisposition;
|
||
BOOL bRet = TRUE;
|
||
ACM_APP_PARAM sAppParam={this, NULL, ACMAPP_FORMATENUMHANDLER_ENUM, NULL, NULL, 0, NULL};
|
||
ACMFORMATTAGDETAILS aftd;
|
||
AUDCAP_DETAILS audcapDetails;
|
||
UINT i;
|
||
|
||
ZeroMemory(&IDsByRank, sizeof(IDsByRank));
|
||
|
||
// LOOKLOOK - this supports a hack to disable CPU intensive codecs if not running on a pentium
|
||
GetSystemInfo(&si);
|
||
#ifdef _M_IX86
|
||
wMaxCPU = (si.dwProcessorType == PROCESSOR_INTEL_PENTIUM )? 100 : 50;
|
||
#endif
|
||
#ifdef _ALPHA_
|
||
wMaxCPU = 100;
|
||
#endif
|
||
if (pLocalFormats)
|
||
{
|
||
UINT u;
|
||
AUDCAP_DETAILS *pDetails = pLocalFormats;
|
||
for(u=0; u <uNumLocalFormats; u++)
|
||
{
|
||
if(pDetails->lpLocalFormatDetails)
|
||
{
|
||
MEMFREE(pDetails->lpLocalFormatDetails);
|
||
}
|
||
// there really should never be remote details associated with the local
|
||
// formats........
|
||
if(pDetails->lpRemoteFormatDetails)
|
||
{
|
||
MEMFREE(pDetails->lpRemoteFormatDetails);
|
||
}
|
||
|
||
pDetails++;
|
||
}
|
||
MEMFREE(pLocalFormats);
|
||
pLocalFormats = NULL;
|
||
uLocalFormatCapacity = 0;
|
||
}
|
||
|
||
uNumLocalFormats = 0;
|
||
uCapIDBase=0;
|
||
|
||
/*
|
||
* Format cache
|
||
*/
|
||
|
||
|
||
if (!pRegFmts) {
|
||
if (!(pRegFmts=(PRRF_INFO)MemAlloc (sizeof (RRF_INFO)))) {
|
||
bRet = FALSE;
|
||
goto RELEASE_AND_EXIT;
|
||
}
|
||
|
||
bUseDefault=FALSE;
|
||
|
||
if (ReadRegistryFormats (szRegInternetPhone TEXT("\\") szRegMSIPAndH323Encodings,
|
||
&pRegFmts->pNames,(BYTE ***)&pRegFmts->pData,&pRegFmts->nFormats,sizeof (AUDCAP_DETAILS)) != ERROR_SUCCESS) {
|
||
bUseDefault=TRUE;
|
||
MemFree ((void *) pRegFmts);
|
||
pRegFmts=NULL;
|
||
}
|
||
}
|
||
|
||
// pass the registry formats through ACM to the handler
|
||
sAppParam.pRegCache=pRegFmts;
|
||
|
||
if(!DriverEnum((DWORD_PTR) &sAppParam))
|
||
{
|
||
bRet = FALSE;
|
||
goto RELEASE_AND_EXIT;
|
||
}
|
||
|
||
SortEncodeCaps(SortByAppPref);
|
||
RELEASE_AND_EXIT:
|
||
return bRet;
|
||
}
|
||
|
||
|
||
STDMETHODIMP CMsiaCapability::QueryInterface( REFIID iid, void ** ppvObject)
|
||
{
|
||
// this breaks the rules for the official COM QueryInterface because
|
||
// the interfaces that are queried for are not necessarily real COM
|
||
// interfaces. The reflexive property of QueryInterface would be broken in
|
||
// that case.
|
||
|
||
HRESULT hr = E_NOINTERFACE;
|
||
if(!ppvObject)
|
||
return hr;
|
||
|
||
*ppvObject = 0;
|
||
if(iid == IID_IAppAudioCap )
|
||
{
|
||
*ppvObject = (LPAPPCAPPIF)&m_IAppCap;
|
||
AddRef();
|
||
hr = hrSuccess;
|
||
}
|
||
else if(iid == IID_IH323MediaCap)
|
||
{
|
||
*ppvObject = (IH323MediaCap *)this;
|
||
AddRef();
|
||
hr = hrSuccess;
|
||
}
|
||
else if (iid == IID_IUnknown)
|
||
{
|
||
*ppvObject = this;
|
||
AddRef();
|
||
hr = hrSuccess;
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
ULONG CMsiaCapability::AddRef()
|
||
{
|
||
uRef++;
|
||
return uRef;
|
||
}
|
||
|
||
ULONG CMsiaCapability::Release()
|
||
{
|
||
uRef--;
|
||
if(uRef == 0)
|
||
{
|
||
delete this;
|
||
return 0;
|
||
}
|
||
return uRef;
|
||
}
|
||
VOID CMsiaCapability::FreeRegistryKeyName(LPTSTR lpszKeyName)
|
||
{
|
||
if (lpszKeyName)
|
||
{
|
||
LocalFree(lpszKeyName);
|
||
}
|
||
}
|
||
|
||
LPTSTR CMsiaCapability::AllocRegistryKeyName(LPTSTR lpDriverName,
|
||
UINT uSampleRate, UINT uBitsPerSample, UINT uBytesPerSec)
|
||
{
|
||
FX_ENTRY(("MsiaCapability::AllocRegistryKeyName"));
|
||
BOOL bRet = FALSE;
|
||
LPTSTR lpszKeyName = NULL;
|
||
|
||
if(!lpDriverName)
|
||
{
|
||
return NULL;
|
||
}
|
||
// build a subkey name (drivername_samplerate_bitspersample)
|
||
// allow room for THREE underscore chars + 2x17 bytes of string returned
|
||
// from _itoa
|
||
|
||
// NOTE: use wsprintf instead of itoa - because of dependency on runtime lib
|
||
lpszKeyName = (LPTSTR)LocalAlloc (LPTR, lstrlen(lpDriverName) * sizeof(*lpDriverName)+3*20);
|
||
if (!lpszKeyName)
|
||
{
|
||
ERRORMESSAGE(("%s: LocalAlloc failed\r\n",_fx_));
|
||
return(NULL);
|
||
}
|
||
// build a subkey name ("drivername_samplerate_bitspersample")
|
||
wsprintf(lpszKeyName,
|
||
"%s_%u_%u_%u",
|
||
lpDriverName,
|
||
uSampleRate,
|
||
uBitsPerSample,
|
||
uBytesPerSec);
|
||
|
||
return (lpszKeyName);
|
||
}
|
||
|
||
|
||
VOID CMsiaCapability::SortEncodeCaps(SortMode sortmode)
|
||
{
|
||
UINT iSorted=0;
|
||
UINT iInsert = 0;
|
||
UINT iCache=0;
|
||
UINT iTemp =0;
|
||
BOOL bInsert;
|
||
AUDCAP_DETAILS *pDetails1, *pDetails2;
|
||
|
||
if(!uNumLocalFormats)
|
||
return;
|
||
if(uNumLocalFormats ==1)
|
||
{
|
||
IDsByRank[0]=0;
|
||
return;
|
||
}
|
||
|
||
// look at every cached format, build index array
|
||
for(iCache=0;iCache<uNumLocalFormats;iCache++)
|
||
{
|
||
pDetails1 = pLocalFormats+iCache;
|
||
for(iInsert=0;iInsert < iSorted; iInsert++)
|
||
{
|
||
pDetails2 = pLocalFormats+IDsByRank[iInsert];
|
||
// if existing stuff is less than new stuff....
|
||
|
||
bInsert = FALSE;
|
||
switch(sortmode)
|
||
{
|
||
case SortByAppPref:
|
||
if(pDetails2->wApplicationPrefOrder > pDetails1->wApplicationPrefOrder)
|
||
bInsert = TRUE;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
if(bInsert)
|
||
{
|
||
if(iSorted < MAX_CAPS_PRESORT)
|
||
{
|
||
iSorted++;
|
||
}
|
||
// make room, if there is something in the last element,
|
||
// it gets overwritten
|
||
for(iTemp = iSorted-1; iTemp > iInsert; iTemp--)
|
||
{
|
||
IDsByRank[iTemp] = IDsByRank[iTemp-1];
|
||
}
|
||
// insert at iInsert
|
||
IDsByRank[iInsert] = iCache;
|
||
break;
|
||
}
|
||
}
|
||
// check end boundary
|
||
if((iInsert == iSorted) && (iInsert < MAX_CAPS_PRESORT))
|
||
{
|
||
IDsByRank[iInsert] = iCache;
|
||
iSorted++;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
STDMETHODIMP CMsiaCapability::GetDecodeFormatDetails(MEDIA_FORMAT_ID FormatID, VOID **ppFormat, UINT *puSize)
|
||
{
|
||
// validate input
|
||
UINT uIndex = IDToIndex(FormatID);
|
||
if(uIndex >= (UINT)uNumLocalFormats)
|
||
{
|
||
*puSize = 0;
|
||
*ppFormat = NULL;
|
||
return E_INVALIDARG;
|
||
}
|
||
|
||
*ppFormat = (pLocalFormats + uIndex)->lpLocalFormatDetails;
|
||
*puSize = SIZEOF_WAVEFORMATEX((WAVEFORMATEX*)(*ppFormat));
|
||
return S_OK;
|
||
|
||
}
|
||
|
||
STDMETHODIMP CMsiaCapability::GetEncodeFormatDetails(MEDIA_FORMAT_ID FormatID, VOID **ppFormat, UINT *puSize)
|
||
{
|
||
// same as GetDecodeFormatDetails
|
||
return GetDecodeFormatDetails(FormatID, ppFormat, puSize);
|
||
}
|
||
|
||
VOID CMsiaCapability::CalculateFormatProperties(AUDCAP_DETAILS *pFmtBuf,LPWAVEFORMATEX lpwfx)
|
||
{
|
||
WORD wFrames;
|
||
if(!pFmtBuf)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// use actual bits per sample unless the bps field is zero, in which case
|
||
// assume 16 bits (worst case). This is a typical GSM scenario
|
||
UINT uBitrateIn = (pFmtBuf->audio_params.uSamplesPerSec) *
|
||
((pFmtBuf->audio_params.uBitsPerSample)
|
||
? pFmtBuf->audio_params.uBitsPerSample
|
||
:16);
|
||
|
||
// set the maximum bitrate (uMaxBitrate). we're not setting the average bitrate (uAvgBitrate),
|
||
// since the nAvgBytesPerSec reported by ACM is really worst case. uAvgBitrate will be set
|
||
// from the hardcoded numbers for our known codecs and from the provided AUDCAP_INFO for
|
||
// installable codecs
|
||
pFmtBuf->uMaxBitrate = (lpwfx->nAvgBytesPerSec)? lpwfx->nAvgBytesPerSec*8:uBitrateIn;
|
||
|
||
pFmtBuf->dwDefaultSamples = MinSampleSize(lpwfx);
|
||
|
||
// nonstandard channel parameters. This
|
||
// might be a good point to calculate values that don't have valid defaults set.
|
||
wFrames = pFmtBuf->nonstd_params.wFramesPerPktMax;
|
||
if(!pFmtBuf->nonstd_params.wFramesPerPktMax)
|
||
{
|
||
pFmtBuf->nonstd_params.wFramesPerPktMax=
|
||
wFrames = LOWORD(MaxFramesPerPacket(lpwfx));
|
||
}
|
||
// if the preferred frames/packet is 0 or greater than the max, set it to min
|
||
if((pFmtBuf->nonstd_params.wFramesPerPkt ==0) ||
|
||
(pFmtBuf->nonstd_params.wFramesPerPkt > wFrames))
|
||
{
|
||
pFmtBuf->nonstd_params.wFramesPerPkt =
|
||
LOWORD(MinFramesPerPacket(lpwfx));
|
||
}
|
||
// if the min is more than preferred, fix it
|
||
if(pFmtBuf->nonstd_params.wFramesPerPktMin > pFmtBuf->nonstd_params.wFramesPerPkt)
|
||
{
|
||
pFmtBuf->nonstd_params.wFramesPerPktMin =
|
||
LOWORD(MinFramesPerPacket(lpwfx));
|
||
}
|
||
|
||
pFmtBuf->nonstd_params.wDataRate =0; // default
|
||
pFmtBuf->nonstd_params.wFrameSize = (pFmtBuf->nonstd_params.wFramesPerPkt)
|
||
? LOWORD(pFmtBuf->dwDefaultSamples / pFmtBuf->nonstd_params.wFramesPerPkt): 0;
|
||
pFmtBuf->nonstd_params.UsePostFilter = 0;
|
||
pFmtBuf->nonstd_params.UseSilenceDet = 0;
|
||
|
||
}
|
||
|
||
|
||
AUDIO_FORMAT_ID CMsiaCapability::AddFormat(AUDCAP_DETAILS *pFmtBuf,LPVOID lpvMappingData, UINT uSize)
|
||
{
|
||
FX_ENTRY(("CMsiaCapability::AddFormat"));
|
||
AUDCAP_DETAILS *pTemp;
|
||
WORD wFrames;
|
||
UINT uSamples;
|
||
if(!pFmtBuf || !lpvMappingData || !uSize)
|
||
{
|
||
return INVALID_AUDIO_FORMAT;
|
||
}
|
||
// check room
|
||
if(uLocalFormatCapacity <= uNumLocalFormats)
|
||
{
|
||
// get more mem, realloc memory by CAP_CHUNK_SIZE for pLocalFormats
|
||
pTemp = (AUDCAP_DETAILS *)MEMALLOC((uNumLocalFormats + CAP_CHUNK_SIZE)*sizeof(AUDCAP_DETAILS));
|
||
if(!pTemp)
|
||
goto ERROR_EXIT;
|
||
// remember how much capacity we now have
|
||
uLocalFormatCapacity = uNumLocalFormats + CAP_CHUNK_SIZE;
|
||
#ifdef DEBUG
|
||
if((uNumLocalFormats && !pLocalFormats) || (!uNumLocalFormats && pLocalFormats))
|
||
{
|
||
ERRORMESSAGE(("%s:leak! uNumLocalFormats:0x%08lX, pLocalFormats:0x%08lX\r\n",
|
||
_fx_, uNumLocalFormats,pLocalFormats));
|
||
}
|
||
#endif
|
||
// copy old stuff, discard old mem
|
||
if(uNumLocalFormats && pLocalFormats)
|
||
{
|
||
memcpy(pTemp, pLocalFormats, uNumLocalFormats*sizeof(AUDCAP_DETAILS));
|
||
MEMFREE(pLocalFormats);
|
||
}
|
||
pLocalFormats = pTemp;
|
||
}
|
||
// pTemp is where the stuff is cached
|
||
pTemp = pLocalFormats+uNumLocalFormats;
|
||
memcpy(pTemp, pFmtBuf, sizeof(AUDCAP_DETAILS));
|
||
|
||
pTemp->uLocalDetailsSize = 0; // clear this now
|
||
//if(uSize && lpvMappingData)
|
||
//{
|
||
pTemp->lpLocalFormatDetails = MEMALLOC(uSize);
|
||
if(pTemp->lpLocalFormatDetails)
|
||
{
|
||
memcpy(pTemp->lpLocalFormatDetails, lpvMappingData, uSize);
|
||
pTemp->uLocalDetailsSize = uSize;
|
||
}
|
||
#ifdef DEBUG
|
||
else
|
||
{
|
||
ERRORMESSAGE(("%s:allocation failed!\r\n",_fx_));
|
||
}
|
||
#endif
|
||
//}
|
||
//else
|
||
//{
|
||
//}
|
||
|
||
// in all cases, fixup channel parameters.
|
||
|
||
pTemp->dwDefaultSamples = uSamples =pTemp->dwDefaultSamples;
|
||
|
||
wFrames = pTemp->nonstd_params.wFramesPerPktMax;
|
||
if(!pTemp->nonstd_params.wFramesPerPktMax)
|
||
{
|
||
pTemp->nonstd_params.wFramesPerPktMax=
|
||
wFrames = LOWORD(MaxFramesPerPacket((LPWAVEFORMATEX)lpvMappingData));
|
||
}
|
||
// if the preferred frames/packet is 0 or greater than the max, set it to min
|
||
if((pTemp->nonstd_params.wFramesPerPkt ==0) ||
|
||
(pTemp->nonstd_params.wFramesPerPkt > wFrames))
|
||
{
|
||
pTemp->nonstd_params.wFramesPerPkt =
|
||
LOWORD(MinFramesPerPacket((LPWAVEFORMATEX)lpvMappingData));
|
||
}
|
||
// if the min is more than preferred, fix it
|
||
if(pTemp->nonstd_params.wFramesPerPktMin > pTemp->nonstd_params.wFramesPerPkt)
|
||
{
|
||
pTemp->nonstd_params.wFramesPerPktMin =
|
||
LOWORD(MinFramesPerPacket((LPWAVEFORMATEX)lpvMappingData));
|
||
}
|
||
pTemp->nonstd_params.wDataRate =0; // default
|
||
pTemp->nonstd_params.wFrameSize = (pTemp->nonstd_params.wFramesPerPkt)
|
||
?uSamples / pTemp->nonstd_params.wFramesPerPkt: 0;
|
||
if(pTemp->nonstd_params.wFrameSizeMax < pTemp->nonstd_params.wFrameSize)
|
||
pTemp->nonstd_params.wFrameSizeMax = pTemp->nonstd_params.wFrameSize;
|
||
|
||
pTemp->nonstd_params.UsePostFilter = 0;
|
||
pTemp->nonstd_params.UseSilenceDet = 0;
|
||
|
||
|
||
// fixup the H245 parameters. Use the REBASED index of the cap entry as the cap ID
|
||
pTemp->H245TermCap.CapId = (USHORT)IndexToId(uNumLocalFormats);
|
||
|
||
if(pTemp->H245TermCap.ClientType ==0
|
||
|| pTemp->H245TermCap.ClientType ==H245_CLIENT_AUD_NONSTD)
|
||
{
|
||
LPWAVEFORMATEX lpwfx;
|
||
lpwfx = (LPWAVEFORMATEX)pTemp->lpLocalFormatDetails;
|
||
if(lpwfx)
|
||
{
|
||
pTemp->H245TermCap.ClientType = H245_CLIENT_AUD_NONSTD;
|
||
|
||
// all nonstandard identifier fields are unsigned short
|
||
// two possibilities for choice are "h221NonStandard_chosen" and "object_chosen"
|
||
pTemp->H245TermCap.H245Aud_NONSTD.nonStandardIdentifier.choice = h221NonStandard_chosen;
|
||
|
||
pTemp->H245TermCap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35CountryCode = USA_H221_COUNTRY_CODE;
|
||
pTemp->H245TermCap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35Extension = USA_H221_COUNTRY_EXTENSION;
|
||
pTemp->H245TermCap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.manufacturerCode = MICROSOFT_H_221_MFG_CODE;
|
||
|
||
// Set the nonstandard data fields to null for now. The nonstandard cap data will be
|
||
// created when capabilities are serialized.
|
||
// set size of buffer
|
||
pTemp->H245TermCap.H245Aud_NONSTD.data.length = 0;
|
||
pTemp->H245TermCap.H245Aud_NONSTD.data.value = NULL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// the following should already have been set in *pFmtBuf by the calling function
|
||
// and it should have already been copied to *pTemp
|
||
|
||
//pTemp->ClientType = (H245_CLIENT_T)pDecodeDetails->H245Cap.ClientType;
|
||
//pTemp->DataType = H245_DATA_AUDIO;
|
||
//pTemp->Dir = H245_CAPDIR_LCLTX; // should this be H245_CAPDIR_LCLRX for receive caps?
|
||
|
||
// issue:special case G723 params ???
|
||
if(pTemp->H245TermCap.ClientType == H245_CLIENT_AUD_G723)
|
||
{
|
||
pTemp->H245TermCap.H245Aud_G723.maxAl_sduAudioFrames = 4;
|
||
// mikev 9/10/96 - we may NOT want to advertise silence suppression capability of
|
||
// the codec because our silence detection scheme works out-of-band for any codec
|
||
// 9/29/96 - this gets overwritten in SerializeH323DecodeFormats() anyway
|
||
pTemp->H245TermCap.H245Aud_G723.silenceSuppression = 0;
|
||
}
|
||
|
||
// check for pre-existing capability with the same standard ID.
|
||
pTemp->dwPublicRefIndex = 0; // forget old association, assume that there
|
||
// is no pre-existing capability with the same
|
||
//standard ID.
|
||
UINT i;
|
||
AUDCAP_DETAILS *pFmtExisting = pLocalFormats;
|
||
BOOL bRefFound = FALSE; // this var needed only to support backward
|
||
// compatibility with Netmeeting 2.0 Beta 1
|
||
if(uNumLocalFormats && pLocalFormats)
|
||
{
|
||
for(i=0; i<uNumLocalFormats; i++)
|
||
{
|
||
pFmtExisting = pLocalFormats + i;
|
||
// see if it is the same defined codepoint
|
||
if(pFmtExisting->H245TermCap.ClientType == pTemp->H245TermCap.ClientType)
|
||
{
|
||
// mark this capability entry as being publically advertised
|
||
// by the existing entry. If the existing entry also refs
|
||
// another, follow the reference
|
||
pTemp->dwPublicRefIndex = (pFmtExisting->dwPublicRefIndex)?
|
||
pFmtExisting->dwPublicRefIndex : i;
|
||
bRefFound = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
uNumLocalFormats++;
|
||
|
||
// return the capability ID.
|
||
//return (uNumLocalFormats-1);
|
||
return pTemp->H245TermCap.CapId;
|
||
|
||
ERROR_EXIT:
|
||
return INVALID_AUDIO_FORMAT;
|
||
|
||
}
|
||
|
||
UINT CMsiaCapability::GetNumCaps(BOOL bRXCaps)
|
||
{
|
||
UINT u, uOut=0;
|
||
|
||
AUDCAP_DETAILS *pDecodeDetails = pLocalFormats;
|
||
if(bRXCaps)
|
||
{
|
||
for(u=0; u <uNumLocalFormats; u++)
|
||
{
|
||
if(pDecodeDetails->bRecvEnabled)
|
||
uOut++;
|
||
|
||
pDecodeDetails++;
|
||
}
|
||
return uOut;
|
||
}
|
||
else
|
||
return uNumLocalFormats;
|
||
}
|
||
|
||
VOID CMsiaCapability::FlushRemoteCaps()
|
||
{
|
||
if(pRemoteDecodeFormats)
|
||
{
|
||
MEMFREE(pRemoteDecodeFormats);
|
||
pRemoteDecodeFormats = NULL;
|
||
uNumRemoteDecodeFormats = 0;
|
||
uRemoteDecodeFormatCapacity = 0;
|
||
}
|
||
}
|
||
HRESULT CMsiaCapability::GetNumFormats(UINT *puNumFmtOut)
|
||
{
|
||
*puNumFmtOut = uNumLocalFormats;
|
||
return hrSuccess;
|
||
}
|
||
|
||
|
||
/***************************************************************************
|
||
|
||
Name : CMsiaCapability::FormatEnumHandler
|
||
|
||
Purpose : Enumerate ACM formats coming from ACM, and see if they
|
||
are ones that we use.
|
||
|
||
Parameters: Standard ACM EnumFormatCallback parameters
|
||
|
||
Returns : BOOL
|
||
|
||
Comment :
|
||
|
||
***************************************************************************/
|
||
BOOL CMsiaCapability::FormatEnumHandler(HACMDRIVERID hadid,
|
||
LPACMFORMATDETAILS pafd, DWORD_PTR dwInstance, DWORD fdwSupport)
|
||
{
|
||
PACM_APP_PARAM pAppParam = (PACM_APP_PARAM) dwInstance;
|
||
LPACMFORMATTAGDETAILS paftd = pAppParam->paftd;
|
||
AUDCAP_DETAILS audcap_entry;
|
||
|
||
// look at the passed in dwInstance. this will tell us which format handler
|
||
// to call
|
||
if ((pAppParam->dwFlags && ACMAPP_FORMATENUMHANDLER_MASK) == ACMAPP_FORMATENUMHANDLER_ADD)
|
||
{
|
||
// this one was called for add format purposes
|
||
return AddFormatEnumHandler(hadid, pafd, dwInstance, fdwSupport);
|
||
}
|
||
|
||
// evaluate the details
|
||
if(pafd->pwfx->nChannels ==1)
|
||
{
|
||
if(IsFormatSpecified(pafd->pwfx, pafd, paftd, &audcap_entry))
|
||
{
|
||
DEBUGMSG(ZONE_ACM,("FormatEnumHandler: tag 0x%04X, nChannels %d\r\n",
|
||
pafd->pwfx->wFormatTag, pafd->pwfx->nChannels));
|
||
DEBUGMSG(ZONE_ACM,("FormatEnumHandler: nSamplesPerSec 0x%08lX, nAvgBytesPerSec 0x%08lX,\r\n",
|
||
pafd->pwfx->nSamplesPerSec, pafd->pwfx->nAvgBytesPerSec));
|
||
DEBUGMSG(ZONE_ACM,("FormatEnumHandler: nBlockAlign 0x%04X, wBitsPerSample 0x%04X, cbSize 0x%04X\r\n",
|
||
pafd->pwfx->nBlockAlign, pafd->pwfx->wBitsPerSample, pafd->pwfx->cbSize));
|
||
DEBUGMSG(ZONE_ACM,("FormatEnumHandler: szFormat %s,\r\n",
|
||
pafd->szFormat));
|
||
|
||
// done inside IsFormatSpecified and/or whatever it calls
|
||
// CalculateFormatProperties(&audcap_details, pafd->pwfx);
|
||
AddFormat(&audcap_entry, (LPVOID)pafd->pwfx,
|
||
(pafd->pwfx) ? (sizeof(WAVEFORMATEX)+pafd->pwfx->cbSize):0);
|
||
|
||
}
|
||
//#define BUILD_TEST_ENTRIES
|
||
#ifdef BUILD_TEST_ENTRIES
|
||
else
|
||
{
|
||
AUDCAP_INFO sAudCapInfo;
|
||
|
||
if(paftd)
|
||
{
|
||
if((lstrcmp(paftd->szFormatTag, "G.723" ) ==0)
|
||
/* || (lstrcmp(paftd->szFormatTag, "MSN Audio" ) ==0) */
|
||
|| (lstrcmp(paftd->szFormatTag, "GSM 6.10" ) ==0))
|
||
{
|
||
lstrcpyn(audcap_entry.szFormat, paftd->szFormatTag,
|
||
sizeof(audcap_entry.szFormat));
|
||
int iLen = lstrlen(audcap_entry.szFormat);
|
||
if(iLen < (sizeof(audcap_entry.szFormat) + 8*sizeof(TCHAR)))
|
||
{
|
||
// ok to concatenate
|
||
lstrcat(audcap_entry.szFormat,", ");
|
||
// must check for truncation. so do the final concatenation via lstrcpyn
|
||
// lstrcat(audcap_entry.szFormat, pafd->szFormat);
|
||
iLen = lstrlen(audcap_entry.szFormat);
|
||
lstrcpyn(&audcap_entry.szFormat[iLen], pafd->szFormat,
|
||
sizeof(audcap_entry.szFormat) - iLen - sizeof(TCHAR));
|
||
}
|
||
lstrcpyn(sAudCapInfo.szFormat, audcap_entry.szFormat,
|
||
sizeof(sAudCapInfo.szFormat);
|
||
AddACMFormat (pafd->pwfx, &sAudCapInfo);
|
||
}
|
||
}
|
||
}
|
||
#endif // BUILD_TEST_ENTRIES
|
||
}
|
||
|
||
return TRUE;
|
||
|
||
}
|
||
|
||
|
||
/***************************************************************************
|
||
|
||
Name : CMsiaCapability::BuildFormatName
|
||
|
||
Purpose : Builds a format name for a format, from the format name and
|
||
the tag name
|
||
|
||
Parameters: pAudcapDetails [out] - pointer to an AUDCAP_DETAILS structure, where the
|
||
created value name will be stored
|
||
pszFormatTagName [in] - pointer to the name of the format tag
|
||
pszFormatName [in] - pointer to the name of the format
|
||
|
||
Returns : BOOL
|
||
|
||
Comment :
|
||
|
||
***************************************************************************/
|
||
BOOL CMsiaCapability::BuildFormatName( AUDCAP_DETAILS *pAudcapDetails,
|
||
char *pszFormatTagName,
|
||
char *pszFormatName)
|
||
{
|
||
BOOL bRet = TRUE;
|
||
int iLen=0;
|
||
|
||
if (!pAudcapDetails ||
|
||
!pszFormatTagName ||
|
||
!pszFormatName)
|
||
{
|
||
bRet = FALSE;
|
||
goto out;
|
||
}
|
||
|
||
// concatenate ACM strings to form the first part of the registry key - the
|
||
// format is szFormatTag (actually pAudcapDetails->szFormat)
|
||
// (the string which describes the format tag followed by szFormatDetails
|
||
// (the string which describes parameters, e.g. sample rate)
|
||
|
||
lstrcpyn(pAudcapDetails->szFormat, pszFormatTagName, sizeof(pAudcapDetails->szFormat));
|
||
iLen = lstrlen(pAudcapDetails->szFormat);
|
||
// if the format tag description string takes up all the space, don't
|
||
// bother with the format details (need space for ", " also).
|
||
// we're going to say that if we don't have room for 4 characters
|
||
// of the format details string + " ,", then it's not worth it if the
|
||
// point is generating a unique string -if it is not unique by now, it
|
||
// will be because some ACM driver writer was misinformed
|
||
if(iLen < (sizeof(pAudcapDetails->szFormat) + 8*sizeof(TCHAR)))
|
||
{
|
||
// ok to concatenate
|
||
lstrcat(pAudcapDetails->szFormat,", ");
|
||
// must check for truncation. so do the final concatenation via lstrcpyn
|
||
// lstrcat(pFormatPrefsBuf->szFormat, pafd->szFormat);
|
||
iLen = lstrlen(pAudcapDetails->szFormat);
|
||
lstrcpyn(pAudcapDetails->szFormat+iLen, pszFormatName,
|
||
sizeof(pAudcapDetails->szFormat) - iLen - sizeof(TCHAR));
|
||
}
|
||
|
||
out:
|
||
return bRet;
|
||
}
|
||
|
||
// Free a a structure of registry formats info (PRRF_INFO), including memory pointed
|
||
// from this structure
|
||
void FreeRegistryFormats (PRRF_INFO pRegFmts)
|
||
{
|
||
UINT u;
|
||
|
||
if (pRegFmts) {
|
||
for (u=0;u<pRegFmts->nFormats;u++) {
|
||
MemFree ((void *) pRegFmts->pNames[u]);
|
||
MemFree ((void *) pRegFmts->pData[u]);
|
||
}
|
||
MemFree ((void *) pRegFmts->pNames);
|
||
MemFree ((void *) pRegFmts->pData);
|
||
MemFree ((void *) pRegFmts);
|
||
|
||
}
|
||
}
|
||
|
||
ULONG ReadRegistryFormats (LPCSTR lpszKeyName,CHAR ***pppName,BYTE ***pppData,PUINT pnFormats,DWORD dwDebugSize)
|
||
{
|
||
|
||
HKEY hKeyParent;
|
||
DWORD nSubKey,nMaxSubLen,nValues=0,nValNamelen,nValDatalen,nValTemp,nDataTemp,i;
|
||
ULONG hRes;
|
||
|
||
//Not neccessary but makes life easier
|
||
CHAR **pNames=NULL;
|
||
BYTE **pData=NULL;
|
||
|
||
*pnFormats=0;
|
||
|
||
|
||
//Get the top level node.
|
||
hRes=RegOpenKeyEx (HKEY_LOCAL_MACHINE,lpszKeyName,0,KEY_READ,&hKeyParent);
|
||
|
||
if (hRes != ERROR_SUCCESS)
|
||
{
|
||
return hRes;
|
||
}
|
||
|
||
//Get some info about this key
|
||
hRes=RegQueryInfoKey (hKeyParent,NULL,NULL,NULL,&nSubKey,&nMaxSubLen,NULL,&nValues,&nValNamelen,&nValDatalen,NULL,NULL);
|
||
|
||
if (hRes != ERROR_SUCCESS)
|
||
{
|
||
goto Error_Out;
|
||
}
|
||
|
||
|
||
if (nValDatalen != dwDebugSize) {
|
||
DEBUGMSG (ZONE_ACM,("Largest Data Value not expected size!\r\n"));
|
||
hRes=ERROR_INVALID_DATA;
|
||
goto Error_Out;
|
||
}
|
||
|
||
//Allocate some memory for the various pointers.
|
||
if (!(pNames=(char **) MemAlloc (sizeof(char *)*nValues))) {
|
||
hRes=ERROR_OUTOFMEMORY;
|
||
goto Error_Out;
|
||
}
|
||
ZeroMemory (pNames,sizeof (char *)*nValues);
|
||
|
||
if (!(pData = (BYTE **) MemAlloc (sizeof(BYTE *)*nValues))) {
|
||
hRes=ERROR_OUTOFMEMORY;
|
||
goto Error_Out;
|
||
}
|
||
ZeroMemory (pData,sizeof (BYTE *)*nValues);
|
||
|
||
|
||
//Walk the value list.
|
||
for (i=0;i<nValues;i++)
|
||
{
|
||
//Yes, we're wasting memory here, oh well it's not a lot.
|
||
//probably 40 bytes. We free it later
|
||
if (!(pNames[i] = (char *)MemAlloc (nValNamelen))) {
|
||
hRes=ERROR_OUTOFMEMORY;
|
||
goto Error_Out;
|
||
}
|
||
|
||
if (!(pData[i] = (BYTE *)MemAlloc (nValDatalen))) {
|
||
hRes=ERROR_OUTOFMEMORY;
|
||
goto Error_Out;
|
||
}
|
||
|
||
//This needs to be able to be smashed, but is an in/out param.
|
||
nValTemp=nValNamelen;
|
||
nDataTemp=nValDatalen;
|
||
|
||
hRes=RegEnumValue (hKeyParent,i,(pNames[i]),&nValTemp,NULL,NULL,(pData[i]),&nDataTemp);
|
||
|
||
#ifdef DEBUG
|
||
if (nDataTemp != dwDebugSize) {
|
||
DEBUGMSG (ZONE_ACM, ("ReadRegistryFormats: Data block not expected size!\r\n"));
|
||
//Return?
|
||
}
|
||
#endif
|
||
|
||
}
|
||
|
||
//Fill in the output.
|
||
*pnFormats=nValues;
|
||
*pppName=pNames;
|
||
*pppData=pData;
|
||
|
||
RegCloseKey (hKeyParent);
|
||
|
||
return (ERROR_SUCCESS);
|
||
|
||
Error_Out:
|
||
RegCloseKey (hKeyParent);
|
||
//Free any allocations
|
||
if(pNames)
|
||
{
|
||
for (i=0;i<nValues;i++)
|
||
{
|
||
if (pNames[i])
|
||
{
|
||
MemFree (pNames[i]);
|
||
}
|
||
}
|
||
MemFree (pNames);
|
||
}
|
||
|
||
if (pData)
|
||
{
|
||
for (i=0;i<nValues;i++)
|
||
{
|
||
if (pData[i])
|
||
{
|
||
MemFree (pData[i]);
|
||
}
|
||
}
|
||
|
||
MemFree (pData);
|
||
}
|
||
return hRes;
|
||
}
|
||
|
||
|
||
BOOL CMsiaCapability::IsFormatSpecified(LPWAVEFORMATEX lpwfx, LPACMFORMATDETAILS pafd,
|
||
LPACMFORMATTAGDETAILS paftd, AUDCAP_DETAILS *pAudcapDetails)
|
||
{
|
||
AUDCAP_DETAILS cap_entry;
|
||
BOOL bRet = FALSE;
|
||
LPTSTR lpszValueName = NULL;
|
||
DWORD dwRes;
|
||
UINT i;
|
||
|
||
|
||
if(!lpwfx || !pAudcapDetails)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
if (!bUseDefault) {
|
||
for (i=0;i<pRegFmts->nFormats;i++) {
|
||
// do a quick sanity check on the contents
|
||
if ( (lpwfx->wFormatTag == ((AUDCAP_DETAILS *)pRegFmts->pData[i])->wFormatTag) &&
|
||
(lpwfx->nSamplesPerSec == ((DWORD)((AUDCAP_DETAILS *)pRegFmts->pData[i])->audio_params.uSamplesPerSec)) &&
|
||
((lpwfx->nAvgBytesPerSec * 8) == (((AUDCAP_DETAILS *)pRegFmts->pData[i])->uMaxBitrate))) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (i == pRegFmts->nFormats) {
|
||
//Check the case that some (but not all) of the default formats are missing.
|
||
for (i=0;i<uDefTableEntries;i++) {
|
||
if ((paftd->dwFormatTag == default_id_table[i].wFormatTag)
|
||
&& (lpwfx->nSamplesPerSec == (DWORD)default_id_table[i].audio_params.uSamplesPerSec)
|
||
&& (lpwfx->wBitsPerSample == LOWORD(default_id_table[i].audio_params.uBitsPerSample))) {
|
||
|
||
//Arrgh!! Jump down, and rebuild this format
|
||
goto RebuildFormat;
|
||
}
|
||
}
|
||
if (i==uDefTableEntries) {
|
||
//We don't care about this format, it's not in the cache, or default list
|
||
return FALSE;
|
||
}
|
||
|
||
}
|
||
|
||
memcpy(pAudcapDetails, pRegFmts->pData[i], sizeof(AUDCAP_DETAILS));
|
||
bRet=TRUE;
|
||
} else {
|
||
|
||
RebuildFormat:
|
||
RtlZeroMemory((PVOID) pAudcapDetails, sizeof(AUDCAP_DETAILS));
|
||
|
||
// fixup the bits per sample and sample rate fields of audio_params so that the key name can be built
|
||
pAudcapDetails->audio_params.uSamplesPerSec = lpwfx->nSamplesPerSec;
|
||
pAudcapDetails->audio_params.uBitsPerSample = MAKELONG(lpwfx->wBitsPerSample,0);
|
||
pAudcapDetails->uMaxBitrate = lpwfx->nAvgBytesPerSec * 8;
|
||
|
||
if (!paftd ||
|
||
(!BuildFormatName( pAudcapDetails,
|
||
paftd->szFormatTag,
|
||
pafd->szFormat)))
|
||
{
|
||
ERRORMESSAGE(("IsFormatSpecified: Couldn't build format name\r\n"));
|
||
return(FALSE);
|
||
}
|
||
|
||
for(i=0;i< uDefTableEntries; i++)
|
||
{
|
||
if((lpwfx->wFormatTag == default_id_table[i].wFormatTag)
|
||
&& (lpwfx->nSamplesPerSec == (DWORD)default_id_table[i].audio_params.uSamplesPerSec)
|
||
&& (lpwfx->wBitsPerSample == LOWORD(default_id_table[i].audio_params.uBitsPerSample)))
|
||
//&& strnicmp(lpwfx->szFormat, default_id_table[i].szFormat)
|
||
{
|
||
// found matching default entry - copy stuff from table
|
||
// (but don't overwrite the string)
|
||
memcpy(pAudcapDetails, &default_id_table[i],
|
||
sizeof(AUDCAP_DETAILS) - sizeof(pAudcapDetails->szFormat));
|
||
|
||
// LOOKLOOK - test against CPU limitations.
|
||
// this supports a hack to disable CPU intensive codecs if not running
|
||
//on a pentium
|
||
|
||
if(default_id_table[i].wCPUUtilizationEncode > wMaxCPU)
|
||
{
|
||
pAudcapDetails->bSendEnabled = FALSE;
|
||
}
|
||
if(default_id_table[i].wCPUUtilizationDecode > wMaxCPU)
|
||
{
|
||
pAudcapDetails->bRecvEnabled = FALSE;
|
||
}
|
||
|
||
// add this to the registry
|
||
CalculateFormatProperties(pAudcapDetails, lpwfx);
|
||
bRet = UpdateFormatInRegistry(pAudcapDetails);
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
return bRet;
|
||
}
|
||
|
||
|
||
/***************************************************************************
|
||
|
||
Name : CMsiaCapability::CopyAudcapInfo
|
||
|
||
Purpose : Copies basic audio info from an AUDCAP_INFO structure to an
|
||
AUDCAP_DETAILS structure, or vice versa. AUDCAP_INFO is external
|
||
representation. AUDCAP_DETAILS is internal one.
|
||
|
||
Parameters: pDetails - pointer to an AUDCAP_DETAILS structure
|
||
pInfo - pointer to an AUDCAP_INFO structure
|
||
bDirection - 0 = ->, 1 = <-
|
||
|
||
Returns : HRESULT
|
||
|
||
Comment :
|
||
|
||
***************************************************************************/
|
||
HRESULT CMsiaCapability::CopyAudcapInfo (PAUDCAP_DETAILS pDetails,
|
||
PAUDCAP_INFO pInfo, BOOL bDirection)
|
||
{
|
||
WORD wSortIndex;
|
||
UINT uIndex;
|
||
AUDIO_FORMAT_ID Id;
|
||
HRESULT hr=NOERROR;
|
||
|
||
if(!pInfo || !pDetails)
|
||
{
|
||
hr = CAPS_E_INVALID_PARAM;
|
||
goto out;
|
||
}
|
||
|
||
if (bDirection)
|
||
{
|
||
// AUDCAP_INFO -> AUDCAP_DETAILS
|
||
// the caller cannot modify szFormat, Id, wSortIndex and uMaxBitrate, all calculated fields
|
||
|
||
pDetails->wFormatTag = pInfo->wFormatTag;
|
||
pDetails->uAvgBitrate = pInfo->uAvgBitrate;
|
||
pDetails->wCPUUtilizationEncode = pInfo->wCPUUtilizationEncode;
|
||
pDetails->wCPUUtilizationDecode = pInfo->wCPUUtilizationDecode;
|
||
pDetails->bSendEnabled = pInfo->bSendEnabled;
|
||
pDetails->bRecvEnabled = pInfo->bRecvEnabled;
|
||
}
|
||
else
|
||
{
|
||
// find the sort index.
|
||
uIndex = (UINT)(pDetails - pLocalFormats);
|
||
Id = IndexToId(uIndex);
|
||
for(wSortIndex=0; wSortIndex<uNumLocalFormats && wSortIndex < MAX_CAPS_PRESORT; wSortIndex++)
|
||
{
|
||
if (uIndex == IDsByRank[wSortIndex])
|
||
break; // found it
|
||
}
|
||
// note: recall that only MAX_CAPS_PRESORT are sorted and the rest are in random order.
|
||
// the rest all have a value of MAX_CAPS_PRESORT for the sort index
|
||
|
||
memcpy(pInfo->szFormat, pDetails->szFormat, sizeof(pInfo->szFormat));
|
||
|
||
// AUDCAP_DETAILS -> AUDCAP_INFO
|
||
pInfo->wFormatTag = pDetails->wFormatTag;
|
||
pInfo->Id = Id;
|
||
pInfo->uMaxBitrate = pDetails->uMaxBitrate;
|
||
pInfo->uAvgBitrate = pDetails->uAvgBitrate;
|
||
pInfo->wCPUUtilizationEncode = pDetails->wCPUUtilizationEncode;
|
||
pInfo->wCPUUtilizationDecode = pDetails->wCPUUtilizationDecode;
|
||
pInfo->bSendEnabled = pDetails->bSendEnabled;
|
||
pInfo->bRecvEnabled = pDetails->bRecvEnabled;
|
||
pInfo->wSortIndex = wSortIndex;
|
||
}
|
||
|
||
out:
|
||
return hr;
|
||
}
|
||
|
||
|
||
HRESULT CMsiaCapability::EnumCommonFormats(PBASIC_AUDCAP_INFO pFmtBuf, UINT uBufsize,
|
||
UINT *uNumFmtOut, BOOL bTXCaps)
|
||
{
|
||
UINT u, uNumOut =0;
|
||
HRESULT hr = hrSuccess;
|
||
MEDIA_FORMAT_ID FormatIDRemote;
|
||
HRESULT hrIsCommon;
|
||
|
||
AUDCAP_DETAILS *pDetails = pLocalFormats;
|
||
// validate input
|
||
if(!pFmtBuf || !uNumFmtOut || (uBufsize < (sizeof(BASIC_AUDCAP_INFO)*uNumLocalFormats)))
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
if(!uNumLocalFormats || !pDetails)
|
||
{
|
||
return CAPS_E_NOCAPS;
|
||
}
|
||
// temporary - enumerating requestable receive formats is not yet supported
|
||
if(!bTXCaps)
|
||
return CAPS_E_NOT_SUPPORTED;
|
||
|
||
for(u=0; (u <uNumLocalFormats) && (u <MAX_CAPS_PRESORT); u++)
|
||
{
|
||
pDetails = pLocalFormats + IDsByRank[u];
|
||
// if there is a session, then return formats that are common to local and remote.
|
||
if(uNumRemoteDecodeFormats)
|
||
{
|
||
hrIsCommon = ResolveToLocalFormat(IndexToId(IDsByRank[u]), &FormatIDRemote);
|
||
if(HR_SUCCEEDED(hrIsCommon))
|
||
{
|
||
hr = CopyAudcapInfo (pDetails, pFmtBuf, 0);
|
||
if(!HR_SUCCEEDED(hr))
|
||
goto EXIT;
|
||
uNumOut++;
|
||
pFmtBuf++;
|
||
}
|
||
}
|
||
else // no remote capabilities exist because there is no current session
|
||
{
|
||
hr = CAPS_E_NOCAPS;
|
||
}
|
||
}
|
||
|
||
*uNumFmtOut = uNumOut;
|
||
EXIT:
|
||
return hr;
|
||
}
|
||
|
||
HRESULT CMsiaCapability::EnumFormats(PBASIC_AUDCAP_INFO pFmtBuf, UINT uBufsize,
|
||
UINT *uNumFmtOut)
|
||
{
|
||
UINT u;
|
||
HRESULT hr = hrSuccess;
|
||
AUDCAP_DETAILS *pDetails = pLocalFormats;
|
||
// validate input
|
||
if(!pFmtBuf || !uNumFmtOut || (uBufsize < (sizeof(BASIC_AUDCAP_INFO)*uNumLocalFormats)))
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
if(!uNumLocalFormats || !pDetails)
|
||
{
|
||
return CAPS_E_NOCAPS;
|
||
}
|
||
|
||
for(u=0; (u <uNumLocalFormats) && (u <MAX_CAPS_PRESORT); u++)
|
||
{
|
||
pDetails = pLocalFormats + IDsByRank[u];
|
||
hr = CopyAudcapInfo (pDetails, pFmtBuf, 0);
|
||
if(!HR_SUCCEEDED(hr))
|
||
goto EXIT;
|
||
pFmtBuf++;
|
||
}
|
||
|
||
*uNumFmtOut = min(uNumLocalFormats, MAX_CAPS_PRESORT);
|
||
EXIT:
|
||
return hr;
|
||
}
|
||
|
||
HRESULT CMsiaCapability::GetBasicAudcapInfo (AUDIO_FORMAT_ID Id, PBASIC_AUDCAP_INFO pFormatPrefsBuf)
|
||
{
|
||
AUDCAP_DETAILS *pFmt;
|
||
UINT uIndex = IDToIndex(Id);
|
||
if(!pFormatPrefsBuf || (uNumLocalFormats <= uIndex))
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
pFmt = pLocalFormats + uIndex;
|
||
|
||
return (CopyAudcapInfo(pFmt,pFormatPrefsBuf, 0));
|
||
}
|
||
|
||
HRESULT CMsiaCapability::ApplyAppFormatPrefs (PBASIC_AUDCAP_INFO pFormatPrefsBuf,
|
||
UINT uNumFormatPrefs)
|
||
{
|
||
FX_ENTRY ("CMsiaCapability::ApplyAppFormatPrefs");
|
||
UINT u, v;
|
||
PBASIC_AUDCAP_INFO pTemp;
|
||
AUDCAP_DETAILS *pFmt;
|
||
|
||
if(!pFormatPrefsBuf || (uNumLocalFormats != uNumFormatPrefs))
|
||
{
|
||
ERRORMESSAGE(("%s invalid param: pFbuf:0x%08lx, uNumIN:%d, uNum:%d\r\n",
|
||
_fx_, pFormatPrefsBuf, uNumFormatPrefs, uNumLocalFormats));
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
|
||
// validate
|
||
for(u=0; u <uNumLocalFormats; u++)
|
||
{
|
||
pTemp = pFormatPrefsBuf+u;
|
||
// make sure that the format ID is real
|
||
if(IDToIndex(pTemp->Id) >= uNumLocalFormats)
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
// look for bad sort indices, duplicate sort indices and duplicate format IDs
|
||
if(pTemp->wSortIndex >= uNumLocalFormats)
|
||
return CAPS_E_INVALID_PARAM;
|
||
|
||
for(v=u+1; v <uNumLocalFormats; v++)
|
||
{
|
||
if((pTemp->wSortIndex == pFormatPrefsBuf[v].wSortIndex)
|
||
|| (pTemp->Id == pFormatPrefsBuf[v].Id))
|
||
{
|
||
ERRORMESSAGE(("%s invalid param: wSI1:0x%04x, wSI2:0x%04x, ID1:%d, ID2:%d\r\n",
|
||
_fx_, pTemp->wSortIndex, pFormatPrefsBuf[v].wSortIndex, pTemp->Id,
|
||
pFormatPrefsBuf[v].Id));
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
}
|
||
}
|
||
// all seems well
|
||
for(u=0; u <uNumLocalFormats; u++)
|
||
{
|
||
pTemp = pFormatPrefsBuf+u; // next entry of the input
|
||
pFmt = pLocalFormats + IDToIndex(pTemp->Id); // identifies this local format
|
||
|
||
// apply the new sort order
|
||
pFmt->wApplicationPrefOrder = pTemp->wSortIndex;
|
||
// update the updatable parameters (CPU utilization, bitrate)
|
||
pFmt->bSendEnabled = pTemp->bSendEnabled;
|
||
pFmt->bRecvEnabled = pTemp->bRecvEnabled;
|
||
|
||
// only the tuning wizard or other profiling app can write these (via other apis only)
|
||
pFmt->wCPUUtilizationEncode = pTemp->wCPUUtilizationEncode;
|
||
pFmt->wCPUUtilizationDecode = pTemp->wCPUUtilizationDecode;
|
||
// pFmt->wApplicationPrefOrder = pTemp->wApplicationPrefOrder;
|
||
// pFmt->uAvgBitrate = pTemp->
|
||
// pFmt->wCompressionRatio = pTemp->
|
||
|
||
// update the registry
|
||
UpdateFormatInRegistry(pFmt);
|
||
|
||
// now update the sort order contained in IDsByRank
|
||
// note: recall that only MAX_CAPS_PRESORT are sorted and the rest are in random order.
|
||
// LOOKLOOK - maybe need a separate sort order array? - the order in IDsByRank
|
||
// is being overriden here
|
||
// the array holds the sorted indices into the array of formats in pLocalFormats
|
||
if(pTemp->wSortIndex < MAX_CAPS_PRESORT)
|
||
{
|
||
// insert the format at the position indicated by the input
|
||
IDsByRank[pTemp->wSortIndex] = (MEDIA_FORMAT_ID)(pFmt - pLocalFormats);
|
||
}
|
||
|
||
}
|
||
|
||
#ifdef DEBUG
|
||
for(u=0; u <uNumLocalFormats; u++) {
|
||
pTemp = pFormatPrefsBuf+u; // next entry of the input
|
||
pFmt = pLocalFormats + IDToIndex(pTemp->Id); // identifies this local format
|
||
DEBUGMSG (ZONE_ACM,("Format %s: Sort Index: %d\r\n",pTemp->szFormat,pTemp->wSortIndex));
|
||
}
|
||
#endif
|
||
|
||
return hrSuccess;
|
||
}
|
||
|
||
// update the registry
|
||
BOOL CMsiaCapability::UpdateFormatInRegistry(AUDCAP_DETAILS *pAudcapDetails)
|
||
{
|
||
|
||
FX_ENTRY(("CMsiaCapability::UpdateFormatInRegistry"));
|
||
LPTSTR lpszKeyName = NULL;
|
||
BOOL bRet;
|
||
UINT i;
|
||
if(!pAudcapDetails)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
//Update the CACHE info!!!
|
||
if (pRegFmts) {
|
||
for (i=0;i<pRegFmts->nFormats;i++) {
|
||
if (!lstrcmp (((AUDCAP_DETAILS *)pRegFmts->pData[i])->szFormat,pAudcapDetails->szFormat) &&
|
||
pAudcapDetails->audio_params.uSamplesPerSec == ((AUDCAP_DETAILS *)pRegFmts->pData[i])->audio_params.uSamplesPerSec &&
|
||
pAudcapDetails->audio_params.uBitsPerSample == ((AUDCAP_DETAILS *)pRegFmts->pData[i])->audio_params.uBitsPerSample &&
|
||
pAudcapDetails->uMaxBitrate == ((AUDCAP_DETAILS *)pRegFmts->pData[i])->uMaxBitrate) {
|
||
|
||
memcpy (pRegFmts->pData[i],pAudcapDetails,sizeof (AUDCAP_DETAILS));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
lpszKeyName = AllocRegistryKeyName( pAudcapDetails->szFormat,
|
||
pAudcapDetails->audio_params.uSamplesPerSec,
|
||
pAudcapDetails->audio_params.uBitsPerSample,
|
||
pAudcapDetails->uMaxBitrate);
|
||
if (!lpszKeyName)
|
||
{
|
||
ERRORMESSAGE(("%s:Alloc failed\r\n",_fx_));
|
||
return(FALSE);
|
||
}
|
||
|
||
DEBUGMSG(ZONE_ACM,("%s:updating %s, wPref:0x%04x, bS:%d, bR:%d\r\n",
|
||
_fx_, lpszKeyName, pAudcapDetails->wApplicationPrefOrder,
|
||
pAudcapDetails->bSendEnabled, pAudcapDetails->bRecvEnabled));
|
||
// add this to the registry
|
||
RegEntry reAudCaps(szRegInternetPhone TEXT("\\") szRegMSIPAndH323Encodings,
|
||
HKEY_LOCAL_MACHINE);
|
||
|
||
bRet = (ERROR_SUCCESS == reAudCaps.SetValue(lpszKeyName,
|
||
pAudcapDetails,
|
||
sizeof(AUDCAP_DETAILS)));
|
||
|
||
FreeRegistryKeyName(lpszKeyName);
|
||
return(bRet);
|
||
}
|
||
|
||
/***************************************************************************
|
||
|
||
Name : CMsiaCapability::AddFormatEnumHandler
|
||
|
||
Purpose : Enumerates the ACM formats for the case in which we want
|
||
to see all formats, and find the one we need. Used for installable
|
||
codecs when we want to find more info on the format being added
|
||
|
||
Parameters: Standard ACM EnumFormatCallback parameters
|
||
|
||
Returns : BOOL (somewhat upside down logic)
|
||
TRUE - not out format. keep calling.
|
||
FALSE - found our format. don't call anymore
|
||
|
||
Comment :
|
||
|
||
***************************************************************************/
|
||
BOOL CMsiaCapability::AddFormatEnumHandler(HACMDRIVERID hadid,
|
||
LPACMFORMATDETAILS pafd, DWORD_PTR dwInstance, DWORD fdwSupport)
|
||
{
|
||
PACM_APP_PARAM pAppParam = (PACM_APP_PARAM) dwInstance;
|
||
LPWAVEFORMATEX lpwfx = pAppParam->lpwfx;
|
||
LPACMFORMATTAGDETAILS paftd = pAppParam->paftd;
|
||
AUDCAP_DETAILS *pAudcapDetails = pAppParam->pAudcapDetails;
|
||
BOOL bRet = TRUE;
|
||
|
||
if (pAppParam->hr == NOERROR)
|
||
{
|
||
// already got what we wanted
|
||
bRet = FALSE;
|
||
goto out;
|
||
}
|
||
|
||
// check to see if this is the format we're looking for
|
||
if ((lpwfx->cbSize != pafd->pwfx->cbSize) ||
|
||
!RtlEqualMemory(lpwfx, pafd->pwfx, sizeof(WAVEFORMATEX)+lpwfx->cbSize))
|
||
{
|
||
// not the one. out of here asap, but tell ACM to keep calling us
|
||
bRet = TRUE;
|
||
goto out;
|
||
}
|
||
|
||
// this is the format tag we're looking for
|
||
if (BuildFormatName(pAudcapDetails,
|
||
paftd->szFormatTag,
|
||
pafd->szFormat))
|
||
{
|
||
pAppParam->hr = NOERROR;
|
||
}
|
||
|
||
// either an error or we found what we want. tell ACM not to call us anymore
|
||
bRet = FALSE;
|
||
|
||
out:
|
||
return bRet;
|
||
}
|
||
|
||
/***************************************************************************
|
||
|
||
Name : NormalizeCPUUtilization
|
||
|
||
Purpose : Normalize CPU utilization numbers for an audio format
|
||
|
||
Parameters: pAudcapDetails [in/out] pointer to an AUDCAP_DETAILS structure
|
||
with the wCPUUtilizationEncode and wCPUUtilizationDecode
|
||
correctly initialized. These fields will be scaled in place
|
||
per the machine CPU.
|
||
|
||
Returns : FALSE for error
|
||
|
||
***************************************************************************/
|
||
BOOL NormalizeCPUUtilization (PAUDCAP_DETAILS pAudcapDetails)
|
||
{
|
||
#define wCPUEncode pAudcapDetails->wCPUUtilizationEncode
|
||
#define wCPUDecode pAudcapDetails->wCPUUtilizationDecode
|
||
#define BASE_PENTIUM 90
|
||
int nNormalizedSpeed, iFamily=0;
|
||
|
||
if (!pAudcapDetails)
|
||
{
|
||
ASSERT(pAudcapDetails);
|
||
return FALSE;
|
||
}
|
||
|
||
#ifdef _M_IX86
|
||
GetNormalizedCPUSpeed (&nNormalizedSpeed,&iFamily);
|
||
#else
|
||
// profile the CPU on, say, an Alpha
|
||
// see ui\conf\audiocpl.cpp
|
||
iFamily=5;
|
||
nNormalizedSpeed=300;
|
||
#endif
|
||
|
||
// base is Pentium 90Mhz.
|
||
if (iFamily < 5)
|
||
{ // 486 or below, inlcuding Cyrix parts
|
||
if (nNormalizedSpeed > 50)
|
||
{ // Cyrix or friends. 1.5 the utilization of a P5-90. Make it so.
|
||
wCPUEncode += max(1, wCPUEncode / 2);
|
||
wCPUDecode += max(1, wCPUDecode / 2);
|
||
}
|
||
else
|
||
{ // 486 is half a P5-90. This is not accurate, but good enough
|
||
wCPUEncode = max(1, wCPUEncode * 2);
|
||
wCPUDecode = max(1, wCPUDecode * 2);
|
||
}
|
||
}
|
||
else
|
||
{ // it's a Pentium or TNGs
|
||
// nNormalizedSpeed ALREADY accounts for P-Pro and later families
|
||
wCPUEncode=max(1,((wCPUEncode*BASE_PENTIUM)/nNormalizedSpeed));
|
||
wCPUDecode=max(1,((wCPUDecode*BASE_PENTIUM)/nNormalizedSpeed));
|
||
}
|
||
|
||
// disable this format if encode utilization is too high
|
||
// we compare to 80%, since there's no QoS CPU utilization number at
|
||
// this point, and if there was, it would usually select 81%
|
||
if (wCPUEncode > 80)
|
||
pAudcapDetails->bSendEnabled = FALSE;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/***************************************************************************
|
||
|
||
Name : CMsiaCapability::AddACMFormat
|
||
|
||
Purpose : Adds an ACM format to the list of formats we support
|
||
|
||
Parameters: lpwfx - pointer to the waveformat structure for the added codec
|
||
pAudCapInfo - additional format info that is not in the waveformat
|
||
structure
|
||
|
||
Returns : HRESULT
|
||
|
||
Comment :
|
||
|
||
***************************************************************************/
|
||
HRESULT CMsiaCapability::AddACMFormat (LPWAVEFORMATEX lpwfx, PBASIC_AUDCAP_INFO pAudcapInfo)
|
||
{
|
||
HRESULT hr = hrSuccess;
|
||
// initialize cap entry with default values
|
||
AUDCAP_DETAILS cap_entry =
|
||
{WAVE_FORMAT_UNKNOWN, NONSTD_TERMCAP, STD_CHAN_PARAMS,
|
||
{RTP_DYNAMIC_MIN, 0, 8000, 16},
|
||
0, TRUE, TRUE,
|
||
960, // default number of samples per packet
|
||
16000, // default to 16kbs bitrate
|
||
0, // unknown average bitrate
|
||
90, 90, // default CPU utilization
|
||
PREF_ORDER_UNASSIGNED, // unassigned sort order
|
||
0,NULL,0,NULL,
|
||
""};
|
||
ACM_APP_PARAM sAppParam = { this, &cap_entry, ACMAPP_FORMATENUMHANDLER_ADD,
|
||
lpwfx, NULL, CAPS_E_SYSTEM_ERROR, NULL};
|
||
|
||
/*
|
||
* Parameter validation
|
||
*/
|
||
|
||
if (!lpwfx || !pAudcapInfo)
|
||
{
|
||
hr = CAPS_E_INVALID_PARAM;
|
||
goto out;
|
||
}
|
||
|
||
// nBlockAlign of 0 is illegal and will crash NAC
|
||
if (lpwfx->nBlockAlign == 0)
|
||
{
|
||
hr = CAPS_E_INVALID_PARAM;
|
||
goto out;
|
||
}
|
||
|
||
// only supporting formats with one audio channel
|
||
if (lpwfx->nChannels != 1)
|
||
{
|
||
hr = CAPS_E_INVALID_PARAM;
|
||
goto out;
|
||
}
|
||
|
||
/*
|
||
* Build the AUDCAP_DETALS structure for this format
|
||
*/
|
||
|
||
// WAVEFORMAT info first
|
||
// fixup the bits per sample and sample rate fields of audio_params so that
|
||
// the key name can be built
|
||
cap_entry.audio_params.uSamplesPerSec = lpwfx->nSamplesPerSec;
|
||
cap_entry.audio_params.uBitsPerSample = MAKELONG(lpwfx->wBitsPerSample,0);
|
||
|
||
// fill in info given in lpwfx, calculate whatever parameters can be calculated
|
||
// use actual bits per sample unless the bps field is zero, in which case
|
||
// assume 16 bits (worst case).
|
||
cap_entry.wFormatTag = lpwfx->wFormatTag;
|
||
|
||
// now add in the caller AUDCAP_INFO information
|
||
CopyAudcapInfo(&cap_entry, pAudcapInfo, 1);
|
||
|
||
// normalize the encode and decode CPU utilization numbers
|
||
NormalizeCPUUtilization(&cap_entry);
|
||
|
||
// get the values we need to get from the WAVEFORMATEX structure
|
||
CalculateFormatProperties(&cap_entry, lpwfx);
|
||
|
||
// set the RTP payload number. We are using a random number from the dynamic range
|
||
// for the installable codecs
|
||
cap_entry.audio_params.RTPPayload = RTP_DYNAMIC_MIN;
|
||
|
||
// get ACM to enumerate all formats, and see if we can find this one
|
||
// this call will make ACM call into AddFormatEnumHandler, which will try to
|
||
// match formats returned by ACM with the added format, and if successful,
|
||
// will create a format name for it into cap_entry.szFormat;
|
||
if(!DriverEnum((DWORD_PTR) &sAppParam))
|
||
{
|
||
hr = CAPS_E_NOMATCH;
|
||
goto out;
|
||
}
|
||
|
||
if (HR_FAILED(sAppParam.hr))
|
||
{
|
||
ERRORMESSAGE(("CMsiaCapability::AddACMFormat: format enum problem\r\n"));
|
||
hr = CAPS_E_NOMATCH;
|
||
goto out;
|
||
}
|
||
|
||
// add this to the registry
|
||
if(!UpdateFormatInRegistry(&cap_entry))
|
||
{
|
||
ERRORMESSAGE(("CMsiaCapability::AddACMFormat: can't update registry\r\n"));
|
||
hr = CAPS_E_SYSTEM_ERROR;
|
||
goto out;
|
||
}
|
||
// free the old format cache...
|
||
FreeRegistryFormats(pRegFmts);
|
||
pRegFmts=NULL;
|
||
|
||
// reinit to update the list of local formats
|
||
if (!ReInit())
|
||
{
|
||
ERRORMESSAGE(("CMsiaCapability::AddACMFormat: Reinit failed\r\n"));
|
||
hr = CAPS_E_SYSTEM_ERROR;
|
||
goto out;
|
||
}
|
||
|
||
out:
|
||
return hr;
|
||
}
|
||
|
||
/***************************************************************************
|
||
|
||
Name : CMsiaCapability::RemoveACMFormat
|
||
|
||
Purpose : Removes an ACM format from the list of formats we support
|
||
|
||
Parameters: lpwfx - pointer to the waveformat structure for the added codec
|
||
|
||
Returns : HRESULT
|
||
|
||
Comment :
|
||
|
||
***************************************************************************/
|
||
HRESULT CMsiaCapability::RemoveACMFormat (LPWAVEFORMATEX lpwfx)
|
||
{
|
||
HRESULT hr = hrSuccess;
|
||
HKEY hKey = NULL;
|
||
LPTSTR lpszValueName = NULL;
|
||
DWORD dwErr;
|
||
AUDCAP_DETAILS cap_entry;
|
||
ACM_APP_PARAM sAppParam = { this, &cap_entry, ACMAPP_FORMATENUMHANDLER_ADD,
|
||
lpwfx, NULL, CAPS_E_SYSTEM_ERROR, NULL};
|
||
|
||
/*
|
||
* Parameter validation
|
||
*/
|
||
|
||
if(!lpwfx)
|
||
{
|
||
ERRORMESSAGE(("CMsiaCapability::RemoveACMFormat: NULL WAVEFORMAT pointer\r\n"));
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
|
||
// nBlockAlign of 0 is illegal and will crash NAC
|
||
if (lpwfx->nBlockAlign == 0)
|
||
{
|
||
hr = CAPS_E_INVALID_PARAM;
|
||
goto out;
|
||
}
|
||
|
||
// only supporting formats with one audio channel
|
||
if (lpwfx->nChannels != 1)
|
||
{
|
||
hr = CAPS_E_INVALID_PARAM;
|
||
goto out;
|
||
}
|
||
|
||
/*
|
||
* Enumerate ACM formats
|
||
*/
|
||
|
||
if(!DriverEnum((DWORD_PTR) &sAppParam))
|
||
{
|
||
ERRORMESSAGE(("CMsiaCapability::RemoveACMFormat: Couldn't find format\r\n"));
|
||
hr = CAPS_E_NOMATCH;
|
||
goto out;
|
||
}
|
||
|
||
if (HR_FAILED(sAppParam.hr))
|
||
{
|
||
ERRORMESSAGE(("CMsiaCapability::RemoveACMFormat: format enum problem\r\n"));
|
||
hr = CAPS_E_SYSTEM_ERROR;
|
||
goto out;
|
||
}
|
||
|
||
lpszValueName = AllocRegistryKeyName(cap_entry.szFormat,
|
||
lpwfx->nSamplesPerSec,
|
||
MAKELONG(lpwfx->wBitsPerSample,0),
|
||
lpwfx->nAvgBytesPerSec * 8);
|
||
if (!lpszValueName)
|
||
{
|
||
ERRORMESSAGE(("CMsiaCapability::RemoveACMFormat: Alloc failed\r\n"));
|
||
hr = CAPS_E_SYSTEM_ERROR;
|
||
goto out;
|
||
}
|
||
|
||
// Get the key handle
|
||
if (dwErr = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
||
szRegInternetPhone TEXT("\\") szRegMSIPAndH323Encodings, 0,
|
||
KEY_ALL_ACCESS, &hKey))
|
||
{
|
||
ERRORMESSAGE(("CMsiaCapability::RemoveACMFormat: can't open key to delete\r\n"));
|
||
hr = CAPS_E_SYSTEM_ERROR;
|
||
goto out;
|
||
}
|
||
|
||
dwErr = RegDeleteValue(hKey, lpszValueName );
|
||
if(dwErr != ERROR_SUCCESS)
|
||
{
|
||
hr = CAPS_E_SYSTEM_ERROR;
|
||
goto out;
|
||
}
|
||
|
||
// free the old format cache...
|
||
FreeRegistryFormats(pRegFmts);
|
||
pRegFmts=NULL;
|
||
|
||
// reinit to update the list of local formats
|
||
if (!ReInit())
|
||
{
|
||
hr = CAPS_E_SYSTEM_ERROR;
|
||
goto out;
|
||
}
|
||
|
||
out:
|
||
if (hKey)
|
||
RegCloseKey(hKey);
|
||
if(lpszValueName)
|
||
MEMFREE(lpszValueName);
|
||
return hr;
|
||
}
|
||
|
||
HRESULT CMsiaCapability::SetCapIDBase (UINT uNewBase)
|
||
{
|
||
uCapIDBase = uNewBase;
|
||
UINT u;
|
||
for (u=0;u<uNumLocalFormats;u++)
|
||
{
|
||
pLocalFormats[u].H245TermCap.CapId = u + uCapIDBase;
|
||
}
|
||
return hrSuccess;
|
||
}
|
||
|
||
BOOL CMsiaCapability::IsHostForCapID(MEDIA_FORMAT_ID CapID)
|
||
{
|
||
if((CapID >= uCapIDBase) && ((CapID - uCapIDBase) < uNumLocalFormats))
|
||
return TRUE;
|
||
else
|
||
return FALSE;
|
||
|
||
}
|
||
|
||
|
||
|
||
|