1316 lines
41 KiB
C++
1316 lines
41 KiB
C++
/*
|
||
* File: h323caps.cpp
|
||
*
|
||
* H.323/H.245 specific implementation of Microsoft A/V capability
|
||
* interface methods. (Contained in CMsiaCapability class)
|
||
*
|
||
* Revision History:
|
||
*
|
||
* 09/10/96 mikev created
|
||
* 10/08/96 mikeg - created h323vidc.cpp
|
||
* 11/04/96 mikev - cleanup and merge audio and video capability classes (remove
|
||
* common inheritance of IH323PubCap, both audio and video implementation
|
||
* classes inherit from IH323MediaCap. )
|
||
*/
|
||
|
||
|
||
#include "precomp.h"
|
||
|
||
#define SAMPLE_BASED_SAMPLES_PER_FRAME 8
|
||
#define MAX_FRAME_LEN 480 //bytes - where did this value come from?
|
||
#define MAX_FRAME_LEN_RECV 1440 // 180 ms at 8000hz G.711
|
||
|
||
// some utility functions for calculating frame sizes and frames per packet
|
||
|
||
HRESULT WINAPI CreateMediaCapability(REFGUID mediaId, LPIH323MediaCap * ppMediaCapability)
|
||
{
|
||
HRESULT hrLast = E_OUTOFMEMORY;
|
||
|
||
if (!ppMediaCapability)
|
||
return E_POINTER;
|
||
if (mediaId == MEDIA_TYPE_H323AUDIO)
|
||
{
|
||
CMsiaCapability * pAudObj = NULL;
|
||
UINT uAud;
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
pAudObj = new CMsiaCapability;
|
||
|
||
if(pAudObj)
|
||
{
|
||
|
||
hrLast = pAudObj->QueryInterface(IID_IH323MediaCap, (void **)ppMediaCapability);
|
||
pAudObj->Release(); // this balances the refcount of "new CMsiaCapability"
|
||
pAudObj = NULL;
|
||
}
|
||
|
||
|
||
}
|
||
else if (mediaId == MEDIA_TYPE_H323VIDEO)
|
||
{
|
||
CMsivCapability * pVidObj = NULL;
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
pVidObj = new CMsivCapability;
|
||
if(pVidObj)
|
||
{
|
||
|
||
hrLast = pVidObj->QueryInterface(IID_IH323MediaCap, (void **)ppMediaCapability);
|
||
pVidObj->Release(); // this balances the refcount of "new CMsivCapability"
|
||
pVidObj = NULL;
|
||
}
|
||
|
||
}
|
||
else
|
||
hrLast = E_NOINTERFACE;
|
||
if(HR_SUCCEEDED(hrLast))
|
||
{
|
||
if (!(*ppMediaCapability)->Init())
|
||
{
|
||
(*ppMediaCapability)->Release();
|
||
hrLast = E_FAIL;
|
||
*ppMediaCapability = NULL;
|
||
}
|
||
}
|
||
return hrLast;
|
||
}
|
||
|
||
//
|
||
// CMsiaCapability
|
||
//
|
||
UINT CMsiaCapability::GetLocalSendParamSize(MEDIA_FORMAT_ID dwID)
|
||
{
|
||
return (sizeof(AUDIO_CHANNEL_PARAMETERS));
|
||
}
|
||
UINT CMsiaCapability::GetLocalRecvParamSize(PCC_TERMCAP pCapability)
|
||
{
|
||
return (sizeof(AUDIO_CHANNEL_PARAMETERS));
|
||
}
|
||
|
||
|
||
HRESULT CMsiaCapability::CreateCapList(LPVOID *ppCapBuf)
|
||
{
|
||
UINT u;
|
||
AUDCAP_DETAILS *pDecodeDetails = pLocalFormats;
|
||
PCC_TERMCAPLIST pTermCapList = NULL;
|
||
PPCC_TERMCAP ppCCThisTermCap = NULL;
|
||
|
||
PCC_TERMCAP pCCThisCap = NULL;
|
||
PNSC_AUDIO_CAPABILITY pNSCapNext;
|
||
LPWAVEFORMATEX lpwfx;
|
||
HRESULT hr = hrSuccess;
|
||
FX_ENTRY ("CreateCapList");
|
||
// validate input
|
||
if(!ppCapBuf)
|
||
{
|
||
hr = CAPS_E_INVALID_PARAM;
|
||
goto ERROR_OUT;
|
||
}
|
||
*ppCapBuf = NULL;
|
||
if(!uNumLocalFormats || !pDecodeDetails)
|
||
{
|
||
hr = CAPS_E_NOCAPS;
|
||
goto ERROR_OUT;
|
||
}
|
||
|
||
pTermCapList = (PCC_TERMCAPLIST)MemAlloc(sizeof(CC_TERMCAPLIST));
|
||
if(!pTermCapList)
|
||
{
|
||
hr = CAPS_E_NOMEM;
|
||
goto ERROR_OUT;
|
||
}
|
||
ppCCThisTermCap = (PPCC_TERMCAP)MemAlloc(uNumLocalFormats * sizeof(PCC_TERMCAP));
|
||
if(!ppCCThisTermCap)
|
||
{
|
||
hr = CAPS_E_NOMEM;
|
||
goto ERROR_OUT;
|
||
}
|
||
pTermCapList->wLength = 0;
|
||
// point the CC_TERMCAPLIST pTermCapArray at the array of PCC_TERMCAP
|
||
pTermCapList->pTermCapArray = ppCCThisTermCap;
|
||
/*
|
||
CC_TERMCAPLIST PCC_TERMCAP CC_TERMCAP
|
||
|
||
pTermCapList-> {
|
||
wLength
|
||
pTermCapArray--->pTermCap----------->{single capability.....}
|
||
}
|
||
pTermCap----------->{single capability.}
|
||
|
||
pTermCap----------->{single capability...}
|
||
|
||
*/
|
||
|
||
for(u=0; u <uNumLocalFormats; u++)
|
||
{
|
||
// check if enabled for receive, skip if false
|
||
// also skip if public version of capabilities is to be advertised via a
|
||
// separate local capability entry
|
||
if((!pDecodeDetails->bRecvEnabled ) || (pDecodeDetails->dwPublicRefIndex))
|
||
{
|
||
pDecodeDetails++;
|
||
continue;
|
||
}
|
||
|
||
if(pDecodeDetails->H245TermCap.ClientType ==0
|
||
|| pDecodeDetails->H245TermCap.ClientType ==H245_CLIENT_AUD_NONSTD)
|
||
{
|
||
|
||
lpwfx = (LPWAVEFORMATEX)pDecodeDetails->lpLocalFormatDetails;
|
||
if(!lpwfx)
|
||
{
|
||
pDecodeDetails++;
|
||
continue;
|
||
}
|
||
// allocate for this one capability
|
||
pCCThisCap = (PCC_TERMCAP)MemAlloc(sizeof(CC_TERMCAP));
|
||
pNSCapNext = (PNSC_AUDIO_CAPABILITY)MemAlloc(sizeof(NSC_AUDIO_CAPABILITY)
|
||
+ lpwfx->cbSize);
|
||
|
||
if((!pCCThisCap)|| (!pNSCapNext))
|
||
{
|
||
hr = CAPS_E_NOMEM;
|
||
goto ERROR_OUT;
|
||
}
|
||
// set type of nonstandard capability
|
||
pNSCapNext->cap_type = NSC_ACM_WAVEFORMATEX;
|
||
// stuff both chunks of nonstandard capability info into buffer
|
||
// first stuff the "channel parameters" (the format independent communication options)
|
||
memcpy(&pNSCapNext->cap_params, &pDecodeDetails->nonstd_params, sizeof(NSC_CHANNEL_PARAMETERS));
|
||
|
||
// then the ACM stuff
|
||
memcpy(&pNSCapNext->cap_data.wfx, lpwfx, sizeof(WAVEFORMATEX) + lpwfx->cbSize);
|
||
|
||
pCCThisCap->ClientType = H245_CLIENT_AUD_NONSTD;
|
||
pCCThisCap->DataType = H245_DATA_AUDIO;
|
||
// is this a "receive only" cap or a send&receive cap
|
||
pCCThisCap->Dir = (pDecodeDetails->bSendEnabled && bPublicizeTXCaps)
|
||
? H245_CAPDIR_LCLRXTX :H245_CAPDIR_LCLRX;
|
||
|
||
// convert index of the cap entry to the ID
|
||
pCCThisCap->CapId = (USHORT)IndexToId(u);
|
||
|
||
// all nonstandard identifier fields are unsigned short
|
||
// two possibilities for choice are "h221NonStandard_chosen" and "object_chosen"
|
||
pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.choice = h221NonStandard_chosen;
|
||
// NOTE: there is some question about the correct byte order
|
||
// of the codes in the h221NonStandard structure
|
||
pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35CountryCode = USA_H221_COUNTRY_CODE;
|
||
pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35Extension = USA_H221_COUNTRY_EXTENSION;
|
||
pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.manufacturerCode = MICROSOFT_H_221_MFG_CODE;
|
||
|
||
// set size of buffer
|
||
pCCThisCap->Cap.H245Aud_NONSTD.data.length = sizeof(NSC_AUDIO_CAPABILITY) + lpwfx->cbSize;
|
||
pCCThisCap->Cap.H245Aud_NONSTD.data.value = (BYTE *)pNSCapNext; // point to nonstandard stuff
|
||
|
||
// pNSCapNext is now referenced by the pTermCapList and will
|
||
// be cleaned up via DeleteCapList(). Null the ptr so that error cleanup
|
||
// won't try redundant cleanup.
|
||
pNSCapNext = NULL;
|
||
}
|
||
else
|
||
{
|
||
// allocate for this one capability
|
||
pCCThisCap = (PCC_TERMCAP)MemAlloc(sizeof(CC_TERMCAP));
|
||
if(!pCCThisCap)
|
||
{
|
||
hr = CAPS_E_NOMEM;
|
||
goto ERROR_OUT;
|
||
}
|
||
|
||
pCCThisCap->ClientType = (H245_CLIENT_T)pDecodeDetails->H245TermCap.ClientType;
|
||
pCCThisCap->DataType = H245_DATA_AUDIO;
|
||
// is this a "receive only" cap or a send&receive cap
|
||
pCCThisCap->Dir = (pDecodeDetails->bSendEnabled && bPublicizeTXCaps)
|
||
? H245_CAPDIR_LCLRXTX :H245_CAPDIR_LCLRX;
|
||
|
||
// convert the index of the cap entry to the ID
|
||
pCCThisCap->CapId = (USHORT)IndexToId(u);//
|
||
|
||
// Fixup capability parameters based on local details
|
||
// use parameters that should have been set when codecs were enumerated
|
||
// Special note for sample based codecs: H.225.0 Section 6.2.1 states
|
||
// "Sample based codecs, such as G.711 and G.722 shall be considered to be
|
||
// frame oriented, with a frame size of eight samples."
|
||
switch (pCCThisCap->ClientType )
|
||
{
|
||
|
||
case H245_CLIENT_AUD_G711_ALAW64:
|
||
pCCThisCap->Cap.H245Aud_G711_ALAW64 =
|
||
pDecodeDetails->nonstd_params.wFramesPerPktMax
|
||
/ SAMPLE_BASED_SAMPLES_PER_FRAME;
|
||
break;
|
||
case H245_CLIENT_AUD_G711_ULAW64:
|
||
pCCThisCap->Cap.H245Aud_G711_ULAW64 =
|
||
pDecodeDetails->nonstd_params.wFramesPerPktMax
|
||
/SAMPLE_BASED_SAMPLES_PER_FRAME ;
|
||
break;
|
||
|
||
case H245_CLIENT_AUD_G723:
|
||
|
||
pCCThisCap->Cap.H245Aud_G723.maxAl_sduAudioFrames = //4
|
||
pDecodeDetails->nonstd_params.wFramesPerPktMax;
|
||
// we know that the G.723 codec can decode SID in any mode, so
|
||
//could we always advertise the *capability* to do silence suppression ????
|
||
|
||
pCCThisCap->Cap.H245Aud_G723.silenceSuppression = 0;
|
||
// = (pDecodeDetails->nonstd_params.UseSilenceDet)?1:0;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
pDecodeDetails++;
|
||
*ppCCThisTermCap++ = pCCThisCap;// add ptr to this capability to the array
|
||
pTermCapList->wLength++; // count this entry
|
||
// pCCThisCap is now referenced by the pTermCapList and will
|
||
// be cleaned up via DeleteCapList(). Null the ptr so that error cleanup
|
||
// won't try redundant cleanup.
|
||
pCCThisCap = NULL;
|
||
}
|
||
*ppCapBuf = pTermCapList;
|
||
return hr;
|
||
|
||
ERROR_OUT:
|
||
if(pTermCapList)
|
||
{
|
||
DeleteCapList(pTermCapList);
|
||
}
|
||
if(pCCThisCap)
|
||
MemFree(pCCThisCap);
|
||
if(pNSCapNext)
|
||
MemFree(pNSCapNext);
|
||
return hr;
|
||
|
||
|
||
}
|
||
|
||
HRESULT CMsiaCapability::DeleteCapList(LPVOID pCapBuf)
|
||
{
|
||
UINT u;
|
||
PCC_TERMCAPLIST pTermCapList = (PCC_TERMCAPLIST)pCapBuf;
|
||
PCC_TERMCAP pCCThisCap;
|
||
PNSC_AUDIO_CAPABILITY pNSCap;
|
||
|
||
if(!pTermCapList)
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
|
||
if(pTermCapList->pTermCapArray)
|
||
{
|
||
while(pTermCapList->wLength--)
|
||
{
|
||
pCCThisCap = *(pTermCapList->pTermCapArray + pTermCapList->wLength);
|
||
if(pCCThisCap)
|
||
{
|
||
if(pCCThisCap->ClientType == H245_CLIENT_AUD_NONSTD)
|
||
{
|
||
if(pCCThisCap->Cap.H245Aud_NONSTD.data.value)
|
||
{
|
||
MemFree(pCCThisCap->Cap.H245Aud_NONSTD.data.value);
|
||
}
|
||
}
|
||
MemFree(pCCThisCap);
|
||
}
|
||
}
|
||
MemFree(pTermCapList->pTermCapArray);
|
||
}
|
||
MemFree(pTermCapList);
|
||
return hrSuccess;
|
||
}
|
||
|
||
|
||
// copies relevant fields from a real H245 TERMCAP struct
|
||
// to a local H245TermCap struct
|
||
void CopyTermCapInfo(PCC_TERMCAP pSrc, H245_TERMCAP *pDest)
|
||
{
|
||
ZeroMemory(pDest, sizeof(*pDest));
|
||
|
||
pDest->Dir = pSrc->Dir;
|
||
pDest->DataType = pSrc->DataType;
|
||
pDest->ClientType = pSrc->ClientType;
|
||
pDest->CapId = pSrc->CapId;
|
||
|
||
pDest->H245_NonStd = pSrc->Cap.H245_NonStd;
|
||
pDest->H245Aud_NONSTD = pSrc->Cap.H245Aud_NONSTD;
|
||
|
||
pDest->H245Aud_G711_ALAW64 = pSrc->Cap.H245Aud_G711_ALAW64;
|
||
pDest->H245Aud_G711_ULAW64 = pSrc->Cap.H245Aud_G711_ULAW64;
|
||
pDest->H245Aud_G723 = pSrc->Cap.H245Aud_G723;
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
void CopyLocalTermCapInfo(H245_TERMCAP *pSrc, PCC_TERMCAP pDest)
|
||
{
|
||
ZeroMemory(pDest, sizeof(*pDest));
|
||
|
||
pDest->Dir = pSrc->Dir;
|
||
pDest->DataType = pSrc->DataType;
|
||
pDest->ClientType = pSrc->ClientType;
|
||
pDest->CapId = pSrc->CapId;
|
||
|
||
pDest->Cap.H245_NonStd = pSrc->H245_NonStd;
|
||
pDest->Cap.H245Aud_NONSTD = pSrc->H245Aud_NONSTD;
|
||
|
||
pDest->Cap.H245Aud_G711_ALAW64 = pSrc->H245Aud_G711_ALAW64;
|
||
pDest->Cap.H245Aud_G711_ULAW64 = pSrc->H245Aud_G711_ULAW64;
|
||
pDest->Cap.H245Aud_G723 = pSrc->H245Aud_G723;
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
|
||
// the intent is to keep a copy of the channel parameters used to open a send channel
|
||
// that the remote end can decode.
|
||
|
||
AUDIO_FORMAT_ID CMsiaCapability::AddRemoteDecodeFormat(PCC_TERMCAP pCCThisCap)
|
||
{
|
||
FX_ENTRY ("CMsiaCapability::AddRemoteDecodeFormat");
|
||
|
||
AUDCAP_DETAILS audcapdetails =
|
||
{WAVE_FORMAT_UNKNOWN, NONSTD_TERMCAP, STD_CHAN_PARAMS,
|
||
{RTP_DYNAMIC_MIN, 8000, 4},
|
||
0, TRUE, TRUE, 320, 32000,32000,50,0,0,0,NULL,0, NULL,""};
|
||
|
||
LPVOID lpData = NULL;
|
||
UINT uSize = 0;
|
||
AUDCAP_DETAILS *pTemp;
|
||
if(!pCCThisCap)
|
||
{
|
||
return INVALID_AUDIO_FORMAT;
|
||
}
|
||
|
||
// check room
|
||
if(uRemoteDecodeFormatCapacity <= uNumRemoteDecodeFormats)
|
||
{
|
||
// get more mem, realloc memory by CAP_CHUNK_SIZE for pRemoteDecodeFormats
|
||
pTemp = (AUDCAP_DETAILS *)MemAlloc((uNumRemoteDecodeFormats + CAP_CHUNK_SIZE)*sizeof(AUDCAP_DETAILS));
|
||
if(!pTemp)
|
||
goto ERROR_EXIT;
|
||
// remember how much capacity we now have
|
||
uRemoteDecodeFormatCapacity = uNumRemoteDecodeFormats + CAP_CHUNK_SIZE;
|
||
#ifdef DEBUG
|
||
if((uNumRemoteDecodeFormats && !pRemoteDecodeFormats) || (!uNumRemoteDecodeFormats && pRemoteDecodeFormats))
|
||
{
|
||
ERRORMESSAGE(("%s:leak! uNumRemoteDecodeFormats:0x%08lX, pRemoteDecodeFormats:0x%08lX\r\n",
|
||
_fx_, uNumRemoteDecodeFormats,pRemoteDecodeFormats));
|
||
}
|
||
#endif
|
||
// copy old stuff, discard old mem
|
||
if(uNumRemoteDecodeFormats && pRemoteDecodeFormats)
|
||
{
|
||
memcpy(pTemp, pRemoteDecodeFormats, uNumRemoteDecodeFormats*sizeof(AUDCAP_DETAILS));
|
||
MemFree(pRemoteDecodeFormats);
|
||
}
|
||
pRemoteDecodeFormats = pTemp;
|
||
}
|
||
// pTemp is where the stuff is cached
|
||
pTemp = pRemoteDecodeFormats+uNumRemoteDecodeFormats;
|
||
|
||
// fixup the capability structure being added. First thing: initialize defaults
|
||
memcpy(pTemp, &audcapdetails, sizeof(AUDCAP_DETAILS));
|
||
// next, the H245 parameters
|
||
|
||
// memcpy(&pTemp->H245Cap, pCCThisCap, sizeof(pTemp->H245Cap));
|
||
CopyTermCapInfo(pCCThisCap, &pTemp->H245TermCap);
|
||
|
||
// Note: if nonstandard data exists, the nonstd pointers need to be fixed up
|
||
if(pCCThisCap->ClientType == H245_CLIENT_AUD_NONSTD)
|
||
{
|
||
// do we recognize this?
|
||
if(pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.choice == h221NonStandard_chosen)
|
||
{
|
||
if((pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35CountryCode == USA_H221_COUNTRY_CODE)
|
||
&& (pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35Extension == USA_H221_COUNTRY_EXTENSION)
|
||
&& (pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.manufacturerCode == MICROSOFT_H_221_MFG_CODE))
|
||
{
|
||
// ok, this is ours so far. Now what data type is contained therein?
|
||
// welllll, lets keep a copy of this regardless ????. If we can't understand
|
||
// future versions of ourselves, then what???
|
||
uSize = pCCThisCap->Cap.H245Aud_NONSTD.data.length;
|
||
lpData = pCCThisCap->Cap.H245Aud_NONSTD.data.value;
|
||
}
|
||
}
|
||
} else {
|
||
// set up the NSC_CHANNEL_PARAMETERS struct based on the remote H245 parameters
|
||
|
||
switch(pCCThisCap->ClientType ) {
|
||
case H245_CLIENT_AUD_G711_ALAW64:
|
||
pTemp->nonstd_params.wFramesPerPktMax = pCCThisCap->Cap.H245Aud_G711_ALAW64
|
||
* SAMPLE_BASED_SAMPLES_PER_FRAME;
|
||
break;
|
||
case H245_CLIENT_AUD_G711_ULAW64:
|
||
pTemp->nonstd_params.wFramesPerPktMax = pCCThisCap->Cap.H245Aud_G711_ULAW64
|
||
* SAMPLE_BASED_SAMPLES_PER_FRAME;
|
||
break;
|
||
|
||
case H245_CLIENT_AUD_G723:
|
||
|
||
pTemp->nonstd_params.wFramesPerPktMax =pCCThisCap->Cap.H245Aud_G723.maxAl_sduAudioFrames;
|
||
// do we care about silence suppression?
|
||
pTemp->nonstd_params.UseSilenceDet = pCCThisCap->Cap.H245Aud_G723.silenceSuppression;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
pTemp->uLocalDetailsSize = 0; // we're not keeping another copy of local encode details
|
||
pTemp->lpLocalFormatDetails =0; // we're not keeping another copy of local encode details
|
||
|
||
pTemp->uRemoteDetailsSize = 0; // clear this now
|
||
if(uSize && lpData)
|
||
{
|
||
pTemp->H245TermCap.H245Aud_NONSTD.data.length = uSize;
|
||
pTemp->H245TermCap.H245Aud_NONSTD.data.value = (unsigned char *)lpData;
|
||
|
||
pTemp->lpRemoteFormatDetails = MemAlloc(uSize);
|
||
if(pTemp->lpRemoteFormatDetails)
|
||
{
|
||
memcpy(pTemp->lpRemoteFormatDetails, lpData, uSize);
|
||
pTemp->uRemoteDetailsSize = uSize;
|
||
|
||
}
|
||
#ifdef DEBUG
|
||
else
|
||
{
|
||
ERRORMESSAGE(("%s:allocation failed!\r\n",_fx_));
|
||
}
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
pTemp->lpRemoteFormatDetails = NULL;
|
||
pTemp->uRemoteDetailsSize =0;
|
||
}
|
||
uNumRemoteDecodeFormats++;
|
||
// use the index as the ID
|
||
return (uNumRemoteDecodeFormats-1);
|
||
|
||
ERROR_EXIT:
|
||
return INVALID_AUDIO_FORMAT;
|
||
|
||
}
|
||
|
||
BOOL CMsiaCapability::IsCapabilityRecognized(PCC_TERMCAP pCCThisCap)
|
||
{
|
||
FX_ENTRY ("CMsiaCapability::IsCapabilityRecognized");
|
||
if(pCCThisCap->DataType != H245_DATA_AUDIO)
|
||
return FALSE;
|
||
|
||
if(pCCThisCap->ClientType == H245_CLIENT_AUD_NONSTD)
|
||
{
|
||
// do we recognize this?
|
||
if(pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.choice == h221NonStandard_chosen)
|
||
{
|
||
if((pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35CountryCode == USA_H221_COUNTRY_CODE)
|
||
&& (pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35Extension == USA_H221_COUNTRY_EXTENSION)
|
||
&& (pCCThisCap->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.manufacturerCode == MICROSOFT_H_221_MFG_CODE))
|
||
|
||
{
|
||
// ok, this is ours so far. Now what data type is contained therein?
|
||
// welllll, lets keep a copy of this regardless ????. If we can't understand
|
||
// future versions of ourselves, then what???
|
||
return TRUE;
|
||
}
|
||
else
|
||
{
|
||
// unrecognized nonstandard capability
|
||
ERRORMESSAGE(("%s:unrecognized nonstd capability\r\n",_fx_));
|
||
#ifdef DEBUG
|
||
VOID DumpNonstdParameters(PCC_TERMCAP pChanCap1, PCC_TERMCAP pChanCap2);
|
||
DumpNonstdParameters(NULL, pCCThisCap);
|
||
#endif
|
||
return FALSE;
|
||
}
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
HRESULT CMsiaCapability::AddRemoteDecodeCaps(PCC_TERMCAPLIST pTermCapList)
|
||
{
|
||
FX_ENTRY ("CMsiaCapability::AddRemoteDecodeCaps");
|
||
HRESULT hr = hrSuccess;
|
||
PPCC_TERMCAP ppCCThisCap;
|
||
PCC_TERMCAP pCCThisCap;
|
||
|
||
WORD wNumCaps;
|
||
|
||
//ERRORMESSAGE(("%s,\r\n", _fx_));
|
||
if(!pTermCapList) // additional capability descriptors may be added
|
||
{ // at any time
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
|
||
// cleanup old term caps if term caps are being added and old caps exist
|
||
FlushRemoteCaps();
|
||
|
||
wNumCaps = pTermCapList->wLength;
|
||
ppCCThisCap = pTermCapList->pTermCapArray;
|
||
|
||
/*
|
||
CC_TERMCAPLIST TERMCAPINFO CC_TERMCAP
|
||
|
||
pTermCapList-> {
|
||
wLength
|
||
pTermCapInfo--->pTermCap----------->{single capability.....}
|
||
}
|
||
pTermCap----------->{single capability.}
|
||
|
||
pTermCap----------->{single capability...}
|
||
|
||
*/
|
||
while(wNumCaps--)
|
||
{
|
||
if(!(pCCThisCap = *ppCCThisCap++))
|
||
{
|
||
ERRORMESSAGE(("%s:null pTermCap, 0x%04x of 0x%04x\r\n",
|
||
_fx_, pTermCapList->wLength - wNumCaps, pTermCapList->wLength));
|
||
continue;
|
||
}
|
||
if(!IsCapabilityRecognized(pCCThisCap))
|
||
{
|
||
continue;
|
||
}
|
||
AddRemoteDecodeFormat(pCCThisCap);
|
||
}
|
||
return hr;
|
||
}
|
||
|
||
|
||
|
||
// Given the ID of a local format, gets the channel parameters that are sent to the
|
||
// remote end as part of the capability exchange. This function is not used by the
|
||
// capability exchange code (because it sends more than just these parameters).
|
||
// However, this is useful information by itself - it can be used for validating the
|
||
// parameters of channel open requests against the expected parameters
|
||
|
||
HRESULT CMsiaCapability::GetPublicDecodeParams(LPVOID pBufOut, UINT uBufSize, AUDIO_FORMAT_ID id)
|
||
{
|
||
UINT uIndex = IDToIndex(id);
|
||
// validate input
|
||
if(!pBufOut|| (uIndex >= (UINT)uNumLocalFormats))
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
if(uBufSize < sizeof(CC_TERMCAP))
|
||
{
|
||
return CAPS_E_BUFFER_TOO_SMALL;
|
||
}
|
||
// memcpy(pBufOut, &((pLocalFormats + uIndex)->H245Cap), sizeof(CC_TERMCAP));
|
||
CopyLocalTermCapInfo(&((pLocalFormats + uIndex)->H245TermCap), (PCC_TERMCAP)pBufOut);
|
||
|
||
return hrSuccess;
|
||
}
|
||
|
||
HRESULT CMsiaCapability::SetAudioPacketDuration(UINT uPacketDuration)
|
||
{
|
||
m_uPacketDuration = uPacketDuration;
|
||
return S_OK;
|
||
}
|
||
|
||
// Given the IDs of "matching" local and remote formats, gets the preferred channel parameters
|
||
// that will be used in requests to open a channel for sending to the remote.
|
||
|
||
HRESULT CMsiaCapability::GetEncodeParams(LPVOID pBufOut, UINT uBufSize,LPVOID pLocalParams, UINT uSizeLocal,
|
||
AUDIO_FORMAT_ID idRemote, AUDIO_FORMAT_ID idLocal)
|
||
{
|
||
UINT uLocalIndex = IDToIndex(idLocal);
|
||
AUDCAP_DETAILS *pLocalDetails = pLocalFormats + uLocalIndex;
|
||
AUDCAP_DETAILS *pFmtTheirs;
|
||
AUDIO_CHANNEL_PARAMETERS local_params;
|
||
PNSC_CHANNEL_PARAMETERS pNSRemoteParams;
|
||
LPWAVEFORMATEX lpwfx;
|
||
|
||
UINT u;
|
||
PCC_TERMCAP pTermCap = (PCC_TERMCAP)pBufOut;
|
||
// validate input
|
||
if(!pBufOut)
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
if(uBufSize < sizeof(CC_TERMCAP))
|
||
{
|
||
return CAPS_E_BUFFER_TOO_SMALL;
|
||
}
|
||
if(!pLocalParams|| uSizeLocal < sizeof(AUDIO_CHANNEL_PARAMETERS)
|
||
||(uLocalIndex >= (UINT)uNumLocalFormats))
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
|
||
pFmtTheirs = pRemoteDecodeFormats; // start at the beginning of the remote formats
|
||
for(u=0; u<uNumRemoteDecodeFormats; u++)
|
||
{
|
||
if(pFmtTheirs->H245TermCap.CapId == idRemote)
|
||
{
|
||
// copy CC_TERMCAP struct. Any data referenced by CC_TERMCAP now has
|
||
// two references to it. i.e. pTermCap->extrablah is the same
|
||
// location as pFmtTheirs->extrablah
|
||
// memcpy(pBufOut, &(pFmtTheirs->H245Cap), sizeof(CC_TERMCAP));
|
||
CopyLocalTermCapInfo(&(pFmtTheirs->H245TermCap), (PCC_TERMCAP)pBufOut);
|
||
|
||
break;
|
||
}
|
||
pFmtTheirs++; // next entry in receiver's caps
|
||
}
|
||
|
||
// check for an unfound format
|
||
if(u >= uNumRemoteDecodeFormats)
|
||
goto ERROR_EXIT;
|
||
|
||
// select channel parameters if appropriate. The audio formats that have variable parameters
|
||
// are :
|
||
|
||
// H245_CAP_G723_T H245Aud_G723;
|
||
// H245_CAP_AIS11172_T H245Aud_IS11172;
|
||
// H245_CAP_IS13818_T H245Aud_IS13818;
|
||
// and of course all nonstandard formats
|
||
|
||
// Select parameters based on local capability info
|
||
|
||
// initialize local_params with default settings
|
||
memcpy(&local_params.ns_params,&pLocalDetails->nonstd_params,sizeof(local_params.ns_params));
|
||
|
||
// recalculate frames per packet
|
||
lpwfx = (LPWAVEFORMATEX)pLocalDetails->lpLocalFormatDetails;
|
||
local_params.ns_params.wFramesPerPktMax = LOWORD(MaxFramesPerPacket(lpwfx));
|
||
local_params.ns_params.wFramesPerPkt = LOWORD(MinFramesPerPacket(lpwfx));
|
||
if(local_params.ns_params.wFramesPerPktMin > local_params.ns_params.wFramesPerPkt)
|
||
{
|
||
local_params.ns_params.wFramesPerPktMin = local_params.ns_params.wFramesPerPkt;
|
||
}
|
||
|
||
|
||
|
||
if(pTermCap->ClientType == H245_CLIENT_AUD_G723)
|
||
{
|
||
// select frames per packet based on minimum latency value that is acceptable
|
||
pTermCap->Cap.H245Aud_G723.maxAl_sduAudioFrames = //4
|
||
min(local_params.ns_params.wFramesPerPkt, pTermCap->Cap.H245Aud_G723.maxAl_sduAudioFrames);
|
||
// pLocalDetails->nonstd_params.wFramesPerPktMax;
|
||
// never request silence suppression
|
||
pTermCap->Cap.H245Aud_G723.silenceSuppression = 0;
|
||
// (pLocalDetails->nonstd_params.UseSilenceDet)?1:0;
|
||
|
||
// keep a copy of the selected parameters for use on the local side
|
||
local_params.ns_params.wFramesPerPkt = local_params.ns_params.wFramesPerPktMin =
|
||
local_params.ns_params.wFramesPerPktMax = pTermCap->Cap.H245Aud_G723.maxAl_sduAudioFrames;
|
||
local_params.ns_params.UseSilenceDet = pTermCap->Cap.H245Aud_G723.silenceSuppression;
|
||
local_params.RTP_Payload = pLocalDetails->audio_params.RTPPayload;
|
||
}
|
||
else if(pTermCap->ClientType == H245_CLIENT_AUD_G711_ALAW64)
|
||
{
|
||
// select frames per packet based on minimum latency value that is acceptable
|
||
pTermCap->Cap.H245Aud_G711_ALAW64 =
|
||
min(local_params.ns_params.wFramesPerPkt/SAMPLE_BASED_SAMPLES_PER_FRAME, pTermCap->Cap.H245Aud_G711_ALAW64);
|
||
// keep a copy of the selected parameters for use on the local side
|
||
local_params.ns_params.wFramesPerPkt = local_params.ns_params.wFramesPerPktMin =
|
||
local_params.ns_params.wFramesPerPktMax = pTermCap->Cap.H245Aud_G711_ALAW64*SAMPLE_BASED_SAMPLES_PER_FRAME;
|
||
local_params.ns_params.UseSilenceDet = FALSE;
|
||
// note that local_params.RTP_Payload is fixed below
|
||
}
|
||
else if(pTermCap->ClientType == H245_CLIENT_AUD_G711_ULAW64)
|
||
{
|
||
// select frames per packet based on minimum latency value that is acceptable
|
||
pTermCap->Cap.H245Aud_G711_ULAW64 =
|
||
min(local_params.ns_params.wFramesPerPkt/SAMPLE_BASED_SAMPLES_PER_FRAME, pTermCap->Cap.H245Aud_G711_ULAW64);
|
||
// keep a copy of the selected parameters for use on the local side
|
||
local_params.ns_params.wFramesPerPkt = local_params.ns_params.wFramesPerPktMin =
|
||
local_params.ns_params.wFramesPerPktMax = pTermCap->Cap.H245Aud_G711_ULAW64*SAMPLE_BASED_SAMPLES_PER_FRAME;
|
||
local_params.ns_params.UseSilenceDet = FALSE;
|
||
// note that local_params.RTP_Payload is fixed below
|
||
}
|
||
else if (pTermCap->ClientType == H245_CLIENT_AUD_NONSTD)
|
||
{
|
||
|
||
// note: "H245_CLIENT_AUD_NONSTD H245Aud_NONSTD;" also has variable parameters in the
|
||
// form of a pointer to a chunk of nonstandard data. This pointer and the nonstandard
|
||
// data it points to was set when remote caps were received (see AddRemoteDecodeCaps ()).
|
||
// So as of this point, we just copied that nonstandard data back out into the channel
|
||
// parameters. We will use these parameters to request an open channel.
|
||
|
||
// once we fix up a few important parameters. set channel params based on local params
|
||
|
||
|
||
pNSRemoteParams = &((PNSC_AUDIO_CAPABILITY)(pTermCap->Cap.H245Aud_NONSTD.data.value))->cap_params;
|
||
|
||
// LOOKLOOK ---- which parameters do we really need to select ???
|
||
// For example, if wFrameSizeMin != wFrameSizeMax, do we pick something in the range?
|
||
// or own favorite value? what else?
|
||
|
||
if(pNSRemoteParams->wFrameSizeMax < pNSRemoteParams->wFrameSize) // fixup bogus parameters
|
||
pNSRemoteParams->wFrameSizeMax = pNSRemoteParams->wFrameSize;
|
||
|
||
// note that this writes on the memory that is caching remote capabilities
|
||
// set frame size to our preferred size unless remote can't take it that big
|
||
pNSRemoteParams->wFrameSize =
|
||
min(local_params.ns_params.wFrameSize, pNSRemoteParams->wFrameSizeMax);
|
||
pNSRemoteParams->wFramesPerPkt = min( local_params.ns_params.wFramesPerPkt,
|
||
pNSRemoteParams->wFramesPerPktMax);
|
||
|
||
// use optional stuff only of both sides have it
|
||
pNSRemoteParams->UseSilenceDet = pNSRemoteParams->UseSilenceDet && local_params.ns_params.UseSilenceDet;
|
||
pNSRemoteParams->UsePostFilter = pNSRemoteParams->UsePostFilter && local_params.ns_params.UsePostFilter;
|
||
|
||
// keep a copy of the selected parameters for use on the local side
|
||
memcpy(&local_params.ns_params, pNSRemoteParams, sizeof(NSC_CHANNEL_PARAMETERS));
|
||
}
|
||
|
||
// fix payload type
|
||
local_params.RTP_Payload = pLocalDetails->audio_params.RTPPayload;
|
||
memcpy(pLocalParams, &local_params, sizeof(AUDIO_CHANNEL_PARAMETERS));
|
||
|
||
return hrSuccess;
|
||
|
||
ERROR_EXIT:
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
|
||
|
||
// Given the ID of the local format, gets the local parameters that are used to configure
|
||
// the RECEIVE side of the channel
|
||
HRESULT CMsiaCapability::GetLocalDecodeParams(LPVOID lpvBuf, UINT uBufSize, AUDIO_FORMAT_ID id)
|
||
{
|
||
// validate input
|
||
if(!lpvBuf|| uBufSize < sizeof(NSC_CHANNEL_PARAMETERS) ||(id > (UINT)uNumLocalFormats))
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
memcpy(lpvBuf, &((pLocalFormats + id)->nonstd_params), sizeof(NSC_CHANNEL_PARAMETERS));
|
||
return hrSuccess;
|
||
}
|
||
|
||
BOOL NonstandardCapsCompareA(AUDCAP_DETAILS *pFmtMine, PNSC_AUDIO_CAPABILITY pCap2,
|
||
UINT uSize2)
|
||
{
|
||
LPWAVEFORMATEX lpwfx;
|
||
if(!pFmtMine || !pCap2)
|
||
return FALSE;
|
||
|
||
if(!(lpwfx = (LPWAVEFORMATEX)pFmtMine->lpLocalFormatDetails))
|
||
return FALSE;
|
||
|
||
|
||
if(pCap2->cap_type == NSC_ACM_WAVEFORMATEX)
|
||
{
|
||
// check sizes first
|
||
if(lpwfx->cbSize != pCap2->cap_data.wfx.cbSize)
|
||
{
|
||
return FALSE;
|
||
}
|
||
// compare structures, including extra bytes
|
||
if(memcmp(lpwfx, &pCap2->cap_data.wfx,
|
||
sizeof(WAVEFORMATEX) + lpwfx->cbSize )==0)
|
||
{
|
||
return TRUE;
|
||
}
|
||
}
|
||
else if(pCap2->cap_type == NSC_ACMABBREV)
|
||
{
|
||
if((LOWORD(pCap2->cap_data.acm_brief.dwFormatTag) == lpwfx->wFormatTag)
|
||
&& (pCap2->cap_data.acm_brief.dwSamplesPerSec == lpwfx->nSamplesPerSec)
|
||
&& (LOWORD(pCap2->cap_data.acm_brief.dwBitsPerSample) == lpwfx->wBitsPerSample))
|
||
{
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
HRESULT CMsiaCapability::ResolveToLocalFormat(MEDIA_FORMAT_ID FormatIDLocal,
|
||
MEDIA_FORMAT_ID * pFormatIDRemote)
|
||
{
|
||
AUDCAP_DETAILS *pFmtLocal;
|
||
AUDCAP_DETAILS *pFmtRemote;
|
||
UINT uIndex = IDToIndex(FormatIDLocal);
|
||
UINT i;
|
||
|
||
if(!pFormatIDRemote || (FormatIDLocal == INVALID_MEDIA_FORMAT)
|
||
|| (uIndex >= (UINT)uNumLocalFormats))
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
pFmtLocal = pLocalFormats + uIndex;
|
||
|
||
pFmtRemote = pRemoteDecodeFormats; // start at the beginning of the remote formats
|
||
for(i=0; i<uNumRemoteDecodeFormats; i++)
|
||
{
|
||
if(!pFmtLocal->bSendEnabled)
|
||
continue;
|
||
|
||
// compare capabilities - start by comparing the format tag. a.k.a. "ClientType" in H.245 land
|
||
if(pFmtLocal->H245TermCap.ClientType == pFmtRemote->H245TermCap.ClientType)
|
||
{
|
||
// if this is a nonstandard cap, compare nonstandard parameters
|
||
if(pFmtLocal->H245TermCap.ClientType == H245_CLIENT_AUD_NONSTD)
|
||
{
|
||
if(NonstandardCapsCompareA(pFmtLocal,
|
||
(PNSC_AUDIO_CAPABILITY)pFmtRemote->H245TermCap.H245Aud_NONSTD.data.value,
|
||
pFmtRemote->H245TermCap.H245Aud_NONSTD.data.length))
|
||
{
|
||
goto RESOLVED_EXIT;
|
||
}
|
||
}
|
||
else // compare standard parameters, if any
|
||
{
|
||
// well, so far, there aren't any parameters that are significant enough
|
||
// to affect the match/no match decision
|
||
goto RESOLVED_EXIT;
|
||
}
|
||
}
|
||
pFmtRemote++; // next entry in receiver's caps
|
||
}
|
||
|
||
return CAPS_E_NOMATCH;
|
||
|
||
RESOLVED_EXIT:
|
||
// Match! return ID of remote decoding (receive fmt) caps that match our
|
||
// send caps
|
||
*pFormatIDRemote = pFmtRemote->H245TermCap.CapId;
|
||
return hrSuccess;
|
||
}
|
||
|
||
// resolve using currently cached local and remote formats
|
||
|
||
HRESULT CMsiaCapability::ResolveEncodeFormat(
|
||
AUDIO_FORMAT_ID *pIDEncodeOut,
|
||
AUDIO_FORMAT_ID *pIDRemoteDecode)
|
||
{
|
||
UINT i,j=0;
|
||
AUDCAP_DETAILS *pFmtMine = pLocalFormats;
|
||
AUDCAP_DETAILS *pFmtTheirs;
|
||
// LP_CUSTOM_CAPS lpCustomRemoteCaps = (LP_CUSTOM_CAPS)lpvRemoteCustomFormats;
|
||
// LP_MSIAVC_CUSTOM_CAP_ENTRY lpCustomCaps;
|
||
// LPWAVEFORMATEX lpWFX;
|
||
|
||
if(!pIDEncodeOut || !pIDRemoteDecode)
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
if(!uNumLocalFormats || !pLocalFormats)
|
||
{
|
||
*pIDEncodeOut = *pIDRemoteDecode = INVALID_AUDIO_FORMAT;
|
||
return CAPS_E_NOCAPS;
|
||
}
|
||
if(!pRemoteDecodeFormats || !uNumRemoteDecodeFormats)
|
||
{
|
||
*pIDEncodeOut = *pIDRemoteDecode = INVALID_AUDIO_FORMAT;
|
||
return CAPS_E_NOMATCH;
|
||
}
|
||
|
||
// decide how to encode. my caps are ordered by my preference according to
|
||
// the contents of IDsByRank[]
|
||
|
||
//If given a salt, find the position and add it
|
||
if (*pIDEncodeOut != INVALID_MEDIA_FORMAT)
|
||
{
|
||
UINT uIndex = IDToIndex(*pIDEncodeOut);
|
||
if (uIndex > uNumLocalFormats)
|
||
{
|
||
return CAPS_W_NO_MORE_FORMATS;
|
||
}
|
||
for(i=0; i<uNumLocalFormats; i++)
|
||
{
|
||
if (pLocalFormats[IDsByRank[i]].H245TermCap.CapId == *pIDEncodeOut)
|
||
{
|
||
j=i+1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
for(i=j; i<uNumLocalFormats; i++)
|
||
{
|
||
pFmtMine = pLocalFormats + IDsByRank[i];
|
||
// check to see if this format is enabled for encoding
|
||
if(!pFmtMine->bSendEnabled)
|
||
continue;
|
||
|
||
pFmtTheirs = pRemoteDecodeFormats; // start at the beginning of the remote formats
|
||
for(j=0; j<uNumRemoteDecodeFormats; j++)
|
||
{
|
||
// compare capabilities - start by comparing the format tag. a.k.a. "ClientType" in H.245 land
|
||
if(pFmtMine->H245TermCap.ClientType == pFmtTheirs->H245TermCap.ClientType)
|
||
{
|
||
// if this is a nonstandard cap, compare nonstandard parameters
|
||
if(pFmtMine->H245TermCap.ClientType == H245_CLIENT_AUD_NONSTD)
|
||
{
|
||
|
||
if(NonstandardCapsCompareA(pFmtMine,
|
||
// (PNSC_AUDIO_CAPABILITY)pFmtMine->H245Cap.Cap.H245Aud_NONSTD.data.value,
|
||
(PNSC_AUDIO_CAPABILITY)pFmtTheirs->H245TermCap.H245Aud_NONSTD.data.value,
|
||
//pFmtMine->H245Cap.Cap.H245Aud_NONSTD.data.length,
|
||
pFmtTheirs->H245TermCap.H245Aud_NONSTD.data.length))
|
||
{
|
||
goto RESOLVED_EXIT;
|
||
}
|
||
|
||
|
||
}
|
||
else // compare standard parameters, if any
|
||
{
|
||
// well, so far, there aren't any parameters that are significant enough
|
||
// to affect the match/no match decision
|
||
goto RESOLVED_EXIT;
|
||
}
|
||
}
|
||
pFmtTheirs++; // next entry in receiver's caps
|
||
}
|
||
|
||
}
|
||
return CAPS_E_NOMATCH;
|
||
|
||
RESOLVED_EXIT:
|
||
// Match!
|
||
DEBUGMSG (ZONE_CONN,("Audio resolved (SEND) to Format Tag: %d\r\n",pFmtMine->wFormatTag));
|
||
// return ID of our encoding (sending fmt) caps that match
|
||
*pIDEncodeOut = pFmtMine->H245TermCap.CapId;
|
||
// return ID of remote decoding (receive fmt) caps that match our
|
||
// send caps
|
||
*pIDRemoteDecode = pFmtTheirs->H245TermCap.CapId;
|
||
return hrSuccess;
|
||
|
||
|
||
}
|
||
|
||
HRESULT CMsiaCapability::GetDecodeParams(PCC_RX_CHANNEL_REQUEST_CALLBACK_PARAMS pChannelParams,
|
||
AUDIO_FORMAT_ID * pFormatID, LPVOID lpvBuf, UINT uBufSize)
|
||
{
|
||
UINT i,j=0;
|
||
PCC_TERMCAP pCapability;
|
||
AUDCAP_DETAILS *pFmtMine = pLocalFormats;
|
||
PAUDIO_CHANNEL_PARAMETERS pAudioParams = (PAUDIO_CHANNEL_PARAMETERS) lpvBuf;
|
||
|
||
if(!pChannelParams || !(pCapability = pChannelParams->pChannelCapability) || !pFormatID || !lpvBuf
|
||
|| (uBufSize < sizeof(AUDIO_CHANNEL_PARAMETERS)))
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
if(!uNumLocalFormats || !pLocalFormats)
|
||
{
|
||
return CAPS_E_NOCAPS;
|
||
}
|
||
|
||
for(i=0; i<uNumLocalFormats; i++)
|
||
{
|
||
WORD wFramesPerPkt;
|
||
pFmtMine = pLocalFormats + IDsByRank[i];
|
||
|
||
// compare capabilities - start by comparing the format tag. a.k.a. "ClientType" in H.245 land
|
||
if(pFmtMine->H245TermCap.ClientType == pCapability->ClientType)
|
||
{
|
||
// if this is a nonstandard cap, compare nonstandard parameters
|
||
if(pFmtMine->H245TermCap.ClientType == H245_CLIENT_AUD_NONSTD)
|
||
{
|
||
if(NonstandardCapsCompareA(pFmtMine,
|
||
(PNSC_AUDIO_CAPABILITY)pCapability->Cap.H245Aud_NONSTD.data.value,
|
||
pCapability->Cap.H245Aud_NONSTD.data.length))
|
||
{
|
||
PNSC_AUDIO_CAPABILITY pNSCapRemote;
|
||
pNSCapRemote = (PNSC_AUDIO_CAPABILITY)pCapability->Cap.H245Aud_NONSTD.data.value;
|
||
if (pNSCapRemote->cap_params.wFramesPerPkt <= pFmtMine->nonstd_params.wFramesPerPktMax)
|
||
{
|
||
pAudioParams->ns_params = pNSCapRemote->cap_params;
|
||
goto RESOLVED_EXIT;
|
||
}
|
||
}
|
||
}
|
||
else // compare standard parameters, if any
|
||
{
|
||
|
||
if(pFmtMine->H245TermCap.ClientType == H245_CLIENT_AUD_G723)
|
||
{
|
||
// NEED TO FIND THE G.723 format that results in the largest buffer
|
||
// size calculations so that the larger bitrate format can be used.
|
||
// The buffer size calculations in the datapump are based on the
|
||
// WAVEFORMATEX structure
|
||
// search the remainder of the prioritized list, keep the best
|
||
|
||
LPWAVEFORMATEX lpwf1, lpwf2;
|
||
AUDCAP_DETAILS *pFmtTry;
|
||
lpwf1 =(LPWAVEFORMATEX)pFmtMine->lpLocalFormatDetails;
|
||
|
||
for(j = i+1; j<uNumLocalFormats; j++)
|
||
{
|
||
pFmtTry = pLocalFormats + IDsByRank[j];
|
||
if(pFmtTry->H245TermCap.ClientType != H245_CLIENT_AUD_G723)
|
||
continue;
|
||
|
||
lpwf2 =(LPWAVEFORMATEX)pFmtTry->lpLocalFormatDetails;
|
||
if(lpwf2->nAvgBytesPerSec > lpwf1->nAvgBytesPerSec)
|
||
{
|
||
//pFmtMine = pFmtTry;
|
||
lpwf1 = lpwf2;
|
||
// Return value is based on index i. This one is the
|
||
// one we want so far
|
||
i = j;
|
||
}
|
||
|
||
}
|
||
|
||
// We know that the G.723 codec can decode SID in any mode,
|
||
//
|
||
//if(pFmtMine->H245Cap.Cap.H245Aud_G723.silenceSuppression ==
|
||
// pCapability->Cap.H245Aud_G723.silenceSuppression)
|
||
//{
|
||
//}
|
||
}
|
||
pAudioParams->ns_params = pFmtMine->nonstd_params;
|
||
// update wFramesPerPkt with the actual recv channel parameter
|
||
switch (pCapability->ClientType)
|
||
{
|
||
default:
|
||
case H245_CLIENT_AUD_G711_ALAW64:
|
||
wFramesPerPkt = pCapability->Cap.H245Aud_G711_ALAW64 * SAMPLE_BASED_SAMPLES_PER_FRAME;
|
||
break;
|
||
case H245_CLIENT_AUD_G711_ULAW64:
|
||
wFramesPerPkt = pCapability->Cap.H245Aud_G711_ULAW64 * SAMPLE_BASED_SAMPLES_PER_FRAME;
|
||
break;
|
||
// these have no parameters
|
||
//case H245_CLIENT_AUD_G711_ULAW56:
|
||
//case H245_CLIENT_AUD_G711_ALAW56:
|
||
break;
|
||
|
||
case H245_CLIENT_AUD_G723:
|
||
wFramesPerPkt = pCapability->Cap.H245Aud_G723.maxAl_sduAudioFrames;
|
||
break;
|
||
}
|
||
if (wFramesPerPkt <= pFmtMine->nonstd_params.wFramesPerPktMax)
|
||
{
|
||
pAudioParams->ns_params.wFramesPerPkt = wFramesPerPkt;
|
||
goto RESOLVED_EXIT;
|
||
}
|
||
else
|
||
{
|
||
DEBUGMSG (ZONE_CONN,("Recv channel wFramesPerPkt mismatch! ours=%d, theirs=%d\r\n",pFmtMine->nonstd_params.wFramesPerPktMax,wFramesPerPkt));
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
return CAPS_E_NOMATCH;
|
||
|
||
RESOLVED_EXIT:
|
||
// Match!
|
||
// return ID of the decoding caps that match
|
||
*pFormatID = IndexToId(IDsByRank[i]);
|
||
|
||
pAudioParams->RTP_Payload = pChannelParams->bRTPPayloadType;
|
||
pAudioParams->ns_params.UseSilenceDet = (BYTE)pChannelParams->bSilenceSuppression;
|
||
|
||
DEBUGMSG (ZONE_CONN,("Audio resolved (RECEIVE) to Format Tag: %d\r\n",pFmtMine->wFormatTag));
|
||
|
||
return hrSuccess;
|
||
|
||
}
|
||
|
||
DWORD CMsiaCapability::MinFramesPerPacket(WAVEFORMATEX *pwf)
|
||
{
|
||
UINT sblk, uSize;
|
||
uSize = MinSampleSize(pwf); // this calculates the minimum # of samples
|
||
// that will still fit in an 80 mS frame
|
||
|
||
// calculate samples per block ( aka frame)
|
||
sblk = pwf->nBlockAlign* pwf->nSamplesPerSec/ pwf->nAvgBytesPerSec;
|
||
if(!sblk)
|
||
return 0; // should never happen unless ACM is corrupted,
|
||
// min samples per frame/samples per block = min frames/block.
|
||
return uSize/sblk;
|
||
}
|
||
|
||
|
||
//
|
||
// determine a reasonable maximum number of frames per packet.
|
||
// 4x the Minimum is reasonable, so long as it doesn't make
|
||
// the packet too big
|
||
DWORD CMsiaCapability::MaxFramesPerPacket(WAVEFORMATEX *pwf)
|
||
{
|
||
DWORD dwMin, dwMax;
|
||
|
||
dwMin = MinFramesPerPacket(pwf); // minimum number of frames
|
||
|
||
dwMax = MAX_FRAME_LEN_RECV / (dwMin * pwf->nBlockAlign);
|
||
|
||
dwMax = min((4*dwMin), dwMax*dwMin);
|
||
|
||
if (dwMax < dwMin)
|
||
{
|
||
WARNING_OUT(("CMsiaCapability::MaxFramesPerPacket - Max value computed as less than min. Return Min for Max\r\n"));
|
||
dwMax = dwMin;
|
||
}
|
||
|
||
return dwMax;
|
||
|
||
}
|
||
|
||
//
|
||
// MinSampleSize() taken from datapump.cpp ChoosePacketSize()
|
||
//
|
||
|
||
|
||
// what else depends on it?
|
||
UINT CMsiaCapability::MinSampleSize(WAVEFORMATEX *pwf)
|
||
{
|
||
// calculate default samples per pkt
|
||
UINT spp, sblk;
|
||
spp = m_uPacketDuration * pwf->nSamplesPerSec / 1000;
|
||
// calculate samples per block ( aka frame)
|
||
sblk = pwf->nBlockAlign* pwf->nSamplesPerSec/ pwf->nAvgBytesPerSec;
|
||
if (sblk <= spp) {
|
||
spp = (spp/sblk)*sblk;
|
||
if ( spp*pwf->nAvgBytesPerSec/pwf->nSamplesPerSec > MAX_FRAME_LEN) {
|
||
// packet too big
|
||
spp = (MAX_FRAME_LEN/pwf->nBlockAlign)*sblk;
|
||
}
|
||
} else
|
||
spp = sblk;
|
||
return spp;
|
||
}
|
||
|
||
HRESULT CMsiaCapability::IsFormatEnabled (MEDIA_FORMAT_ID FormatID, PBOOL bRecv, PBOOL bSend)
|
||
{
|
||
UINT uIndex = IDToIndex(FormatID);
|
||
// validate input
|
||
if(uIndex >= (UINT)uNumLocalFormats)
|
||
{
|
||
return CAPS_E_INVALID_PARAM;
|
||
}
|
||
|
||
*bSend=((pLocalFormats + uIndex)->bSendEnabled);
|
||
*bRecv=((pLocalFormats + uIndex)->bRecvEnabled);
|
||
|
||
return hrSuccess;
|
||
|
||
}
|
||
|
||
BOOL CMsiaCapability::IsFormatPublic (MEDIA_FORMAT_ID FormatID)
|
||
{
|
||
UINT uIndex = IDToIndex(FormatID);
|
||
// validate input
|
||
if(uIndex >= (UINT)uNumLocalFormats)
|
||
return FALSE;
|
||
|
||
// test if this is format is a duplicate of a public format
|
||
if((pLocalFormats + uIndex)->dwPublicRefIndex)
|
||
return FALSE; // then we keep this format to ourselves
|
||
else
|
||
return TRUE;
|
||
}
|
||
MEDIA_FORMAT_ID CMsiaCapability::GetPublicID(MEDIA_FORMAT_ID FormatID)
|
||
{
|
||
UINT uIndex = IDToIndex(FormatID);
|
||
// validate input
|
||
if(uIndex >= (UINT)uNumLocalFormats)
|
||
return INVALID_MEDIA_FORMAT;
|
||
|
||
if((pLocalFormats + uIndex)->dwPublicRefIndex)
|
||
{
|
||
return (pLocalFormats + ((pLocalFormats + uIndex)->dwPublicRefIndex))->H245TermCap.CapId;
|
||
}
|
||
else
|
||
{
|
||
return FormatID;
|
||
}
|
||
}
|
||
|
||
#ifdef DEBUG
|
||
VOID DumpWFX(LPWAVEFORMATEX lpwfxLocal, LPWAVEFORMATEX lpwfxRemote)
|
||
{
|
||
FX_ENTRY("DumpWFX");
|
||
ERRORMESSAGE((" -------- %s Begin --------\r\n",_fx_));
|
||
if(lpwfxLocal)
|
||
{
|
||
ERRORMESSAGE((" -------- Local --------\r\n"));
|
||
ERRORMESSAGE(("wFormatTag:\t0x%04X, nChannels:\t0x%04X\r\n",
|
||
lpwfxLocal->wFormatTag, lpwfxLocal->nChannels));
|
||
ERRORMESSAGE(("nSamplesPerSec:\t0x%08lX, nAvgBytesPerSec:\t0x%08lX\r\n",
|
||
lpwfxLocal->nSamplesPerSec, lpwfxLocal->nAvgBytesPerSec));
|
||
ERRORMESSAGE(("nBlockAlign:\t0x%04X, wBitsPerSample:\t0x%04X, cbSize:\t0x%04X\r\n",
|
||
lpwfxLocal->nBlockAlign, lpwfxLocal->wBitsPerSample, lpwfxLocal->cbSize));
|
||
}
|
||
if(lpwfxRemote)
|
||
{
|
||
ERRORMESSAGE((" -------- Remote --------\r\n"));
|
||
ERRORMESSAGE(("wFormatTag:\t0x%04X, nChannels:\t0x%04X\r\n",
|
||
lpwfxRemote->wFormatTag, lpwfxRemote->nChannels));
|
||
ERRORMESSAGE(("nSamplesPerSec:\t0x%08lX, nAvgBytesPerSec:\t0x%08lX\r\n",
|
||
lpwfxRemote->nSamplesPerSec, lpwfxRemote->nAvgBytesPerSec));
|
||
ERRORMESSAGE(("nBlockAlign:\t0x%04X, wBitsPerSample:\t0x%04X, cbSize:\t0x%04X\r\n",
|
||
lpwfxRemote->nBlockAlign, lpwfxRemote->wBitsPerSample, lpwfxRemote->cbSize));
|
||
}
|
||
ERRORMESSAGE((" -------- %s End --------\r\n",_fx_));
|
||
}
|
||
VOID DumpChannelParameters(PCC_TERMCAP pChanCap1, PCC_TERMCAP pChanCap2)
|
||
{
|
||
FX_ENTRY("DumpChannelParameters");
|
||
ERRORMESSAGE((" -------- %s Begin --------\r\n",_fx_));
|
||
if(pChanCap1)
|
||
{
|
||
ERRORMESSAGE((" -------- Local Cap --------\r\n"));
|
||
ERRORMESSAGE(("DataType:%d(d), ClientType:%d(d)\r\n",pChanCap1->DataType,pChanCap1->ClientType));
|
||
ERRORMESSAGE(("Direction:%d(d), CapId:%d(d)\r\n",pChanCap1->Dir,pChanCap1->CapId));
|
||
}
|
||
if(pChanCap2)
|
||
{
|
||
ERRORMESSAGE((" -------- Remote Cap --------\r\n"));
|
||
ERRORMESSAGE(("DataType:%d(d), ClientType:%d(d)\r\n",pChanCap2->DataType,pChanCap2->ClientType));
|
||
ERRORMESSAGE(("Direction:%d(d), CapId:%d(d)\r\n",pChanCap2->Dir,pChanCap2->CapId));
|
||
}
|
||
ERRORMESSAGE((" -------- %s End --------\r\n",_fx_));
|
||
}
|
||
VOID DumpNonstdParameters(PCC_TERMCAP pChanCap1, PCC_TERMCAP pChanCap2)
|
||
{
|
||
FX_ENTRY("DumpNonstdParameters");
|
||
|
||
ERRORMESSAGE((" -------- %s Begin --------\r\n",_fx_));
|
||
DumpChannelParameters(pChanCap1, pChanCap2);
|
||
|
||
if(pChanCap1)
|
||
{
|
||
ERRORMESSAGE((" -------- Local Cap --------\r\n"));
|
||
if(pChanCap1->Cap.H245Aud_NONSTD.nonStandardIdentifier.choice == h221NonStandard_chosen)
|
||
{
|
||
ERRORMESSAGE(("t35CountryCode:%d(d), t35Extension:%d(d)\r\n",
|
||
pChanCap1->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35CountryCode,
|
||
pChanCap1->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35Extension));
|
||
ERRORMESSAGE(("MfrCode:%d(d), data length:%d(d)\r\n",
|
||
pChanCap1->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.manufacturerCode,
|
||
pChanCap1->Cap.H245Aud_NONSTD.data.length));
|
||
}
|
||
else
|
||
{
|
||
ERRORMESSAGE(("unrecognized nonStandardIdentifier.choice: %d(d)\r\n",
|
||
pChanCap1->Cap.H245Aud_NONSTD.nonStandardIdentifier.choice));
|
||
}
|
||
}
|
||
if(pChanCap2)
|
||
{
|
||
ERRORMESSAGE((" -------- Remote Cap --------\r\n"));
|
||
if(pChanCap2->Cap.H245Aud_NONSTD.nonStandardIdentifier.choice == h221NonStandard_chosen)
|
||
{
|
||
ERRORMESSAGE(("t35CountryCode:%d(d), t35Extension:%d(d)\r\n",
|
||
pChanCap2->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35CountryCode,
|
||
pChanCap2->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35Extension));
|
||
ERRORMESSAGE(("MfrCode:%d(d), data length:%d(d)\r\n",
|
||
pChanCap2->Cap.H245Aud_NONSTD.nonStandardIdentifier.u.h221NonStandard.manufacturerCode,
|
||
pChanCap2->Cap.H245Aud_NONSTD.data.length));
|
||
}
|
||
else
|
||
{
|
||
ERRORMESSAGE(("nonStandardIdentifier.choice: %d(d)\r\n",
|
||
pChanCap2->Cap.H245Aud_NONSTD.nonStandardIdentifier.choice));
|
||
}
|
||
}
|
||
ERRORMESSAGE((" -------- %s End --------\r\n",_fx_));
|
||
}
|
||
#endif
|
||
|
||
|
||
|