able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/netmeeting/av/nac/msivcaps.cpp

2727 lines
85 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
* File: msivcaps.cpp
*
* VCM implementation of Microsoft Network Video capability object.
*
* Revision History:
*
* 06/06/96 mikev created msiacaps.cpp
* 07/28/96 philf created (added support for video)
*/
#define _MSIAV_ TRUE
#include "precomp.h"
BOOL GetFormatBuffer();
extern PVCMFORMATDETAILS pvfd_g;
#define PREF_ORDER_UNASSIGNED 0xffff
//External function (in msiacaps.cpp) to read reg info in one shot
#ifdef DEBUG
extern ULONG ReadRegistryFormats (LPCSTR lpszKeyName,CHAR ***pppName,BYTE ***pppData,PUINT pnFormats,DWORD dwDebugSize);
#else
extern ULONG ReadRegistryFormats (LPCSTR lpszKeyName,CHAR ***pppName,BYTE ***pppData,PUINT pnFormats);
#endif
//This can be used as an export, so give it a unique name!
#ifndef _ALPHA_
VIDCAP_DETAILS default_vid_table[] =
{
#ifdef USE_BILINEAR_MSH26X
{VIDEO_FORMAT_MSH263,STD_VID_TERMCAP(H245_CLIENT_VID_H263),STD_VID_PARAMS,{RTP_PAYLOAD_H263,0,30, 24, Small, 128, 96},0,TRUE,TRUE,1,245760*8,245760*8,10,10,5,0,NULL,0,NULL,"Microsoft H.263 Video Codec, vidc.M263, 24bit, 30fps, 128x096"},
{VIDEO_FORMAT_MSH263,STD_VID_TERMCAP(H245_CLIENT_VID_H263),STD_VID_PARAMS,{RTP_PAYLOAD_H263,0,30, 24, Medium, 176, 144},0,TRUE,TRUE,1,245760*8,245760*8,10,10,4,0,NULL,0,NULL,"Microsoft H.263 Video Codec, vidc.M263, 24bit, 30fps, 176x144"},
{VIDEO_FORMAT_MSH263,STD_VID_TERMCAP(H245_CLIENT_VID_H263),STD_VID_PARAMS,{RTP_PAYLOAD_H263,0,30, 24, Large, 352, 288},0,TRUE,TRUE,1,245760*8*4,245760*8*4,10,10,6,0,NULL,0,NULL,"Microsoft H.263 Video Codec, vidc.M263, 24bit, 30fps, 352x288"},
{VIDEO_FORMAT_MSH261,STD_VID_TERMCAP(H245_CLIENT_VID_H261),STD_VID_PARAMS,{RTP_PAYLOAD_H261,0,30, 24, Medium, 176, 144},0,TRUE,TRUE,1,245760*8,245760*8,10,10,7,0,NULL,0,NULL,"Microsoft H.261 Video Codec, vidc.M261, 24bit, 30fps, 176x144"},
{VIDEO_FORMAT_MSH261,STD_VID_TERMCAP(H245_CLIENT_VID_H261),STD_VID_PARAMS,{RTP_PAYLOAD_H261,0,30, 24, Large, 352, 288},0,TRUE,TRUE,1,245760*8*4,245760*8*4,10,10,8,0,NULL,0,NULL,"Microsoft H.261 Video Codec, vidc.M261, 24bit, 30fps, 352x288"},
{VIDEO_FORMAT_MSH26X,NONSTD_VID_TERMCAP,STD_VID_PARAMS,{RTP_DYNAMIC_MIN+1,0,24, Small, 80, 64},0,TRUE,TRUE,1,245760*8,245760*8,10,10,2,0,NULL,0,NULL,"Microsoft H.263 Video Codec, vidc.M26X, 24bit, 30fps, 080x064"},
{VIDEO_FORMAT_MSH26X,NONSTD_VID_TERMCAP,STD_VID_PARAMS,{RTP_DYNAMIC_MIN+1,0,30, 24, Medium, 128, 96},0,TRUE,TRUE,1,245760*8,245760*8,10,10,1,0,NULL,0,NULL,"Microsoft H.263 Video Codec, vidc.M26X, 24bit, 30fps, 128x096"},
{VIDEO_FORMAT_MSH26X,NONSTD_VID_TERMCAP,STD_VID_PARAMS,{RTP_DYNAMIC_MIN+1,0,24, Large, 176, 144},0,TRUE,TRUE,1,245760*8,245760*8,10,10,3,0,NULL,0,NULL,"Microsoft H.263 Video Codec, vidc.M26X, 24bit, 30fps, 176x144"}
#else
{VIDEO_FORMAT_MSH263,STD_VID_TERMCAP(H245_CLIENT_VID_H263),STD_VID_PARAMS,{RTP_PAYLOAD_H263,0,30, 24, Small, 128, 96},0,TRUE,TRUE,1,245760*8,245760*8,10,10,5,0,NULL,0,NULL,"Microsoft H.263 Video Codec, vidc.M263, 24bit, 30fps, 128x096"},
{VIDEO_FORMAT_MSH263,STD_VID_TERMCAP(H245_CLIENT_VID_H263),STD_VID_PARAMS,{RTP_PAYLOAD_H263,0,30, 24, Medium, 176, 144},0,TRUE,TRUE,1,245760*8,245760*8,10,10,2,0,NULL,0,NULL,"Microsoft H.263 Video Codec, vidc.M263, 24bit, 30fps, 176x144"},
{VIDEO_FORMAT_MSH263,STD_VID_TERMCAP(H245_CLIENT_VID_H263),STD_VID_PARAMS,{RTP_PAYLOAD_H263,0,30, 24, Large, 352, 288},0,TRUE,TRUE,1,245760*8*4,245760*8*4,10,10,14,0,NULL,0,NULL,"Microsoft H.263 Video Codec, vidc.M263, 24bit, 30fps, 352x288"},
{VIDEO_FORMAT_MSH261,STD_VID_TERMCAP(H245_CLIENT_VID_H261),STD_VID_PARAMS,{RTP_PAYLOAD_H261,0,30, 24, Medium, 176, 144},0,TRUE,TRUE,1,245760*8,245760*8,10,10,9,0,NULL,0,NULL,"Microsoft H.261 Video Codec, vidc.M261, 24bit, 30fps, 176x144"},
{VIDEO_FORMAT_MSH261,STD_VID_TERMCAP(H245_CLIENT_VID_H261),STD_VID_PARAMS,{RTP_PAYLOAD_H261,0,30, 24, Large, 352, 288},0,TRUE,TRUE,1,245760*8*4,245760*8*4,10,10,20,0,NULL,0,NULL,"Microsoft H.261 Video Codec, vidc.M261, 24bit, 30fps, 352x288"},
#endif
};
#else
VIDCAP_DETAILS default_vid_table[] =
{
{VIDEO_FORMAT_DECH263,STD_VID_TERMCAP(H245_CLIENT_VID_H263),STD_VID_PARAMS,{RTP_PAYLOAD_H263,0,30, 24, Small,128, 96},0,TRUE,TRUE,1,53760,53760,10,10,10,0,0,5,0,NULL,0,NULL, "Digital H263 Video CODEC, vidc.D263, 24bit, 30fps, 128x096"},
{VIDEO_FORMAT_DECH263,STD_VID_TERMCAP(H245_CLIENT_VID_H263),STD_VID_PARAMS,{RTP_PAYLOAD_H263,0,30, 24, Medium,176, 144},0,TRUE,TRUE,1,53760,53760,10,10,10,0,0,2,0,NULL,0,NULL,"Digital H263 Video Codec, vidc.D263, 24bit, 30fps, 176x144"},
{VIDEO_FORMAT_DECH263,STD_VID_TERMCAP(H245_CLIENT_VID_H263),STD_VID_PARAMS,{RTP_PAYLOAD_H263,0,30, 24, Large,352, 288},0,TRUE,TRUE,1,53760,53760,10,10,10,0,0,14,0,NULL,0,NULL,"Digital H263 Video Codec, vidc.D263, 24bit, 30fps, 352x288"},
{VIDEO_FORMAT_DECH261,STD_VID_TERMCAP(H245_CLIENT_VID_H261),STD_VID_PARAMS,{RTP_PAYLOAD_H261,0,30, 24, Medium,176, 144},0,TRUE,TRUE,1,53760,53760,10,10,10,0,0,9,0,NULL,0,NULL,"Digital H261 Video Codec, vidc.D261, 24bit, 30fps, 176x144"},
{VIDEO_FORMAT_DECH261,STD_VID_TERMCAP(H245_CLIENT_VID_H261),STD_VID_PARAMS,{RTP_PAYLOAD_H261,0,30, 24, Large,352, 288},0,TRUE,TRUE,1,53760,53760,10,10,10,0,0,20,0,NULL,0,NULL,"Digital H261 Video Codec, vidc.D261, 24bit, 30fps, 352x288"},
};
#endif
static UINT uDefVidTableEntries = sizeof(default_vid_table) /sizeof(VIDCAP_DETAILS);
static BOOL bCreateDefTable = FALSE;
//
// static members of CMsivCapability
//
MEDIA_FORMAT_ID CMsivCapability::IDsByRank[MAX_CAPS_PRESORT];
UINT CMsivCapability::uNumLocalFormats = 0; // # of active entries in pLocalFormats
UINT CMsivCapability::uStaticRef = 0; // global ref count
UINT CMsivCapability::uCapIDBase = 0; // rebase capability ID to index into IDsByRank
UINT CMsivCapability::uLocalFormatCapacity = 0; // size of pLocalFormats (in multiples of AUDCAP_DETAILS)
VIDCAP_DETAILS * CMsivCapability::pLocalFormats = NULL;
CMsivCapability::CMsivCapability()
:uRef(1),
wMaxCPU(95),
uNumRemoteDecodeFormats(0),
uRemoteDecodeFormatCapacity(0),
pRemoteDecodeFormats(NULL),
bPublicizeTXCaps(FALSE),
bPublicizeTSTradeoff(TRUE)
{
m_IAppVidCap.Init(this);
}
CMsivCapability::~CMsivCapability()
{
UINT u;
VIDCAP_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--;
}
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;
}
}
UINT CMsivCapability::GetNumCaps(BOOL bRXCaps)
{
UINT u, uOut=0;
VIDCAP_DETAILS *pDecodeDetails = pLocalFormats;
if(bRXCaps)
{
for(u=0; u <uNumLocalFormats; u++)
{
if(pDecodeDetails->bRecvEnabled)
uOut++;
pDecodeDetails++;
}
return uOut;
}
else
{
for(u=0; u <uNumLocalFormats; u++)
{
if(pDecodeDetails->bSendEnabled)
uOut++;
pDecodeDetails++;
}
return uOut;
}
}
STDMETHODIMP CMsivCapability::QueryInterface( REFIID iid, void ** ppvObject)
{
HRESULT hr = E_NOINTERFACE;
if(!ppvObject)
return hr;
*ppvObject = 0;
if(iid == IID_IAppVidCap )
{
*ppvObject = (LPAPPVIDCAPPIF)&m_IAppVidCap;
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 CMsivCapability::AddRef()
{
uRef++;
return uRef;
}
ULONG CMsivCapability::Release()
{
uRef--;
if(uRef == 0)
{
delete this;
return 0;
}
return uRef;
}
HRESULT CMsivCapability::GetNumFormats(UINT *puNumFmtOut)
{
*puNumFmtOut = uNumLocalFormats;
return hrSuccess;
}
VOID CMsivCapability::FreeRegistryKeyName(LPTSTR lpszKeyName)
{
if (lpszKeyName)
{
LocalFree(lpszKeyName);
}
}
LPTSTR CMsivCapability::AllocRegistryKeyName(LPTSTR lpDriverName,
UINT uSampleRate, UINT uBitsPerSample, UINT uBitsPerSec,UINT uWidth,UINT uHeight)
{
FX_ENTRY(("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
//Added 2 UINTs for video...
lpszKeyName = (LPTSTR)LocalAlloc (LPTR, lstrlen(lpDriverName) * sizeof(*lpDriverName) +5*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_%u_%u",
lpDriverName,
uSampleRate,
uBitsPerSample,
uBitsPerSec,
uWidth,
uHeight);
return (lpszKeyName);
}
VOID CMsivCapability::SortEncodeCaps(SortMode sortmode)
{
UINT iSorted=0;
UINT iInsert = 0;
UINT iCache=0;
UINT iTemp =0;
BOOL bInsert;
VIDCAP_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++;
}
}
}
BOOL CMsivCapability::Init()
{
BOOL bRet;
if(uStaticRef == 0)
{
if(bRet = ReInit())
{
uStaticRef++;
}
}
else
{
uStaticRef++;
bRet = TRUE;
}
return bRet;
}
BOOL CMsivCapability::ReInit()
{
DWORD dwDisposition;
BOOL bRet = TRUE;
//CVcmCapability::ReInit(); // base class ReInit MUST ALWAYS BE CALLED
SYSTEM_INFO si;
ZeroMemory(&IDsByRank, sizeof(IDsByRank));
// LOOKLOOK - this supports a hack to disable CPU intensive codecs if not running on a pentium
GetSystemInfo(&si);
wMaxCPU = (si.dwProcessorType == PROCESSOR_INTEL_PENTIUM )? 100 : 95;
UINT uNumRemoteDecodeFormats; // # of entries for remote decode capabilities
UINT uRemoteDecodeFormatCapacity; // size of pRemoteDecodeFormats (in multiples of VIDCAP_DETAILS)
if (pLocalFormats)
{
UINT u;
VIDCAP_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;
uLocalFormatCapacity =0;
// m_pAppParam should be non-NULL only if we want to add a VCM format
// and not for standard enumeration
m_pAppParam = NULL;
if(!FormatEnum(this, VCM_FORMATENUMF_APP))
{
bRet = FALSE;
goto RELEASE_AND_EXIT;
}
SortEncodeCaps(SortByAppPref);
RELEASE_AND_EXIT:
return bRet;
}
STDMETHODIMP CMsivCapability::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(VIDEOFORMATEX);
return S_OK;
}
STDMETHODIMP CMsivCapability::GetEncodeFormatDetails(MEDIA_FORMAT_ID FormatID, VOID **ppFormat, UINT *puSize)
{
// same as GetDecodeFormatDetails
return GetDecodeFormatDetails(FormatID, ppFormat, puSize);
}
VOID CMsivCapability::CalculateFormatProperties(VIDCAP_DETAILS *pFmtBuf, PVIDEOFORMATEX lpvfx)
{
if(!pFmtBuf)
{
return;
}
// Estimate input bit rate
UINT uBitrateIn = lpvfx->nSamplesPerSec * WIDTHBYTES(lpvfx->bih.biWidth * lpvfx->bih.biBitCount) * lpvfx->bih.biHeight * 8;
// set the maximum bitrate (uMaxBitrate). we're not setting the average bitrate (uAvgBitrate),
// since the nAvgBytesPerSec reported by VCM is really worst case. uAvgBitrate will be set
// from the hardcoded numbers for our known codecs and from the provided VIDCAP_INFO for
// installable codecs
pFmtBuf->uMaxBitrate = (lpvfx->nAvgBytesPerSec)? lpvfx->nAvgBytesPerSec*8:uBitrateIn;
}
VIDEO_FORMAT_ID CMsivCapability::AddFormat(VIDCAP_DETAILS *pFmtBuf,
LPVOID lpvMappingData, UINT uSize)
{
VIDCAP_DETAILS *pTemp;
VIDEO_PARAMS *pVidCapInfo;
UINT format;
if(!pFmtBuf)
{
return INVALID_VIDEO_FORMAT;
}
// check room
if(uLocalFormatCapacity <= uNumLocalFormats)
{
// get more mem, realloc memory by CAP_CHUNK_SIZE for pLocalFormats
pTemp = (VIDCAP_DETAILS *)MEMALLOC((uNumLocalFormats + CAP_CHUNK_SIZE)*sizeof(VIDCAP_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(("AddFormat:leak! uNumLocalFormats:0x%08lX, pLocalFormats:0x%08lX\r\n", uNumLocalFormats,pLocalFormats));
}
#endif
// copy old stuff, discard old mem
if(uNumLocalFormats && pLocalFormats)
{
memcpy(pTemp, pLocalFormats, uNumLocalFormats*sizeof(VIDCAP_DETAILS));
MEMFREE(pLocalFormats);
}
pLocalFormats = pTemp;
}
// pTemp is where the stuff is cached
pTemp = pLocalFormats+uNumLocalFormats;
memcpy(pTemp, pFmtBuf, sizeof(VIDCAP_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(("AddFormat:allocation failed!\r\n"));
}
#endif
}
else
{
}
// LOOKLOOK NEED TO FIXUP channel parameters
// pTemp->dwDefaultSamples
// pTemp->nonstd_params.wFramesPerPkt
// pTemp->nonstd_params.wFramesPerPktMax
// pTemp->nonstd_params.wFramesPerPktMin
// pTemp->nonstd_params.wDataRate
// pTemp->nonstd_params.wFrameSize
// fixup the H245 parameters. Use the index of the cap entry as the cap ID
pTemp->H245Cap.CapId = (USHORT)IndexToId(uNumLocalFormats);
if(pTemp->H245Cap.ClientType ==0
|| pTemp->H245Cap.ClientType ==H245_CLIENT_VID_NONSTD)
{
pTemp->H245Cap.Cap.H245Vid_NONSTD.nonStandardIdentifier.choice = h221NonStandard_chosen;
// NOTE: there is some question about the correct byte order
// of the codes in the h221NonStandard structure
pTemp->H245Cap.Cap.H245Vid_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35CountryCode = USA_H221_COUNTRY_CODE;
pTemp->H245Cap.Cap.H245Vid_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35Extension = USA_H221_COUNTRY_EXTENSION;
pTemp->H245Cap.Cap.H245Vid_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.
pTemp->H245Cap.Cap.H245Vid_NONSTD.data.length = 0;
pTemp->H245Cap.Cap.H245Vid_NONSTD.data.value = NULL;
}
else
{
switch (pTemp->H245Cap.ClientType )
{
case H245_CLIENT_VID_H263: {
pVidCapInfo=&pTemp->video_params;
format=get_format (pVidCapInfo->biWidth,pVidCapInfo->biHeight);
switch (format) {
case SQCIF: {
pTemp->H245Cap.Cap.H245Vid_H263.bit_mask =H263VideoCapability_sqcifMPI_present;
//MPI minimum interval in units of 1/29.97sec so 30/ (frames/sec) is reasonable
pTemp->H245Cap.Cap.H245Vid_H263.sqcifMPI = 30/pVidCapInfo->uSamplesPerSec;
pTemp->H245Cap.Cap.H245Vid_H263.H263VdCpblty_qcifMPI =0;
pTemp->H245Cap.Cap.H245Vid_H263.H263VdCpblty_cifMPI =0;
break;
}
case QCIF: {
pTemp->H245Cap.Cap.H245Vid_H263.bit_mask =H263VideoCapability_qcifMPI_present;
pTemp->H245Cap.Cap.H245Vid_H263.sqcifMPI = 0;
pTemp->H245Cap.Cap.H245Vid_H263.H263VdCpblty_qcifMPI =30/pVidCapInfo->uSamplesPerSec;
pTemp->H245Cap.Cap.H245Vid_H263.H263VdCpblty_cifMPI =0;
break;
}
case CIF: {
pTemp->H245Cap.Cap.H245Vid_H263.bit_mask =H263VideoCapability_cifMPI_present;
pTemp->H245Cap.Cap.H245Vid_H263.sqcifMPI = 0;
pTemp->H245Cap.Cap.H245Vid_H263.H263VdCpblty_qcifMPI =0;
pTemp->H245Cap.Cap.H245Vid_H263.H263VdCpblty_cifMPI =30/pVidCapInfo->uSamplesPerSec;
break;
}
default:
break;
}
pTemp->H245Cap.Cap.H245Vid_H263.cif4MPI =0;
pTemp->H245Cap.Cap.H245Vid_H263.cif16MPI =0;
pTemp->H245Cap.Cap.H245Vid_H263.maxBitRate = pFmtBuf->uMaxBitrate / 100; // in units of 100 bits/s
pTemp->H245Cap.Cap.H245Vid_H263.unrestrictedVector = FALSE;
pTemp->H245Cap.Cap.H245Vid_H263.arithmeticCoding = FALSE;
pTemp->H245Cap.Cap.H245Vid_H263.advancedPrediction = FALSE;
pTemp->H245Cap.Cap.H245Vid_H263.pbFrames = FALSE;
pTemp->H245Cap.Cap.H245Vid_H263.tmprlSptlTrdOffCpblty = FALSE;
pTemp->H245Cap.Cap.H245Vid_H263.hrd_B = 0;
pTemp->H245Cap.Cap.H245Vid_H263.bppMaxKb = 0;
/* Optional, and not supported pTemp->H245Cap.Cap.H245Vid_H263.slowQcifMPI =0;
pTemp->H245Cap.Cap.H245Vid_H263.slowSqcifMPI =0;
pTemp->H245Cap.Cap.H245Vid_H263.slowCifMPI =0;
pTemp->H245Cap.Cap.H245Vid_H263.slowCif4MPI =0;
pTemp->H245Cap.Cap.H245Vid_H263.slowCif16MPI =0;
*/
pTemp->H245Cap.Cap.H245Vid_H263.H263VCy_errrCmpnstn = TRUE;
break;
}
case H245_CLIENT_VID_H261:
pVidCapInfo=&pTemp->video_params;
format=get_format (pVidCapInfo->biWidth,pVidCapInfo->biHeight);
switch (format) {
case QCIF: {
pTemp->H245Cap.Cap.H245Vid_H261.bit_mask =H261VdCpblty_qcifMPI_present;
pTemp->H245Cap.Cap.H245Vid_H261.H261VdCpblty_qcifMPI =max (1,min (4,30/pVidCapInfo->uSamplesPerSec));
pTemp->H245Cap.Cap.H245Vid_H261.H261VdCpblty_cifMPI =0;
break;
}
case CIF: {
pTemp->H245Cap.Cap.H245Vid_H261.bit_mask =H261VdCpblty_cifMPI_present;
pTemp->H245Cap.Cap.H245Vid_H261.H261VdCpblty_qcifMPI =0;
pTemp->H245Cap.Cap.H245Vid_H261.H261VdCpblty_cifMPI =max (1,min(4,30/pVidCapInfo->uSamplesPerSec));
break;
}
default:
break;
}
pTemp->H245Cap.Cap.H245Vid_H261.maxBitRate = pFmtBuf->uMaxBitrate / 100; // in units of 100 bits/s
pTemp->H245Cap.Cap.H245Vid_H261.tmprlSptlTrdOffCpblty = FALSE;
pTemp->H245Cap.Cap.H245Vid_H261.stillImageTransmission = FALSE;
break;
}
}
uNumLocalFormats++;
return pTemp->H245Cap.CapId;
ERROR_EXIT:
return INVALID_VIDEO_FORMAT;
}
/***************************************************************************
Name : CMsivCapability::BuildFormatName
Purpose : Builds a format name for a format, from the format name and
the tag name
Parameters: pVidcapDetails [out] - pointer to an VIDCAP_DETAILS structure, where the
created value name will be stored
pszDriverName [in] - pointer to the name of the driver
pszFormatName [in] - pointer to name of the format
Returns : BOOL
Comment :
***************************************************************************/
BOOL CMsivCapability::BuildFormatName( PVIDCAP_DETAILS pVidcapDetails,
WCHAR *pszDriverName,
WCHAR *pszFormatName)
{
int iLen, iLen2;
BOOL bRet=TRUE;
char szTemp[260];
if (!pVidcapDetails ||
!pszDriverName ||
!pszFormatName)
{
bRet = FALSE;
goto out;
}
// concatenate VCM strings to form the first part of the registry key - the
// format is szFormatTag (actually pVidcapDetails->szFormat)
// (the string which describes the format tag followed by szFormatDetails
// (the string which describes parameters, e.g. sample rate)
iLen2 = WideCharToMultiByte(GetACP(), 0, pszDriverName, -1, NULL, 0, NULL, NULL);
WideCharToMultiByte(GetACP(), 0, pszDriverName, iLen2, szTemp, iLen2, NULL, NULL);
lstrcpyn(pVidcapDetails->szFormat, szTemp, sizeof(pVidcapDetails->szFormat));
iLen = lstrlen(pVidcapDetails->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 VCM driver writer was misinformed
if(iLen < (sizeof(pVidcapDetails->szFormat) + 8*sizeof(TCHAR)))
{
// ok to concatenate
lstrcat(pVidcapDetails->szFormat,", ");
// must check for truncation. so do the final concatenation via lstrcpyn
// lstrcat(pFormatPrefsBuf->szFormat, pvfd->szFormat);
iLen2 = WideCharToMultiByte(GetACP(), 0, pszFormatName, -1, NULL, 0, NULL, NULL);
WideCharToMultiByte(GetACP(), 0, pszFormatName, iLen2, szTemp, iLen2, NULL, NULL);
iLen = lstrlen(pVidcapDetails->szFormat);
lstrcpyn(pVidcapDetails->szFormat+iLen, szTemp,
sizeof(pVidcapDetails->szFormat) - iLen - sizeof(TCHAR));
}
out:
return bRet;
}
/***************************************************************************
Name : CMsivCapability::GetFormatName
Purpose : Gets a driver and format info from VCM and builds a format name
Parameters: pVidcapDetails [out] - pointer to an VIDCAP_DETAILS structure, where the
created value name will be stored
pvfx [in] - pointer to the VIDEOFORMATEX structure for which we
need the driver name and the format name
Returns : HRESULT
Comment :
***************************************************************************/
HRESULT CMsivCapability::GetFormatName( PVIDCAP_DETAILS pVidcapDetails,
PVIDEOFORMATEX pvfx)
{
VCMDRIVERDETAILS vdd;
VCMFORMATDETAILS vfd;
HRESULT hr=NOERROR;
// get the driver details info in order to build correct format name
vdd.fccHandler = pvfx->dwFormatTag;
if (vcmDriverDetails(&vdd) != MMSYSERR_NOERROR)
{
ERRORMESSAGE(("CMsivCapability::GetFormatName: can't get the driver details\r\n"));
hr = CAPS_E_NOMATCH;
goto out;
}
// have the driver details. get the format details
vfd.pvfx = pvfx;
if (vcmFormatDetails(&vfd) != MMSYSERR_NOERROR)
{
ERRORMESSAGE(("CMsivCapability::GetFormatName: can't get the format details\r\n"));
hr = CAPS_E_NOMATCH;
goto out;
}
// have the format details too. build the name to store in the registry
if (!BuildFormatName(pVidcapDetails, vdd.szDescription, vfd.szFormat))
{
ERRORMESSAGE(("CMsivCapability::GetFormatName: can't build format name\r\n"));
hr = CAPS_E_SYSTEM_ERROR;
goto out;
}
out:
return hr;
}
BOOL CMsivCapability::FormatEnumHandler(HVCMDRIVERID hvdid,
PVCMFORMATDETAILS pvfd, VCMDRIVERDETAILS *pvdd, DWORD_PTR dwInstance)
{
CMsivCapability *pCapObject = (CMsivCapability *)dwInstance;
VIDCAP_DETAILS vidcap_entry;
UINT i;
// evaluate the details
if(IsFormatSpecified(pvfd->pvfx, pvfd, pvdd, &vidcap_entry))
{
DEBUGMSG(ZONE_VCM,("FormatEnumHandler: tag 0x%08X\r\n",
pvfd->pvfx->dwFormatTag));
DEBUGMSG(ZONE_VCM,("FormatEnumHandler: nSamplesPerSec 0x%08lX, nAvgBytesPerSec 0x%08lX,\r\n",
pvfd->pvfx->nSamplesPerSec, pvfd->pvfx->nAvgBytesPerSec));
DEBUGMSG(ZONE_VCM,("FormatEnumHandler: nBlockAlign 0x%08X, wBitsPerSample 0x%04X\r\n",
pvfd->pvfx->nBlockAlign, pvfd->pvfx->wBitsPerSample));
DEBUGMSG(ZONE_VCM,("FormatEnumHandler: szFormat %s,\r\n",
pvfd->szFormat));
// done inside IsFormatSpecified and/or whatever it calls
// CalculateFormatProperties(&audcap_details, pvfd->pvfx);
i=AddFormat(&vidcap_entry, (LPVOID)pvfd->pvfx,
(pvfd->pvfx) ? sizeof(VIDEOFORMATEX):0);
if (i != INVALID_VIDEO_FORMAT) {
//Set the Send/Recv Flags...
//This now needs to set bSendEnabled, and bRecvEnabled, according to pvfd->dwFlags
//So, we need to find the format, and update the flags accordingly.
//OUTPUT IS RECV!!!!
if (pvfd->dwFlags == VCM_FORMATENUMF_BOTH) {
pLocalFormats[i].bSendEnabled=TRUE;
pLocalFormats[i].bRecvEnabled=TRUE;
}else {
if(pvfd->dwFlags == VCM_FORMATENUMF_OUTPUT) {
pLocalFormats[i].bSendEnabled=FALSE;
pLocalFormats[i].bRecvEnabled=TRUE;
} else {
pLocalFormats[i].bSendEnabled=TRUE;
pLocalFormats[i].bRecvEnabled=FALSE;
}
}
}
}
return TRUE;
}
BOOL CMsivCapability::IsFormatSpecified(PVIDEOFORMATEX lpFormat, PVCMFORMATDETAILS pvfd,
VCMDRIVERDETAILS *pvdd, VIDCAP_DETAILS *pVidcapDetails)
{
VIDCAP_DETAILS *pcap_entry;
BOOL bRet = FALSE;
LPTSTR lpszKeyName = NULL;
DWORD dwRes;
UINT i;
if(!lpFormat || !pVidcapDetails)
{
return FALSE;
}
RtlZeroMemory((PVOID) pVidcapDetails, sizeof(VIDCAP_DETAILS));
// fixup the VIDEOFORMAT fields of video_params so that the key name can be built
pVidcapDetails->video_params.uSamplesPerSec = lpFormat->nSamplesPerSec;
pVidcapDetails->video_params.uBitsPerSample = MAKELONG(lpFormat->bih.biBitCount,0);
pVidcapDetails->video_params.biWidth=lpFormat->bih.biWidth;
pVidcapDetails->video_params.biHeight=lpFormat->bih.biHeight;
pVidcapDetails->uMaxBitrate=lpFormat->nAvgBytesPerSec * 8;
// build the name of the format out of the driver and the VCM format name
if ((!pvdd) ||
!BuildFormatName(pVidcapDetails, pvdd->szDescription, pvfd->szFormat))
{
ERRORMESSAGE(("IsFormatSpecified: Coludn't build format name\r\n"));
return(FALSE);
}
lpszKeyName = AllocRegistryKeyName( pVidcapDetails->szFormat,
pVidcapDetails->video_params.uSamplesPerSec,
pVidcapDetails->video_params.uBitsPerSample,
pVidcapDetails->uMaxBitrate,
pVidcapDetails->video_params.biWidth,
pVidcapDetails->video_params.biHeight);
if (!lpszKeyName)
{
ERRORMESSAGE(("IsFormatSpecified: Alloc failed\r\n"));
return(FALSE);
}
RegEntry reVidCaps(szRegInternetPhone TEXT("\\") szRegInternetPhoneVCMEncodings,
HKEY_LOCAL_MACHINE,
FALSE,
KEY_READ);
dwRes = reVidCaps.GetBinary(lpszKeyName, (PVOID *) &pcap_entry);
// use current registry setting if it exists
if(dwRes && (dwRes == sizeof(VIDCAP_DETAILS)))
{
// do a quick sanity check on the contents
if((lpFormat->dwFormatTag == pcap_entry->dwFormatTag)
&& (lpFormat->nSamplesPerSec == (DWORD)pcap_entry->video_params.uSamplesPerSec)
&& (lpFormat->wBitsPerSample == LOWORD(pcap_entry->video_params.uBitsPerSample))
&& (lpFormat->bih.biWidth == (LONG) pcap_entry->video_params.biWidth)
&& (lpFormat->bih.biHeight == (LONG) pcap_entry->video_params.biHeight))
{
CopyMemory(pVidcapDetails, pcap_entry, sizeof(VIDCAP_DETAILS));
bRet = TRUE;
}
}
else // check the static default table, and recreate the default entries
{
for(i=0;i< uDefVidTableEntries; i++)
{
if((lpFormat->dwFormatTag == default_vid_table[i].dwFormatTag)
&& (lpFormat->nSamplesPerSec == (DWORD)default_vid_table[i].video_params.uSamplesPerSec)
&& (lpFormat->wBitsPerSample == LOWORD(default_vid_table[i].video_params.uBitsPerSample))
&& (lpFormat->bih.biWidth == (LONG) default_vid_table[i].video_params.biWidth)
&& (lpFormat->bih.biHeight == (LONG) default_vid_table[i].video_params.biHeight))
{
// found matching default entry - copy stuff from table
// (but don't overwrite the string)
memcpy(pVidcapDetails, &default_vid_table[i],
sizeof(VIDCAP_DETAILS) - sizeof(pVidcapDetails->szFormat));
// LOOKLOOK - test against CPU limitations.
// this supports a hack to disable CPU intensive codecs if not running
//on a pentium
if(default_vid_table[i].wCPUUtilizationEncode > wMaxCPU)
{
pVidcapDetails->bSendEnabled = FALSE;
pVidcapDetails->bRecvEnabled = FALSE;
}
// add this to the registry
CalculateFormatProperties(pVidcapDetails, lpFormat);
bRet = UpdateFormatInRegistry(pVidcapDetails);
break;
}
}
}
if (lpszKeyName)
{
FreeRegistryKeyName(lpszKeyName);
}
return(bRet);
}
/***************************************************************************
Name : CMsivCapability::CopyVidcapInfo
Purpose : Copies basic video info from an VIDCAP_INFO structure to an
VIDCAP_DETAILS structure, or vice versa. VIDCAP_INFO is external
representation. VIDCAP_DETAILS is internal one.
Parameters: pDetails - pointer to an VIDCAP_DETAILS structure
pInfo - pointer to an VIDCAP_INFO structure
bDirection - 0 = ->, 1 = <-
Returns : HRESULT
Comment :
***************************************************************************/
HRESULT CMsivCapability::CopyVidcapInfo(PVIDCAP_DETAILS pDetails,
PVIDCAP_INFO pInfo,
BOOL bDirection)
{
WORD wSortIndex;
VIDEO_FORMAT_ID Id;
UINT uIndex;
HRESULT hr=NOERROR;
if(!pInfo || !pDetails)
{
hr = CAPS_E_INVALID_PARAM;
goto out;
}
if (bDirection)
{
// VIDCAP_INFO -> VIDCAP_DETAILS
// the caller cannot modify szFormat, Id, wSortIndex and uMaxBitrate, all calculated fields
// nAvgBitrate can be provided, but will be overriden if the codec provided a non-zero
// value in the VIDEOFORMATEX structure
pDetails->dwFormatTag = pInfo->dwFormatTag;
pDetails->uAvgBitrate = pInfo->uAvgBitrate;
pDetails->wCPUUtilizationEncode = pInfo->wCPUUtilizationEncode;
pDetails->wCPUUtilizationDecode = pInfo->wCPUUtilizationDecode;
pDetails->bSendEnabled = pInfo->bSendEnabled;
pDetails->bRecvEnabled = pInfo->bRecvEnabled;
pDetails->video_params.enumVideoSize = pInfo->enumVideoSize;
pDetails->video_params.biHeight = pInfo->bih.biHeight;
pDetails->video_params.biWidth = pInfo->bih.biWidth;
// lpLocalFormatDetails is updated in AddFormat
// DO NOT overwrite any of the fields used to construct the regkey name
// pDetails->video_params.uSamplesPerSec = pInfo->uFrameRate;
pDetails->video_params.uBitsPerSample = pInfo->dwBitsPerSample;
//Re-adjust to frame rate. MPI is Interval in units of 1/29.97 seconds
//No div by zero error
pInfo->uFrameRate= max(1,pInfo->uFrameRate);
pDetails->nonstd_params.MPI = 30/pInfo->uFrameRate;
}
else
{
// VIDCAP_DETAILS -> VIDCAP_INFO
PVIDEOFORMATEX pvfx = (PVIDEOFORMATEX) pDetails->lpLocalFormatDetails;
// 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
pInfo->dwFormatTag = pDetails->dwFormatTag;
pInfo->Id = Id;
memcpy(pInfo->szFormat, pDetails->szFormat, sizeof(pInfo->szFormat));
pInfo->wCPUUtilizationEncode = pDetails->wCPUUtilizationEncode;
pInfo->wCPUUtilizationDecode = pDetails->wCPUUtilizationDecode;
pInfo->bSendEnabled = pDetails->bSendEnabled;
pInfo->bRecvEnabled = pDetails->bRecvEnabled;
pInfo->wSortIndex = wSortIndex;
pInfo->enumVideoSize = pDetails->video_params.enumVideoSize;
if (pvfx)
RtlCopyMemory(&pInfo->bih, &pvfx->bih, sizeof(BITMAPINFOHEADER));
//The h.323 nonstd params for bitrate is in units of 100 bits/sec
pInfo->dwBitsPerSample = pDetails->video_params.uBitsPerSample;
pInfo->uAvgBitrate = pDetails->uAvgBitrate;
pInfo->uMaxBitrate = pDetails->nonstd_params.maxBitRate*100;
//Re-adjust to frame rate. MPI is Interval in units of 1/29.97 seconds
//No div by zero error
pDetails->nonstd_params.MPI= max(1,pDetails->nonstd_params.MPI);
pInfo->uFrameRate = min(30,30/pDetails->nonstd_params.MPI);
}
out:
return hr;
}
HRESULT CMsivCapability::EnumCommonFormats(PBASIC_VIDCAP_INFO pFmtBuf, UINT uBufsize,
UINT *uNumFmtOut, BOOL bTXCaps)
{
UINT u, uNumOut = 0;;
HRESULT hr = hrSuccess;
VIDCAP_DETAILS *pDetails = pLocalFormats;
MEDIA_FORMAT_ID FormatIDRemote;
HRESULT hrIsCommon;
// validate input
if(!pFmtBuf || !uNumFmtOut || (uBufsize < (sizeof(BASIC_VIDCAP_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 = CopyVidcapInfo (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 CMsivCapability::EnumFormats(PBASIC_VIDCAP_INFO pFmtBuf, UINT uBufsize,
UINT *uNumFmtOut)
{
UINT u;
HRESULT hr = hrSuccess;
VIDCAP_DETAILS *pDetails = pLocalFormats;
// validate input
if(!pFmtBuf || !uNumFmtOut || (uBufsize < (sizeof(BASIC_VIDCAP_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 = CopyVidcapInfo (pDetails, pFmtBuf, 0);
if(!HR_SUCCEEDED(hr))
goto EXIT;
pFmtBuf++;
}
*uNumFmtOut = min(uNumLocalFormats, MAX_CAPS_PRESORT);
EXIT:
return hr;
}
HRESULT CMsivCapability::GetBasicVidcapInfo (VIDEO_FORMAT_ID Id, PBASIC_VIDCAP_INFO pFormatPrefsBuf)
{
VIDCAP_DETAILS *pFmt;
UINT uIndex = IDToIndex(Id);
if(!pFormatPrefsBuf || (uNumLocalFormats <= uIndex))
{
return CAPS_E_INVALID_PARAM;
}
pFmt = pLocalFormats + uIndex;
return (CopyVidcapInfo(pFmt,pFormatPrefsBuf,0));
}
HRESULT CMsivCapability::ApplyAppFormatPrefs (PBASIC_VIDCAP_INFO pFormatPrefsBuf,
UINT uNumFormatPrefs)
{
FX_ENTRY ("CMsivCapability::ApplyAppFormatPrefs");
UINT u, v;
PBASIC_VIDCAP_INFO pTemp;
VIDCAP_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;
// DO NOT overwrite any of the fields used to construct the regkey name
// pFmt->video_params.uSamplesPerSec = pTemp->uFrameRate;
//Units of 100 bits/sec
pFmt->nonstd_params.maxBitRate= (pTemp->uMaxBitrate/100);
// pFmt->nonstd_params.maxBPP= 0;
pFmt->nonstd_params.MPI= 30/max(pTemp->uFrameRate, 1);
// only the tuning wizard or other profiling app can write wCPUUtilizationEncode,
// wCPUUtilizationDecode, uAvgBitrate
// update the registry
UpdateFormatInRegistry(pFmt);
// now update the sort order contained in VIDsByRank
// 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 VIDsByRank
// 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);
}
}
return hrSuccess;
}
// update the registry
BOOL CMsivCapability::UpdateFormatInRegistry(VIDCAP_DETAILS *pVidcapDetails)
{
FX_ENTRY(("CMsivCapability::UpdateFormatInRegistry"));
LPTSTR lpszKeyName = NULL;
BOOL bRet;
if(!pVidcapDetails)
{
return FALSE;
}
lpszKeyName = AllocRegistryKeyName( pVidcapDetails->szFormat,
pVidcapDetails->video_params.uSamplesPerSec,
pVidcapDetails->video_params.uBitsPerSample,
pVidcapDetails->uMaxBitrate,
pVidcapDetails->video_params.biWidth,
pVidcapDetails->video_params.biHeight);
if (!lpszKeyName)
{
ERRORMESSAGE(("%s:Alloc failed\r\n",_fx_));
return(FALSE);
}
DEBUGMSG(ZONE_VCM,("%s:updating %s, wPref:0x%04x, bS:%d, bR:%d\r\n",
_fx_, lpszKeyName, pVidcapDetails->wApplicationPrefOrder,
pVidcapDetails->bSendEnabled, pVidcapDetails->bRecvEnabled));
// add this to the registry
RegEntry reVidCaps(szRegInternetPhone TEXT("\\") szRegInternetPhoneVCMEncodings,
HKEY_LOCAL_MACHINE);
bRet = (ERROR_SUCCESS == reVidCaps.SetValue(lpszKeyName,
pVidcapDetails,
sizeof(VIDCAP_DETAILS)));
FreeRegistryKeyName(lpszKeyName);
return(bRet);
}
/***************************************************************************
Name : CMsivCapability::AddVCMFormat
Purpose : Adds an VCM format to the list of formats we support
Parameters: pvfx - pointer to the videoformat structure for the added codec
pVidcapInfo - additional format info that is not in the videoformat
structure
Returns : HRESULT
Comment :
***************************************************************************/
HRESULT CMsivCapability::AddVCMFormat (PVIDEOFORMATEX pvfx, PVIDCAP_INFO pVidcapInfo)
{
HRESULT hr = hrSuccess;
// initialize cap entry with default values
VIDCAP_DETAILS cap_entry =
{VIDEO_FORMAT_UNKNOWN, NONSTD_VID_TERMCAP,STD_VID_PARAMS,
{RTP_DYNAMIC_MIN+1, 0, 30, 7680, Small, 0, 0},0,
TRUE, TRUE,
1, // default number of samples per packet
245760*8, // default to 16kbs bitrate
245760*8, // unknown average bitrate
10, 10, // default CPU utilization
PREF_ORDER_UNASSIGNED, // unassigned sort order
0,NULL,0,NULL,
""};
if(!pvfx || !pVidcapInfo)
{
hr = CAPS_E_INVALID_PARAM;
goto out;
}
/*
* Build the VIDCAP_DETAILS structure for this format
*/
// now add VIDCAP_INFO information
CopyVidcapInfo(&cap_entry, pVidcapInfo, 1);
// 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).
CalculateFormatProperties(&cap_entry, pvfx);
// Make sure it's an upper case FourCC
if (cap_entry.dwFormatTag > 256)
CharUpperBuff((LPTSTR)&cap_entry.dwFormatTag, sizeof(DWORD));
// set the RTP payload number. We are using a random number from the dynamic range
// for the installable codecs
cap_entry.video_params.RTPPayload = RTP_DYNAMIC_MIN+1;
// get the format name and driver name for this format from VCM and
// build a format name to add to the registry
hr = GetFormatName(&cap_entry, pvfx);
if (FAILED(hr))
goto out;
// add this to the registry
if(!UpdateFormatInRegistry(&cap_entry))
{
ERRORMESSAGE(("CMsivCapability::AddVCMFormat: can't update registry\r\n"));
hr = CAPS_E_SYSTEM_ERROR;
goto out;
}
// reinit to update the list of local formats
if (!ReInit())
{
hr = CAPS_E_SYSTEM_ERROR;
goto out;
}
out:
return hr;
}
/***************************************************************************
Name : CMsivCapability::RemoveVCMFormat
Purpose : Removes an VCM format to the list of formats we support
Parameters: pvfx - pointer to the videoformat structure for the added codec
Returns : HRESULT
Comment :
***************************************************************************/
HRESULT CMsivCapability::RemoveVCMFormat (PVIDEOFORMATEX pvfx)
{
HRESULT hr = hrSuccess;
HKEY hKey = NULL;
LPTSTR lpszValueName = NULL;
DWORD dwErr;
VIDCAP_DETAILS cap_entry;
if(!pvfx)
{
return CAPS_E_INVALID_PARAM;
}
// get the format name and driver name for this format from VCM and
// build a format name to add to the registry
hr = GetFormatName(&cap_entry, pvfx);
if (FAILED(hr))
goto out;
lpszValueName = AllocRegistryKeyName(cap_entry.szFormat,
pvfx->nSamplesPerSec,
MAKELONG(pvfx->wBitsPerSample,0),
pvfx->nAvgBytesPerSec*8,
pvfx->bih.biWidth,
pvfx->bih.biHeight);
if (!lpszValueName)
{
ERRORMESSAGE(("CMsivCapability::RemoveVCMFormat: Alloc failed\r\n"));
hr = CAPS_E_SYSTEM_ERROR;
goto out;
}
// Get the key handle
if (dwErr = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
szRegInternetPhone TEXT("\\") szRegInternetPhoneVCMEncodings,
0, KEY_ALL_ACCESS, &hKey))
{
ERRORMESSAGE(("CMsivCapability::RemoveVCMFormat: 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;
}
// 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;
}
UINT CMsivCapability::GetLocalSendParamSize(MEDIA_FORMAT_ID dwID)
{
return (sizeof(VIDEO_CHANNEL_PARAMETERS));
}
UINT CMsivCapability::GetLocalRecvParamSize(PCC_TERMCAP pCapability)
{
return (sizeof(VIDEO_CHANNEL_PARAMETERS));
}
HRESULT CMsivCapability::CreateCapList(LPVOID *ppCapBuf)
{
HRESULT hr = hrSuccess;
UINT u;
VIDCAP_DETAILS *pDecodeDetails = pLocalFormats;
PCC_TERMCAPLIST pTermCapList = NULL;
PPCC_TERMCAP ppCCThisTermCap = NULL;
PCC_TERMCAP pCCThisCap = NULL;
PNSC_VIDEO_CAPABILITY pNSCapNext;
PVIDEOFORMATEX lpvcd;
VIDEO_PARAMS *pVidCapInfo;
UINT format;
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->H245Cap.ClientType ==0
|| pDecodeDetails->H245Cap.ClientType ==H245_CLIENT_VID_NONSTD)
{
lpvcd = (PVIDEOFORMATEX)pDecodeDetails->lpLocalFormatDetails;
if(!lpvcd)
{
pDecodeDetails++;
continue;
}
// allocate for this one capability
pCCThisCap = (PCC_TERMCAP)MemAlloc(sizeof(CC_TERMCAP));
pNSCapNext = (PNSC_VIDEO_CAPABILITY)MemAlloc(sizeof(NSC_VIDEO_CAPABILITY));
if((!pCCThisCap)|| (!pNSCapNext))
{
hr = CAPS_E_NOMEM;
goto ERROR_OUT;
}
// set type of nonstandard capability
pNSCapNext->cvp_type = NSC_VCM_VIDEOFORMATEX;
// stuff both chunks of nonstandard capability info into buffer
// first stuff the "channel parameters" (the format independent communication options)
memcpy(&pNSCapNext->cvp_params, &pDecodeDetails->nonstd_params, sizeof(NSC_CHANNEL_VIDEO_PARAMETERS));
// then the VCM stuff
memcpy(&pNSCapNext->cvp_data.vfx, lpvcd, sizeof(VIDEOFORMATEX));
pCCThisCap->ClientType = H245_CLIENT_VID_NONSTD;
pCCThisCap->DataType = H245_DATA_VIDEO;
pCCThisCap->Dir = (pDecodeDetails->bSendEnabled && bPublicizeTXCaps)
? H245_CAPDIR_LCLRXTX :H245_CAPDIR_LCLRX;
// LOOKLOOK use the index of the cap entry as the ID
// The ID is already preset in local formats by AddCapabilityBase()
// pCCThisCap->CapId = (USHORT)IndexToId(u);
pCCThisCap->CapId = pDecodeDetails->H245Cap.CapId;
// all nonstandard identifier fields are unsigned short
// two possibilities for choice are "h221NonStandard_chosen" and "object_chosen"
pCCThisCap->Cap.H245Vid_NONSTD.nonStandardIdentifier.choice = h221NonStandard_chosen;
// NOTE: there is some question about the correct byte order
// of the codes in the h221NonStandard structure
pCCThisCap->Cap.H245Vid_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35CountryCode = USA_H221_COUNTRY_CODE;
pCCThisCap->Cap.H245Vid_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35Extension = USA_H221_COUNTRY_EXTENSION;
pCCThisCap->Cap.H245Vid_NONSTD.nonStandardIdentifier.u.h221NonStandard.manufacturerCode = MICROSOFT_H_221_MFG_CODE;
// set size of buffer
pCCThisCap->Cap.H245Vid_NONSTD.data.length = sizeof(NSC_VIDEO_CAPABILITY) - BMIH_SLOP_BYTES;
pCCThisCap->Cap.H245Vid_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->H245Cap.ClientType;
pCCThisCap->DataType = H245_DATA_VIDEO;
pCCThisCap->Dir = H245_CAPDIR_LCLRX; // should this be H245_CAPDIR_LCLRX for receive caps?
pCCThisCap->CapId = pDecodeDetails->H245Cap.CapId;
pVidCapInfo=&pDecodeDetails->video_params;
switch (pCCThisCap->ClientType )
{
case H245_CLIENT_VID_H263:
#pragma message ("Collapse H.263 formats")
// refer to the hack that sets H245Vid_H263 parameters
// when formats are enumerated. if that was always done right, then
// all that needs to happen here is collapsing
// This is where the formats need to collapse. H.263 probably
// should not be collapsed into 1 format. Given M specific local
// formats, collapse into N.
format=get_format (pVidCapInfo->biWidth,pVidCapInfo->biHeight);
switch (format) {
case SQCIF: {
pCCThisCap->Cap.H245Vid_H263.bit_mask =H263VideoCapability_sqcifMPI_present;
//MPI minimum interval in units of 1/29.97sec so 30/ (frames/sec) is reasonable
pCCThisCap->Cap.H245Vid_H263.sqcifMPI = max (1,pDecodeDetails->nonstd_params.MPI); //30/pVidCapInfo->uSamplesPerSec;
pCCThisCap->Cap.H245Vid_H263.H263VdCpblty_qcifMPI =0;
pCCThisCap->Cap.H245Vid_H263.H263VdCpblty_cifMPI =0;
break;
}
case QCIF: {
pCCThisCap->Cap.H245Vid_H263.bit_mask =H263VideoCapability_qcifMPI_present;
pCCThisCap->Cap.H245Vid_H263.sqcifMPI = 0;
pCCThisCap->Cap.H245Vid_H263.H263VdCpblty_qcifMPI =max (1,pDecodeDetails->nonstd_params.MPI);//30/pVidCapInfo->uSamplesPerSec; ;;
pCCThisCap->Cap.H245Vid_H263.H263VdCpblty_cifMPI =0;
break;
}
case CIF: {
pCCThisCap->Cap.H245Vid_H263.bit_mask =H263VideoCapability_cifMPI_present;
pCCThisCap->Cap.H245Vid_H263.sqcifMPI = 0;
pCCThisCap->Cap.H245Vid_H263.H263VdCpblty_qcifMPI =0;
pCCThisCap->Cap.H245Vid_H263.H263VdCpblty_cifMPI = max (1,pDecodeDetails->nonstd_params.MPI);//30/pVidCapInfo->uSamplesPerSec;
break;
}
default:
break;
}
pCCThisCap->Cap.H245Vid_H263.cif4MPI =0;
pCCThisCap->Cap.H245Vid_H263.cif16MPI =0;
pCCThisCap->Cap.H245Vid_H263.maxBitRate =
pDecodeDetails->nonstd_params.maxBitRate;
pCCThisCap->Cap.H245Vid_H263.unrestrictedVector = FALSE;
pCCThisCap->Cap.H245Vid_H263.arithmeticCoding = FALSE;
pCCThisCap->Cap.H245Vid_H263.advancedPrediction = FALSE;
pCCThisCap->Cap.H245Vid_H263.pbFrames = FALSE;
pCCThisCap->Cap.H245Vid_H263.tmprlSptlTrdOffCpblty = (ASN1bool_t)bPublicizeTSTradeoff;
pCCThisCap->Cap.H245Vid_H263.hrd_B = 0;
pCCThisCap->Cap.H245Vid_H263.bppMaxKb =
pDecodeDetails->nonstd_params.maxBPP;
/* Optional, and not supported pCCThisCap->Cap.H245Vid_H263.slowQcifMPI =0;
pCCThisCap->Cap.H245Vid_H263.slowSqcifMPI =0;
pCCThisCap->Cap.H245Vid_H263.slowCifMPI =0;
pCCThisCap->Cap.H245Vid_H263.slowCif4MPI =0;
pCCThisCap->Cap.H245Vid_H263.slowCif16MPI =0;
*/
pCCThisCap->Cap.H245Vid_H263.H263VCy_errrCmpnstn = TRUE;
break;
case H245_CLIENT_VID_H261:
#pragma message ("Collapse H.261 formats")
// refer to the hack that sets H245Vid_H261 parameters
// when formats are enumerated. if that was always done right, then
// all that needs to happen here is collapsing
// This is where the formats need to collapse. H.261 probably
// should not be collapsed into 1 format. Given M specific local
// formats, collapse into N.
format=get_format (pVidCapInfo->biWidth,pVidCapInfo->biHeight);
switch (format) {
case QCIF: {
pCCThisCap->Cap.H245Vid_H261.bit_mask =H261VdCpblty_qcifMPI_present;
pCCThisCap->Cap.H245Vid_H261.H261VdCpblty_qcifMPI =max (1,min(4,pDecodeDetails->nonstd_params.MPI));//30/pVidCapInfo->uSamplesPerSec; ;;
pCCThisCap->Cap.H245Vid_H261.H261VdCpblty_cifMPI =0;
break;
}
case CIF: {
pCCThisCap->Cap.H245Vid_H261.bit_mask =H261VdCpblty_cifMPI_present;
pCCThisCap->Cap.H245Vid_H261.H261VdCpblty_qcifMPI =0;
pCCThisCap->Cap.H245Vid_H261.H261VdCpblty_cifMPI =max (1,min(4,pDecodeDetails->nonstd_params.MPI));//30/pVidCapInfo->uSamplesPerSec;
break;
}
default:
break;
}
pCCThisCap->Cap.H245Vid_H261.maxBitRate = (ASN1uint16_t)pDecodeDetails->nonstd_params.maxBitRate;
pCCThisCap->Cap.H245Vid_H261.tmprlSptlTrdOffCpblty = (ASN1bool_t)bPublicizeTSTradeoff;
pCCThisCap->Cap.H245Vid_H261.stillImageTransmission = FALSE;
break;
default:
case H245_CLIENT_VID_NONSTD:
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 CMsivCapability::DeleteCapList(LPVOID pCapBuf)
{
UINT u;
PCC_TERMCAPLIST pTermCapList = (PCC_TERMCAPLIST)pCapBuf;
PCC_TERMCAP pCCThisCap;
PNSC_VIDEO_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_VID_NONSTD)
{
if(pCCThisCap->Cap.H245Vid_NONSTD.data.value)
{
MemFree(pCCThisCap->Cap.H245Vid_NONSTD.data.value);
}
}
MemFree(pCCThisCap);
}
}
MemFree(pTermCapList->pTermCapArray);
}
MemFree(pTermCapList);
return hrSuccess;
}
BOOL CMsivCapability::IsCapabilityRecognized(PCC_TERMCAP pCCThisCap)
{
FX_ENTRY ("CMsivCapability::IsCapabilityRecognized");
if(pCCThisCap->DataType != H245_DATA_VIDEO)
return FALSE;
if(pCCThisCap->ClientType == H245_CLIENT_VID_NONSTD)
{
// do we recognize this?
if(pCCThisCap->Cap.H245Vid_NONSTD.nonStandardIdentifier.choice == h221NonStandard_chosen)
{
if((pCCThisCap->Cap.H245Vid_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35CountryCode == USA_H221_COUNTRY_CODE)
&& (pCCThisCap->Cap.H245Vid_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35Extension == USA_H221_COUNTRY_EXTENSION)
&& (pCCThisCap->Cap.H245Vid_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 , PCC_TERMCAP );
DumpNonstdParameters(NULL, pCCThisCap);
#endif
return FALSE;
}
}
}
return TRUE;
}
// the intent is to keep a copy of the channel parameters used to open a send channel
// that the remote end can decode.
VIDEO_FORMAT_ID CMsivCapability::AddRemoteDecodeFormat(PCC_TERMCAP pCCThisCap)
{
FX_ENTRY ("CMsivCapability::AddRemoteDecodeFormat");
VIDCAP_DETAILS vidcapdetails =
{VIDEO_FORMAT_UNKNOWN,NONSTD_VID_TERMCAP, STD_VID_PARAMS,
{RTP_DYNAMIC_MIN+1, 0, 30, 7680, Small, 0, 0},0,
TRUE, TRUE, 1, 245760*8,245760*8,10,10,0,0,NULL,0,NULL,""};
VIDCAP_DETAILS *pTemp;
LPVOID lpData = NULL;
UINT uSize = 0;
if(!pCCThisCap)
{
return INVALID_VIDEO_FORMAT;
}
// check room
if(uRemoteDecodeFormatCapacity <= uNumRemoteDecodeFormats)
{
// get more mem, realloc memory by CAP_CHUNK_SIZE for pRemoteDecodeFormats
pTemp = (VIDCAP_DETAILS *)MEMALLOC((uNumRemoteDecodeFormats + CAP_CHUNK_SIZE)*sizeof(VIDCAP_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, &vidcapdetails, sizeof(VIDCAP_DETAILS));
// next, the H245 parameters
memcpy(&pTemp->H245Cap, pCCThisCap, sizeof(pTemp->H245Cap));
// Note: if nonstandard data exists, the nonstd pointers need to be fixed up
if(pCCThisCap->ClientType == H245_CLIENT_VID_NONSTD)
{
// do we recognize this?
if(pCCThisCap->Cap.H245Vid_NONSTD.nonStandardIdentifier.choice == h221NonStandard_chosen)
{
if((pCCThisCap->Cap.H245Vid_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35CountryCode == USA_H221_COUNTRY_CODE)
&& (pCCThisCap->Cap.H245Vid_NONSTD.nonStandardIdentifier.u.h221NonStandard.t35Extension == USA_H221_COUNTRY_EXTENSION)
&& (pCCThisCap->Cap.H245Vid_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.H245Vid_NONSTD.data.length;
lpData = pCCThisCap->Cap.H245Vid_NONSTD.data.value;
}
}
}
// this is not really necessary to set RTP payload type of what is received - it should
// be obvious.
else if (pCCThisCap->ClientType == H245_CLIENT_VID_H263 )
{
pTemp->video_params.RTPPayload = RTP_PAYLOAD_H263;
}
else if(pCCThisCap->ClientType == H245_CLIENT_VID_H261)
{
pTemp->video_params.RTPPayload = RTP_PAYLOAD_H261;
}
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->H245Cap.Cap.H245Vid_NONSTD.data.length = uSize;
pTemp->H245Cap.Cap.H245Vid_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_VIDEO_FORMAT;
}
VOID CMsivCapability::FlushRemoteCaps()
{
if(pRemoteDecodeFormats)
{
MEMFREE(pRemoteDecodeFormats);
pRemoteDecodeFormats = NULL;
uNumRemoteDecodeFormats = 0;
uRemoteDecodeFormatCapacity = 0;
}
}
HRESULT CMsivCapability::AddRemoteDecodeCaps(PCC_TERMCAPLIST pTermCapList)
{
FX_ENTRY ("CMsivCapability::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 addded 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 CMsivCapability::GetPublicDecodeParams(LPVOID pBufOut, UINT uBufSize, VIDEO_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));
return hrSuccess;
}
HRESULT CMsivCapability::SetAudioPacketDuration(UINT uPacketDuration)
{
return CAPS_E_INVALID_PARAM;
}
// 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 CMsivCapability::GetEncodeParams(LPVOID pBufOut, UINT uBufSize,LPVOID pLocalParams, UINT uSizeLocal,
VIDEO_FORMAT_ID idRemote, VIDEO_FORMAT_ID idLocal)
{
UINT uLocalIndex = IDToIndex(idLocal);
VIDCAP_DETAILS *pLocalDetails = pLocalFormats + uLocalIndex;
VIDCAP_DETAILS *pFmtTheirs;
VIDEO_CHANNEL_PARAMETERS local_params;
UINT u;
PCC_TERMCAP pTermCap = (PCC_TERMCAP)pBufOut;
// validate input
// AddCapabilityBase adds to the ID below. Make sure we're checking Video Formats
if(!pBufOut)
{
return CAPS_E_INVALID_PARAM;
}
if(uBufSize < sizeof(CC_TERMCAP))
{
return CAPS_E_BUFFER_TOO_SMALL;
}
if(!pLocalParams|| uSizeLocal < sizeof(VIDEO_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->H245Cap.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));
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 :
#pragma message ("Are H.26? variable parameter formats?")
// H245_CAP_H261 H245Vid_H261;
// H245_CAP_H263 H245Vid_H263;
// and of course all nonstandard formats
// Select parameters based on local capability info
if(pTermCap->ClientType == H245_CLIENT_VID_H263)
{
unsigned short bit_mask;
// select frames per packet based on minimum latency value that is acceptable
#define H263_QCIF 0x4000
#define H263_MAXBP 0x0200
//H263_QCIF | H263_MAXBP;
pTermCap->Cap.H245Vid_H263.bit_mask= H263_MAXBP | pLocalDetails->H245Cap.Cap.H245Vid_H263.bit_mask;
local_params.ns_params.maxBitRate = pTermCap->Cap.H245Vid_H263.maxBitRate
= min (pLocalDetails->nonstd_params.maxBitRate , pFmtTheirs->H245Cap.Cap.H245Vid_H263.maxBitRate);
local_params.ns_params.maxBPP = pTermCap->Cap.H245Vid_H263.bppMaxKb
= min (pLocalDetails->nonstd_params.maxBPP, pFmtTheirs->H245Cap.Cap.H245Vid_H263.bppMaxKb);
// we (the local end) need to know that actual MPI is going to be used!
// like everywhere else in this module, the assumption is that local H.263 capabilities are
// fanned out with one local cap entry per frame size.
// MPI minimum interval in units of 1/29.97sec so take the longest interval
// there is no pretty way to do this
bit_mask = pLocalDetails->H245Cap.Cap.H245Vid_H263.bit_mask;
if(bit_mask & H263VideoCapability_sqcifMPI_present)
{
local_params.ns_params.MPI = pTermCap->Cap.H245Vid_H263.sqcifMPI =
max(pLocalDetails->nonstd_params.MPI,
pTermCap->Cap.H245Vid_H263.sqcifMPI);
}
else if (bit_mask & H263VideoCapability_qcifMPI_present)
{
local_params.ns_params.MPI = pTermCap->Cap.H245Vid_H263.H263VdCpblty_qcifMPI =
max(pLocalDetails->nonstd_params.MPI,
pTermCap->Cap.H245Vid_H263.H263VdCpblty_qcifMPI);
}
else if (bit_mask & H263VideoCapability_cifMPI_present)
{
local_params.ns_params.MPI = pTermCap->Cap.H245Vid_H263.H263VdCpblty_cifMPI =
max(pLocalDetails->nonstd_params.MPI,
pTermCap->Cap.H245Vid_H263.H263VdCpblty_cifMPI);
}
else if (bit_mask & H263VideoCapability_cif4MPI_present)
{
local_params.ns_params.MPI = pTermCap->Cap.H245Vid_H263.cif4MPI =
max(pLocalDetails->H245Cap.Cap.H245Vid_H263.cif4MPI,
pTermCap->Cap.H245Vid_H263.cif4MPI);
}
else if (bit_mask & H263VideoCapability_cif16MPI_present)
{
local_params.ns_params.MPI = pTermCap->Cap.H245Vid_H263.cif16MPI =
max(pLocalDetails->nonstd_params.MPI,
pTermCap->Cap.H245Vid_H263.cif16MPI);
}
// else // impossible. Doom, as MikeG and JonT would say
}
else if(pTermCap->ClientType == H245_CLIENT_VID_H261)
{
unsigned short bit_mask;
// select frames per packet based on minimum latency value that is acceptable
pTermCap->Cap.H245Vid_H261.bit_mask= pLocalDetails->H245Cap.Cap.H245Vid_H261.bit_mask;
local_params.ns_params.maxBitRate = pTermCap->Cap.H245Vid_H261.maxBitRate
= min (pLocalDetails->nonstd_params.maxBitRate , pFmtTheirs->H245Cap.Cap.H245Vid_H261.maxBitRate);
// we (the local end) need to know that actual MPI is going to be used!
// like everywhere else in this module, the assumption is that local H.261 capabilities are
// fanned out with one local cap entry per frame size.
// MPI minimum interval in units of 1/29.97sec so take the longest interval
// there is no pretty way to do this
bit_mask = pLocalDetails->H245Cap.Cap.H245Vid_H261.bit_mask;
if (bit_mask & H261VdCpblty_qcifMPI_present)
{
local_params.ns_params.MPI = pTermCap->Cap.H245Vid_H261.H261VdCpblty_qcifMPI =
max(pLocalDetails->nonstd_params.MPI,
pTermCap->Cap.H245Vid_H261.H261VdCpblty_qcifMPI);
}
else if (bit_mask & H261VdCpblty_cifMPI_present)
{
local_params.ns_params.MPI = pTermCap->Cap.H245Vid_H261.H261VdCpblty_cifMPI =
max(pLocalDetails->nonstd_params.MPI,
pTermCap->Cap.H245Vid_H261.H261VdCpblty_cifMPI);
}
// else // impossible. Doom, as MikeG and JonT would say
}
else if (pTermCap->ClientType == H245_CLIENT_VID_NONSTD)
{
// NOT YET IMPLEMENTED!!!!. even the nonstandard parameters need to be fixed
// up here based on mutual maxes and mins
memcpy(&local_params.ns_params, &pLocalDetails->nonstd_params,
sizeof(NSC_CHANNEL_VIDEO_PARAMETERS));
}
local_params.RTP_Payload = pLocalDetails->video_params.RTPPayload;
//Fixup local
memcpy(pLocalParams, &local_params, sizeof(VIDEO_CHANNEL_PARAMETERS));
return hrSuccess;
ERROR_EXIT:
return CAPS_E_INVALID_PARAM;
}
BOOL NonStandardCapsCompareV(VIDCAP_DETAILS *pFmtMine, PNSC_VIDEO_CAPABILITY pCap2,
UINT uSize2)
{
PVIDEOFORMATEX lpvcd;
if(!pFmtMine || !pCap2)
return FALSE;
if(!(lpvcd = (PVIDEOFORMATEX)pFmtMine->lpLocalFormatDetails))
return FALSE;
if(pCap2->cvp_type == NSC_VCM_VIDEOFORMATEX)
{
// check sizes first
if(lpvcd->bih.biSize != pCap2->cvp_data.vfx.bih.biSize)
{
return FALSE;
}
// compare structures, including extra bytes
if(memcmp(lpvcd, &pCap2->cvp_data.vfx,
sizeof(VIDEOFORMATEX) - BMIH_SLOP_BYTES)==0)
{
return TRUE;
}
}
else if(pCap2->cvp_type == NSC_VCMABBREV)
{
if((LOWORD(pCap2->cvp_data.vcm_brief.dwFormatTag) == lpvcd->dwFormatTag)
&& (pCap2->cvp_data.vcm_brief.dwSamplesPerSec == lpvcd->nSamplesPerSec)
&& (LOWORD(pCap2->cvp_data.vcm_brief.dwBitsPerSample) == lpvcd->wBitsPerSample))
{
return TRUE;
}
}
return FALSE;
}
BOOL HasNonStandardCapsTS(VIDCAP_DETAILS *pFmtMine, PNSC_VIDEO_CAPABILITY pCap2)
{
PVIDEOFORMATEX lpvcd;
if(!pFmtMine || !pCap2)
return FALSE;
if(!(lpvcd = (PVIDEOFORMATEX)pFmtMine->lpLocalFormatDetails))
return FALSE;
if(pCap2->cvp_type == NSC_VCM_VIDEOFORMATEX)
if(lpvcd->dwSupportTSTradeOff && pCap2->cvp_data.vfx.dwSupportTSTradeOff)
return TRUE;
return FALSE;
}
HRESULT CMsivCapability::ResolveToLocalFormat(MEDIA_FORMAT_ID FormatIDLocal,
MEDIA_FORMAT_ID * pFormatIDRemote)
{
VIDCAP_DETAILS *pFmtLocal;
VIDCAP_DETAILS *pFmtRemote;
UINT format_mask;
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->H245Cap.ClientType == pFmtRemote->H245Cap.ClientType)
{
// if this is a nonstandard cap, compare nonstandard parameters
if(pFmtLocal->H245Cap.ClientType == H245_CLIENT_VID_NONSTD)
{
if(NonStandardCapsCompareV(pFmtLocal,
(PNSC_VIDEO_CAPABILITY)pFmtRemote->H245Cap.Cap.H245Vid_NONSTD.data.value,
pFmtRemote->H245Cap.Cap.H245Vid_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
if (pFmtLocal->H245Cap.ClientType == H245_CLIENT_VID_H263)
{
format_mask= H263VideoCapability_sqcifMPI_present
| H263VideoCapability_qcifMPI_present | H263VideoCapability_cifMPI_present
| H263VideoCapability_cif4MPI_present | H263VideoCapability_cif16MPI_present;
if ((pFmtRemote->H245Cap.Cap.H245Vid_H263.bit_mask & format_mask) & (pFmtLocal->H245Cap.Cap.H245Vid_H263.bit_mask & format_mask))
{
// compatible basic format
goto RESOLVED_EXIT;
}
}
else if (pFmtLocal->H245Cap.ClientType == H245_CLIENT_VID_H261)
{
format_mask= H261VdCpblty_qcifMPI_present | H261VdCpblty_cifMPI_present;
if ((pFmtRemote->H245Cap.Cap.H245Vid_H261.bit_mask & format_mask) & (pFmtLocal->H245Cap.Cap.H245Vid_H261.bit_mask & format_mask))
{
// compatible basic format
goto RESOLVED_EXIT;
}
}
else
{
//Some other standard format
goto RESOLVED_EXIT;
}
}
}
pFmtRemote++; // next entry in remote caps
}
return CAPS_E_NOMATCH;
RESOLVED_EXIT:
// Match!
// return ID of remote decoding (receive fmt) caps that match our
// send caps
*pFormatIDRemote = pFmtRemote->H245Cap.CapId;
return hrSuccess;
}
// resolve using currently cached local and remote formats
HRESULT CMsivCapability::ResolveEncodeFormat(
VIDEO_FORMAT_ID *pIDEncodeOut,
VIDEO_FORMAT_ID *pIDRemoteDecode)
{
UINT i,j=0,format_mask;
VIDCAP_DETAILS *pFmtMine = pLocalFormats;
VIDCAP_DETAILS *pFmtTheirs;
if(!pIDEncodeOut || !pIDRemoteDecode)
{
return CAPS_E_INVALID_PARAM;
}
if(!uNumLocalFormats || !pLocalFormats)
{
*pIDEncodeOut = *pIDRemoteDecode = INVALID_VIDEO_FORMAT;
return CAPS_E_NOCAPS;
}
if(!pRemoteDecodeFormats || !uNumRemoteDecodeFormats)
{
*pIDEncodeOut = *pIDRemoteDecode = INVALID_VIDEO_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]].H245Cap.CapId == *pIDEncodeOut)
{
j=i+1;
break;
}
}
}
// start at index j
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->H245Cap.ClientType == pFmtTheirs->H245Cap.ClientType)
{
// if this is a nonstandard cap, compare nonstandard parameters
if(pFmtMine->H245Cap.ClientType == H245_CLIENT_VID_NONSTD)
{
if(NonStandardCapsCompareV(pFmtMine,
(PNSC_VIDEO_CAPABILITY)pFmtTheirs->H245Cap.Cap.H245Vid_NONSTD.data.value,
pFmtTheirs->H245Cap.Cap.H245Vid_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
if (pFmtMine->H245Cap.ClientType == H245_CLIENT_VID_H263)
{
format_mask= H263VideoCapability_sqcifMPI_present| H263VideoCapability_qcifMPI_present
|H263VdCpblty_cifMPI_present
|H263VideoCapability_cif4MPI_present
|H263VideoCapability_cif16MPI_present;
if ((pFmtTheirs->H245Cap.Cap.H245Vid_H263.bit_mask & format_mask) & (pFmtMine->H245Cap.Cap.H245Vid_H263.bit_mask & format_mask))
{
// compatible basic format
goto RESOLVED_EXIT;
}
}
else if (pFmtMine->H245Cap.ClientType == H245_CLIENT_VID_H261)
{
format_mask= H261VdCpblty_qcifMPI_present | H261VdCpblty_cifMPI_present;
if ((pFmtTheirs->H245Cap.Cap.H245Vid_H261.bit_mask & format_mask) & (pFmtMine->H245Cap.Cap.H245Vid_H261.bit_mask & format_mask))
{
// compatible basic format
goto RESOLVED_EXIT;
}
} else {
//Some other standard format
goto RESOLVED_EXIT;
}
}
}
pFmtTheirs++; // next entry in receiver's caps
}
}
return CAPS_E_NOMATCH;
RESOLVED_EXIT:
// Match!
// return ID of our encoding (sending fmt) caps that match
*pIDEncodeOut = pFmtMine->H245Cap.CapId;
// return ID of remote decoding (receive fmt) caps that match our
// send caps
*pIDRemoteDecode = pFmtTheirs->H245Cap.CapId;
return hrSuccess;
}
HRESULT CMsivCapability::GetDecodeParams(PCC_RX_CHANNEL_REQUEST_CALLBACK_PARAMS pChannelParams,
VIDEO_FORMAT_ID * pFormatID, LPVOID lpvBuf, UINT uBufSize)
{
UINT i,j=0;
VIDCAP_DETAILS *pFmtMine = pLocalFormats;
VIDCAP_DETAILS *pFmtTheirs = pRemoteDecodeFormats;
VIDEO_CHANNEL_PARAMETERS local_params;
PNSC_CHANNEL_VIDEO_PARAMETERS pNSCap = &local_params.ns_params;
PCC_TERMCAP pCapability;
if(!pChannelParams || !(pCapability = pChannelParams->pChannelCapability) || !pFormatID || !lpvBuf ||
(uBufSize < sizeof(VIDEO_CHANNEL_PARAMETERS)))
{
return CAPS_E_INVALID_PARAM;
}
if(!uNumLocalFormats || !pLocalFormats)
{
return CAPS_E_NOCAPS;
}
local_params.TS_Tradeoff = FALSE; // initialize TS tradeoff
for(i=0; i<uNumLocalFormats; i++)
{
pFmtMine = pLocalFormats + IDsByRank[i];
// compare capabilities - start by comparing the format tag. a.k.a. "ClientType" in H.245 land
if(pFmtMine->H245Cap.ClientType == pCapability->ClientType)
{
// if this is a nonstandard cap, compare nonstandard parameters
if(pFmtMine->H245Cap.ClientType == H245_CLIENT_VID_NONSTD)
{
if(NonStandardCapsCompareV(pFmtMine, (PNSC_VIDEO_CAPABILITY)pCapability->Cap.H245Vid_NONSTD.data.value,
pCapability->Cap.H245Vid_NONSTD.data.length))
{
#pragma message ("someday may need need fixup of nonstd params")
// for now, the remote & local nonstandard params are what we want
// and the remote's version of NSC_CHANNEL_VIDEO_PARAMETERS will
// be copied out
pNSCap = (PNSC_CHANNEL_VIDEO_PARAMETERS)
&((PNSC_VIDEO_CAPABILITY)pCapability->Cap.H245Vid_NONSTD.data.value)->cvp_params;
// Does this format support temporal/spatial tradeoff
if(HasNonStandardCapsTS(pFmtMine, (PNSC_VIDEO_CAPABILITY)pCapability->Cap.H245Vid_NONSTD.data.value))
local_params.TS_Tradeoff = TRUE;
else
local_params.TS_Tradeoff = FALSE;
goto RESOLVED_EXIT;
}
}
else // compare standard parameters, if any
{
switch (pFmtMine->H245Cap.ClientType)
{
unsigned short bit_mask, format_mask, usMyMPI, usTheirMPI;
case H245_CLIENT_VID_H263:
// like everywhere else in this module, the assumption is that
// local H.263 capabilities are fanned out with one local cap entry
// per frame size.
format_mask= H263VideoCapability_sqcifMPI_present
| H263VideoCapability_qcifMPI_present
| H263VideoCapability_cifMPI_present
| H263VideoCapability_cif4MPI_present
| H263VideoCapability_cif16MPI_present;
// bail out if no match or nonexistent frame size
if (!((pCapability->Cap.H245Vid_H263.bit_mask & format_mask) & (pFmtMine->H245Cap.Cap.H245Vid_H263.bit_mask & format_mask)))
continue;
// get the maximum bitrate
local_params.ns_params.maxBitRate = min(pFmtMine->H245Cap.Cap.H245Vid_H263.maxBitRate,
pCapability->Cap.H245Vid_H263.maxBitRate);
local_params.ns_params.maxBPP = min (pFmtMine->H245Cap.Cap.H245Vid_H263.bppMaxKb ,
pCapability->Cap.H245Vid_H263.bppMaxKb);
// FIND THE MAXIMUM MPI!!!!. (minimum frame rate)
// there is no pretty way to do this
bit_mask = pFmtMine->H245Cap.Cap.H245Vid_H263.bit_mask;
if(bit_mask & H263VideoCapability_sqcifMPI_present)
{
local_params.ns_params.MPI =
max(pFmtMine->H245Cap.Cap.H245Vid_H263.sqcifMPI,
pCapability->Cap.H245Vid_H263.sqcifMPI);
}
else if (bit_mask & H263VideoCapability_qcifMPI_present)
{
local_params.ns_params.MPI =
max(pFmtMine->H245Cap.Cap.H245Vid_H263.H263VdCpblty_qcifMPI,
pCapability->Cap.H245Vid_H263.H263VdCpblty_qcifMPI);
}
else if (bit_mask & H263VideoCapability_cifMPI_present)
{
local_params.ns_params.MPI =
max(pFmtMine->H245Cap.Cap.H245Vid_H263.H263VdCpblty_cifMPI,
pCapability->Cap.H245Vid_H263.H263VdCpblty_cifMPI);
}
else if (bit_mask & H263VideoCapability_cif4MPI_present)
{
local_params.ns_params.MPI =
max(pFmtMine->H245Cap.Cap.H245Vid_H263.cif4MPI,
pCapability->Cap.H245Vid_H263.cif4MPI);
}
else if (bit_mask & H263VideoCapability_cif16MPI_present)
{
local_params.ns_params.MPI =
max(pFmtMine->H245Cap.Cap.H245Vid_H263.cif16MPI,
pCapability->Cap.H245Vid_H263.cif16MPI);
}
else // impossible. Doom, as MikeG and JonT would say
continue;
// Fallout (And the format is found!)
// And one more special thing: find out if the other end
// advertised Temporal/Spatial tradeoff in it's send capabilities.
// First try the obvious. Technically, it only makes sense for
// transmit capabilities, but if the channel params have it, then
// the other end must have the capability
if(pCapability->Cap.H245Vid_H263.tmprlSptlTrdOffCpblty)
{
local_params.TS_Tradeoff = TRUE;
}
else
{
// Search for a H.263 SEND capability that has the T/S tradoff set
for(j=0; j<uNumRemoteDecodeFormats; j++)
{
if((pFmtTheirs->H245Cap.ClientType == H245_CLIENT_VID_H263)
// exclude RX capabilities
&& (pFmtTheirs->H245Cap.Dir != H245_CAPDIR_LCLRX)
&& (pFmtTheirs->H245Cap.Dir != H245_CAPDIR_RMTRX))
{
if ((pFmtTheirs->H245Cap.Cap.H245Vid_H263.bit_mask & format_mask) & (pFmtMine->H245Cap.Cap.H245Vid_H263.bit_mask & format_mask))
{
local_params.TS_Tradeoff = TRUE;
break;
}
}
pFmtTheirs++; // next entry in receiver's caps
}
}
goto RESOLVED_EXIT;
break;
case H245_CLIENT_VID_H261:
// like everywhere else in this module, the assumption is that
// local H.261 capabilities are fanned out with one local cap entry
// per frame size.
format_mask= H261VdCpblty_qcifMPI_present |H261VdCpblty_cifMPI_present;
// bail out if no match or nonexistent frame size
if (!((pCapability->Cap.H245Vid_H261.bit_mask & format_mask) & (pFmtMine->H245Cap.Cap.H245Vid_H261.bit_mask & format_mask)))
continue;
// get the maximum bitrate
local_params.ns_params.maxBitRate = min(pFmtMine->H245Cap.Cap.H245Vid_H261.maxBitRate,
pCapability->Cap.H245Vid_H261.maxBitRate);
// FIND THE MAXIMUM MPI!!!!. (minimum frame rate)
// there is no pretty way to do this
bit_mask = pFmtMine->H245Cap.Cap.H245Vid_H261.bit_mask;
if (bit_mask & H261VdCpblty_qcifMPI_present)
{
local_params.ns_params.MPI =
max(pFmtMine->H245Cap.Cap.H245Vid_H261.H261VdCpblty_qcifMPI,
pCapability->Cap.H245Vid_H261.H261VdCpblty_qcifMPI);
}
else if (bit_mask & H261VdCpblty_cifMPI_present)
{
local_params.ns_params.MPI =
max(pFmtMine->H245Cap.Cap.H245Vid_H261.H261VdCpblty_cifMPI,
pCapability->Cap.H245Vid_H261.H261VdCpblty_cifMPI);
}
else // impossible. Doom, as MikeG and JonT would say
continue;
// Fallout (And the format is found!)
// And one more special thing: find out if the other end
// advertised Temporal/Spatial tradeoff in it's send capabilities.
// First try the obvious. Technically, it only makes sense for
// transmit capabilities, but if the channel params have it, then
// the other end must have the capability
if(pCapability->Cap.H245Vid_H261.tmprlSptlTrdOffCpblty)
{
local_params.TS_Tradeoff = TRUE;
}
else
{
// Search for a H.261 SEND capability that has the T/S tradoff set
for(j=0; j<uNumRemoteDecodeFormats; j++)
{
if((pFmtTheirs->H245Cap.ClientType == H245_CLIENT_VID_H261)
// exclude RX capabilities
&& (pFmtTheirs->H245Cap.Dir != H245_CAPDIR_LCLRX)
&& (pFmtTheirs->H245Cap.Dir != H245_CAPDIR_RMTRX))
{
if ((pFmtTheirs->H245Cap.Cap.H245Vid_H261.bit_mask
& format_mask)
& (pFmtMine->H245Cap.Cap.H245Vid_H261.bit_mask
& format_mask))
{
local_params.TS_Tradeoff = TRUE;
break;
}
}
pFmtTheirs++; // next entry in receiver's caps
}
}
goto RESOLVED_EXIT;
break;
default:
goto RESOLVED_EXIT;
break;
}
}// end else compare standard parameters, if any
}// end if(pFmtMine->H245Cap.ClientType == pCapability->ClientType)
}
return CAPS_E_NOMATCH;
RESOLVED_EXIT:
// Match!
// return ID of the decoding caps that match
*pFormatID = pFmtMine->H245Cap.CapId;
local_params.RTP_Payload = pChannelParams->bRTPPayloadType;;
memcpy(lpvBuf, &local_params, sizeof(VIDEO_CHANNEL_PARAMETERS));
return hrSuccess;
}
HRESULT CMsivCapability::SetCapIDBase (UINT uNewBase)
{
uCapIDBase = uNewBase;
UINT u;
for (u=0;u<uNumLocalFormats;u++)
{
pLocalFormats[u].H245Cap.CapId = u + uCapIDBase;
}
return hrSuccess;
}
BOOL CMsivCapability::IsHostForCapID(MEDIA_FORMAT_ID CapID)
{
if((CapID >= uCapIDBase) && ((CapID - uCapIDBase) < uNumLocalFormats))
return TRUE;
else
return FALSE;
}
HRESULT CMsivCapability::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 CMsivCapability::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 CMsivCapability::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))->H245Cap.CapId;
}
else
{
return FormatID;
}
}
// Returns the Id of the format with the smallest wSortIndex - preferred format.
HRESULT CMsivCapability::GetPreferredFormatId (VIDEO_FORMAT_ID *pId)
{
HRESULT hr = hrSuccess;
VIDCAP_DETAILS *pDetails = pLocalFormats;
UINT u, uIndex;
WORD wSortIndex, wMinSortIndex = SHRT_MAX;
// Validate input param
if (!pId)
return((HRESULT)CAPS_E_INVALID_PARAM);
// Validate state
if(!uNumLocalFormats || !pDetails)
return((HRESULT)CAPS_E_NOCAPS);
// Look for the format with the smallest wSortIndex
for (u = 0; (u < uNumLocalFormats) && (u < MAX_CAPS_PRESORT); u++)
{
pDetails = pLocalFormats + IDsByRank[u];
// Find the sort index.
uIndex = (UINT)(pDetails - pLocalFormats);
for (wSortIndex = 0; (wSortIndex < uNumLocalFormats) && (wSortIndex < MAX_CAPS_PRESORT); wSortIndex++)
{
if (uIndex == IDsByRank[wSortIndex])
break; // Found it
}
if (wSortIndex <= wMinSortIndex)
{
*pId = IndexToId(uIndex);
wMinSortIndex = wSortIndex;
}
}
return(hr);
}

Reference in a new issue Copy permalink