/*
 *    File: capsctl.cpp
 *
 *    capability control object implementations
 *
 *
 *    Revision History:
 *
 *    10/10/96 mikeg created
 * 	  06/24/97 mikev	- Added T.120 capability to serialized caps and simcaps (interim hack until a
 *							T120 resolver is implemented)
 *						- Retired  ResolveEncodeFormat(Audio,Video) and implemented a data-independent
 *						resolution algorithm and exposed method ResolveFormats(). Added support
 * 						routines ResolvePermutations(), TestSimultaneousCaps() and
 *						AreSimcaps().
 */

#include "precomp.h"
UINT g_AudioPacketDurationMs = AUDIO_PACKET_DURATION_LONG;	// preferred packet duration
BOOL g_fRegAudioPacketDuration = FALSE;	// AudioPacketDurationMs from registry


PCC_TERMCAPDESCRIPTORS CapsCtl::pAdvertisedSets=NULL;
DWORD CapsCtl::dwConSpeed = 0;
UINT CapsCtl::uStaticGlobalRefCount=0;
UINT CapsCtl::uAdvertizedSize=0;
extern HRESULT WINAPI CreateMediaCapability(REFGUID, LPIH323MediaCap *);

LPIH323MediaCap CapsCtl::FindHostForID(MEDIA_FORMAT_ID id)
{
	if(pAudCaps && pAudCaps->IsHostForCapID(id))
	{
		return (pAudCaps);
	}
	else if (pVidCaps  && pVidCaps->IsHostForCapID(id))
	{
  		return (pVidCaps);
	}
	return NULL;
}

LPIH323MediaCap CapsCtl::FindHostForMediaType(PCC_TERMCAP pCapability)
{
	if(pCapability->DataType == H245_DATA_AUDIO)
	{
		return (pAudCaps);
	}
	else if(pCapability->DataType == H245_DATA_VIDEO)
	{
  		return (pVidCaps);
	}
	return NULL;
}

LPIH323MediaCap CapsCtl::FindHostForMediaGuid(LPGUID pMediaGuid)
{

	if(MEDIA_TYPE_H323VIDEO == *pMediaGuid)
	{
  		return (pVidCaps);
	}
	else if(MEDIA_TYPE_H323AUDIO == *pMediaGuid)
	{
		return (pAudCaps);
	}
	else
		return NULL;
}

ULONG CapsCtl::AddRef()
{
	uRef++;
	return uRef;
}

ULONG CapsCtl::Release()
{
	uRef--;
	if(uRef == 0)
	{
		delete this;
		return 0;
	}
	return uRef;
}

STDMETHODIMP CapsCtl::QueryInterface( REFIID iid,	void ** ppvObject)
{
	// this breaks the rules for the official COM QueryInterface because
	// the interfaces that are queried for are not necessarily real COM
	// interfaces.  The reflexive property of QueryInterface would be broken in
	// that case.

	HRESULT hr = E_NOINTERFACE;
	if(!ppvObject)
		return hr;
		
	*ppvObject = 0;
	if(iid == IID_IDualPubCap)// satisfy symmetric property of QI
	{
		*ppvObject = (IDualPubCap *)this;
		hr = hrSuccess;
		AddRef();
	}
	else if(iid == IID_IAppAudioCap )
	{
		if(pAudCaps)
		{
			return pAudCaps->QueryInterface(iid, ppvObject);
		}
	}
	else if(iid == IID_IAppVidCap )
	{
		if(pVidCaps)
		{
			return pVidCaps->QueryInterface(iid, ppvObject);
		}
	}
	return hr;
}



CapsCtl::CapsCtl () :
uRef(1),
pVidCaps(NULL),
pAudCaps(NULL),
pACapsBuf(NULL),
pVCapsBuf(NULL),
dwNumInUse(0),
bAudioPublicize(TRUE),
bVideoPublicize(TRUE),
bT120Publicize(TRUE),
m_localT120cap(INVALID_MEDIA_FORMAT),
m_remoteT120cap(INVALID_MEDIA_FORMAT),
m_remoteT120bitrate(0),
m_pAudTermCaps(NULL),
m_pVidTermCaps(NULL),
pSetIDs(NULL),
pRemAdvSets(NULL)
{
   uStaticGlobalRefCount++;
}

CapsCtl::~CapsCtl ()
{

   if (pACapsBuf) {
      MemFree (pACapsBuf);
   }
   if (pVCapsBuf) {
      MemFree (pVCapsBuf);
   }

   if (pAudCaps) {
      pAudCaps->Release();
   }

   if (pVidCaps) {
      pVidCaps->Release();
   }
   uStaticGlobalRefCount--;
   if (uStaticGlobalRefCount == 0) {
       //Free up the sim. caps array
       if (pAdvertisedSets) {
          while (pAdvertisedSets->wLength) {
             //wLength is Zero based
             MemFree ((VOID *)pAdvertisedSets->pTermCapDescriptorArray[--pAdvertisedSets->wLength]);
          }
          MemFree ((VOID *)pAdvertisedSets->pTermCapDescriptorArray);
          pAdvertisedSets->pTermCapDescriptorArray = NULL;
          MemFree ((void *) pAdvertisedSets);
          pAdvertisedSets=NULL;
          dwNumInUse=0;
       }
   }

   //And the remote array
   if (pRemAdvSets) {
      while (pRemAdvSets->wLength) {
         MemFree ((VOID *)pRemAdvSets->pTermCapDescriptorArray[--pRemAdvSets->wLength]);
      }
      MemFree ((void *) pRemAdvSets->pTermCapDescriptorArray);
      pRemAdvSets->pTermCapDescriptorArray = NULL;
      MemFree ((void *) pRemAdvSets);
      pRemAdvSets=NULL;
   }
   MemFree (pSetIDs);
   pSetIDs=NULL;
}

BOOL CapsCtl::Init()
{
    HRESULT hrLast;
    int iBase = 1;

    if (g_capFlags & CAPFLAGS_AV_STREAMS)
    {
    	hrLast = ::CreateMediaCapability(MEDIA_TYPE_H323AUDIO, &pAudCaps);
	    if(!HR_SUCCEEDED(hrLast))
    	{
            goto InitDone;
    	}
    }

    if (g_capFlags & CAPFLAGS_AV_STREAMS)
    {
    	hrLast = ::CreateMediaCapability(MEDIA_TYPE_H323VIDEO, &pVidCaps);
	    if(!HR_SUCCEEDED(hrLast))
    	{
            goto InitDone;
    	}
    }

    if (pAudCaps)
    {
    	// Base the capability IDs beginning at 1  (zero is an invalid capability ID!)
	    pAudCaps->SetCapIDBase(iBase);
        iBase += pAudCaps->GetNumCaps();
    }

    if (pVidCaps)
    {
        pVidCaps->SetCapIDBase(iBase);
        iBase += pVidCaps->GetNumCaps();
    }

InitDone:
	m_localT120cap = iBase;
	return TRUE;
}
																								
HRESULT CapsCtl::ReInitialize()
{
	HRESULT hr = hrSuccess;
    int iBase = 1;

	if (pAudCaps && !pAudCaps->ReInit())
	{
		hr = CAPS_E_SYSTEM_ERROR;
		goto EXIT;
	}

	if (pVidCaps && !pVidCaps->ReInit())
	{
		hr = CAPS_E_SYSTEM_ERROR;
		goto EXIT;
	}

	// Base the capability IDs beginning at 1  (zero is an invalid capability ID!)
    if (pAudCaps)
    {
    	pAudCaps->SetCapIDBase(iBase);
        iBase += pAudCaps->GetNumCaps();
    }

    if (pVidCaps)
    {
        pVidCaps->SetCapIDBase(iBase);
        iBase += pVidCaps->GetNumCaps();
    }

	m_localT120cap = iBase;

EXIT:
	return hr;
}

const char szNMProdNum[] = "Microsoft\256 NetMeeting(TM)\0";
const char szNM20VerNum[] = "Version 2.0\0";

HRESULT CapsCtl::AddRemoteDecodeCaps(PCC_TERMCAPLIST pTermCapList,PCC_TERMCAPDESCRIPTORS pTermCapDescriptors, PCC_VENDORINFO pVendorInfo)
{
	FX_ENTRY("CapsCtl::AddRemoteDecodeCaps");
	HRESULT hr;
	void      	  *pData=NULL;
	UINT		  uSize,x,y,z;


   //WLength is # of capabilities, not structure length
	WORD wNDesc;
	LPIH323MediaCap pMediaCap;
	
	if(!pTermCapList && !pTermCapDescriptors) 	// additional capability descriptors may be added
	{											// at any time
	   return CAPS_E_INVALID_PARAM;
	}
	// Check for NM version 2.0
	m_fNM20 = FALSE;
	ASSERT(pVendorInfo);
	if (pVendorInfo->bCountryCode == USA_H221_COUNTRY_CODE
		&& pVendorInfo->wManufacturerCode == MICROSOFT_H_221_MFG_CODE
		&& pVendorInfo->pProductNumber && pVendorInfo->pVersionNumber
		&& pVendorInfo->pProductNumber->wOctetStringLength == sizeof(szNMProdNum)
		&& pVendorInfo->pVersionNumber->wOctetStringLength == sizeof(szNM20VerNum)
		&& memcmp(pVendorInfo->pProductNumber->pOctetString, szNMProdNum, sizeof(szNMProdNum)) == 0
		&& memcmp(pVendorInfo->pVersionNumber->pOctetString, szNM20VerNum, sizeof(szNM20VerNum)) == 0
		)
	{
		m_fNM20 = TRUE;
	}

	// cleanup old term caps if term caps are being added and old caps exist
    if (pAudCaps)
    	pAudCaps->FlushRemoteCaps();
    if (pVidCaps)
    	pVidCaps->FlushRemoteCaps();
	m_remoteT120cap = INVALID_MEDIA_FORMAT;	// note there is no T120 cap resolver and
												// this CapsCtl holds exactly one local and remote T120 cap
	
	// Copy pTermcapDescriptors to a local copy, (and free any old one)
	if (pRemAdvSets) {
	   while (pRemAdvSets->wLength) {
		  //0 based
		  MemFree ((VOID *)pRemAdvSets->pTermCapDescriptorArray[--pRemAdvSets->wLength]);
	   }

	   MemFree ((VOID *)pRemAdvSets->pTermCapDescriptorArray);
	   pRemAdvSets->pTermCapDescriptorArray = NULL;
	   MemFree ((VOID *)pRemAdvSets);
	   pRemAdvSets=NULL;

	}

	//Ok, walk through the PCC_TERMCAPDESCRIPTORS list, first, allocate memory for the Master PCC_TERMCAPDESCRIPTORS
	//structure, then each simcap, and the altcaps therin, then copy the data.

	if (!(pRemAdvSets=(PCC_TERMCAPDESCRIPTORS) MemAlloc (sizeof (CC_TERMCAPDESCRIPTORS) ))){
	   return CAPS_E_SYSTEM_ERROR;
	}

	//How many Descriptors?
	pRemAdvSets->wLength=pTermCapDescriptors->wLength;

	if (!(pRemAdvSets->pTermCapDescriptorArray=((H245_TOTCAPDESC_T **)MemAlloc (sizeof (H245_TOTCAPDESC_T*)*pTermCapDescriptors->wLength))) ) {
	   return CAPS_E_SYSTEM_ERROR;
	}

	//Once per descriptor...
	for (x=0;x < pTermCapDescriptors->wLength;x++) {
	   //Allocate memory for the descriptor entry
	   if (!(pRemAdvSets->pTermCapDescriptorArray[x]=(H245_TOTCAPDESC_T *)MemAlloc (sizeof (H245_TOTCAPDESC_T)))) {
		  return CAPS_E_SYSTEM_ERROR;
	   }

	   //BUGBUG for beta 2 Copy en masse.
	   memcpy (pRemAdvSets->pTermCapDescriptorArray[x],pTermCapDescriptors->pTermCapDescriptorArray[x],sizeof (H245_TOTCAPDESC_T));

/*	post beta 2?
	   //Copy the capability ID
	   pRemAdvSets->pTermCapDescriptorArray[x].CapID=pTermCapDescriptors[x].CapID
	   //Walk the simcaps, then altcaps and copy entries */
	}


	for (wNDesc=0;wNDesc <pTermCapList->wLength;wNDesc++) {
	  pData=NULL;
		pMediaCap = FindHostForMediaType(pTermCapList->pTermCapArray[wNDesc]);
		if(!pMediaCap)
		{
			// special case: there is no T120 resolver. THIS IS A TEMPORARY
			// SITUATION. We cannot track bitrate limits on multiple T120 capability
			// instances because of this.  As of now, we (NetMeeting) do not advertise
			// more than one T.120 capability.

			//This code will keep the last T.120 capability encountered.
			if(((pTermCapList->pTermCapArray[wNDesc])->DataType == H245_DATA_DATA)
			&& ((pTermCapList->pTermCapArray[wNDesc])->Cap.H245Dat_T120.application.choice
				== DACy_applctn_t120_chosen)
			&& ((pTermCapList->pTermCapArray[wNDesc])->Cap.H245Dat_T120.application.u.DACy_applctn_t120.choice
				== separateLANStack_chosen))
			{
				// it's data data
				m_remoteT120cap = (pTermCapList->pTermCapArray[wNDesc])->CapId;
				m_remoteT120bitrate =
					(pTermCapList->pTermCapArray[wNDesc])->Cap.H245Dat_T120.maxBitRate;
			}
			
			// continue;
			// handled it in-line
		}
	  	else if(pMediaCap->IsCapabilityRecognized(pTermCapList->pTermCapArray[wNDesc]))
	  	{
			hr = pMediaCap->AddRemoteDecodeFormat(pTermCapList->pTermCapArray[wNDesc]);
			#ifdef DEBUG
			if(!HR_SUCCEEDED(hr))
			{
				ERRORMESSAGE(("%s:AddRemoteDecodeFormat returned 0x%08lx\r\n",_fx_, hr));
			}
			#endif // DEBUG
	  	}
	}
	return (hrSuccess);
}


HRESULT CapsCtl::CreateCapList(PCC_TERMCAPLIST *ppCapBuf, PCC_TERMCAPDESCRIPTORS *ppCombinations)
{
   	PCC_TERMCAPLIST pTermCapList = NULL, pTermListAud=NULL, pTermListVid=NULL;
	PCC_TERMCAPDESCRIPTORS pCombinations = NULL;
	UINT uCount = 0, uSize = 0, uT120Size = 0;
	HRESULT hr;
	WORD wc;
   	UINT x=0,y=0,z=0,uNumAud=0,uNumVid=0;
	H245_TOTCAPDESC_T *pTotCaps, **ppThisDescriptor;
	PPCC_TERMCAP  ppCCThisTermCap;	
	PCC_TERMCAP  pCCT120Cap = NULL;

	uCount = GetNumCaps(TRUE);

	ASSERT((NULL == m_pAudTermCaps) && (NULL == m_pVidTermCaps));
	
	// calc size of CC_TERMCAPLIST header + CC_TERMCAPDESCRIPTORS + array of PCC_TERMCAP
	// allocate mem for the master CC_TERMCAPLIST, including the array of pointers to all CC_TERMCAPs
	uSize = sizeof(CC_TERMCAPLIST)
		+ sizeof (CC_TERMCAPDESCRIPTORS) + (uCount * sizeof(PCC_TERMCAP));
	if((m_localT120cap != INVALID_MEDIA_FORMAT) && bT120Publicize)
	{
		uSize += sizeof(CC_TERMCAP);
	}

	pTermCapList = (PCC_TERMCAPLIST)MemAlloc(uSize);
  	if(pTermCapList == NULL)
  	{
		hr = CAPS_E_NOMEM;
		goto ERROR_EXIT;
  	}
	
	// divide up the buffer, CC_TERMCAPLIST first, followed by array of PCC_TERMCAP.
	// The array of PCC_TERMCAP follows fixed size CC_TERMCAPLIST structure and the fixed size
	// CC_TERMCAP structure that holds the one T.120 cap.
	if((m_localT120cap != INVALID_MEDIA_FORMAT) && bT120Publicize)
	{
		pCCT120Cap = (PCC_TERMCAP)(((BYTE *)pTermCapList) + sizeof(CC_TERMCAPLIST));
		ppCCThisTermCap = (PPCC_TERMCAP) (((BYTE *)pTermCapList) + sizeof(CC_TERMCAPLIST) +
			sizeof(CC_TERMCAP));
	}
	else
		ppCCThisTermCap = (PPCC_TERMCAP) (((BYTE *)pTermCapList) + sizeof(CC_TERMCAPLIST));
	
	// allocate mem for the simultaneous caps
	// get size of cached advertised sets if it exists and more than one media
	// type is enabled for publication
	if(bAudioPublicize && bVideoPublicize && pAdvertisedSets)
	{
		// use size of cached buffer
		uSize = uAdvertizedSize;
	}
	else if (pAdvertisedSets)
	{
		// This case needs to be fixed. If media types are disabled, the simultaneous capability
		// descriptors in pAdvertisedSets should be rebuilt at that time. There should be no need to test
		// if(bAudioPublicize && bVideoPublicize && pAdvertisedSets)

   		// calculate size of capability descriptors and simultaneous capability structures.

		#pragma message ("Figure out the size this needs to be...")
		#define NUMBER_TERMCAP_DESCRIPTORS 1
		uSize = sizeof(H245_TOTCAPDESC_T) * NUMBER_TERMCAP_DESCRIPTORS+
						  sizeof (CC_TERMCAPDESCRIPTORS)+NUMBER_TERMCAP_DESCRIPTORS*
						  sizeof (H245_TOTCAPDESC_T *);
	}
    else
    {
        uSize = 0;
    }

	
    if (uSize)
    {
    	pCombinations = (PCC_TERMCAPDESCRIPTORS)MemAlloc(uSize);
	    // skip the CC_TERMCAPDESCRIPTORS, which has a variable length array of (H245_TOTCAPDESC_T *) following it
    	// the total size of that glob is uSimCapsSize
	    // The actual array of [H245_TOTCAPDESC_T *] follows the CC_TERMCAPDESCRIPTORS structure
    	// anchor the pCombinations->pTermCapDescriptorArray to this point.
	    if(pCombinations == NULL)
      	{
	    	hr = CAPS_E_NOMEM;
		    goto ERROR_EXIT;
      	}
	
	    ppThisDescriptor = pCombinations->pTermCapDescriptorArray
		    = (H245_TOTCAPDESC_T **)((BYTE *)pCombinations + sizeof(CC_TERMCAPDESCRIPTORS));
    	// the first H245_TOTCAPDESC_T follows the array of [H245_TOTCAPDESC_T *]
	    pTotCaps = (H245_TOTCAPDESC_T *)((BYTE *)ppThisDescriptor + pCombinations->wLength*sizeof(H245_TOTCAPDESC_T **));

    	if(pAudCaps && bAudioPublicize)
	    {
		    hr=pAudCaps->CreateCapList((LPVOID *)&pTermListAud);
    		if(!HR_SUCCEEDED(hr))
	    		goto ERROR_EXIT;
		    ASSERT(pTermListAud != NULL);
    	}
	    if(pVidCaps && bVideoPublicize)
    	{
	    	hr=pVidCaps->CreateCapList((LPVOID *)&pTermListVid);
		    if(!HR_SUCCEEDED(hr))
			    goto ERROR_EXIT;
    		ASSERT(pTermListVid != NULL);
	    }
    }
    else
    {
        pCombinations = NULL;
    }

	// fix pointers in the master caps list

	// Now need to fixup the CC_TERMCAPLIST to refer to the individual capabilities
	// Anchor the CC_TERMCAPLIST member pTermCapArray at the array of PCC_TERMCAP, and
	// start partying on the array.
	pTermCapList->wLength =0;
	pTermCapList->pTermCapArray = ppCCThisTermCap;

	if(pCCT120Cap)
	{
		*ppCCThisTermCap++ = pCCT120Cap;	
		// set T120 capability parameters
		pCCT120Cap->DataType = H245_DATA_DATA;
		pCCT120Cap->ClientType = H245_CLIENT_DAT_T120;
		pCCT120Cap->Dir = H245_CAPDIR_LCLRXTX;
		
		pCCT120Cap->Cap.H245Dat_T120.application.choice = DACy_applctn_t120_chosen;
		pCCT120Cap->Cap.H245Dat_T120.application.u.DACy_applctn_t120.choice= separateLANStack_chosen;
		pCCT120Cap->Cap.H245Dat_T120.maxBitRate = dwConSpeed;

		pCCT120Cap->CapId = (H245_CAPID_T)m_localT120cap;	
		pTermCapList->wLength++;
	}
	if(pAudCaps && pTermListAud)
	{
		for(wc = 0; wc < pTermListAud->wLength; wc++)
		{
			// copy the array of "pointers to CC_TERMCAP"
			*ppCCThisTermCap++ = pTermListAud->pTermCapArray[wc];
			pTermCapList->wLength++;
		}
	}
	if(pVidCaps && pTermListVid)
	{
		for(wc = 0; wc <  pTermListVid->wLength; wc++)
		{
			// copy the array of "pointers to CC_TERMCAP"
			*ppCCThisTermCap++ = pTermListVid->pTermCapArray[wc];
			pTermCapList->wLength++;			
		}

	}
	// fixup the simultaneous capability descriptors
	//	Create a default set if necessary
	//

	if(bAudioPublicize && bVideoPublicize && pAdvertisedSets)
	{
		pCombinations->wLength = pAdvertisedSets->wLength;
       	// point pCombinations->pTermCapDescriptorArray past the header (CC_TERMCAPDESCRIPTORS)
        pCombinations->pTermCapDescriptorArray
			= (H245_TOTCAPDESC_T **)((BYTE *)pCombinations + sizeof(CC_TERMCAPDESCRIPTORS));
        // the first H245_TOTCAPDESC_T follows the array of [H245_TOTCAPDESC_T *]
        pTotCaps = (H245_TOTCAPDESC_T *)((BYTE *)pCombinations->pTermCapDescriptorArray +
            pAdvertisedSets->wLength*sizeof(H245_TOTCAPDESC_T **));			
		
		for(x = 0; x < pAdvertisedSets->wLength; x++)
		{
			// write into the array of descriptor pointers. pointer[x] = this one
            pCombinations->pTermCapDescriptorArray[x] = pTotCaps;
			
            pTotCaps->CapDescId= pAdvertisedSets->pTermCapDescriptorArray[x]->CapDescId;
	   		pTotCaps->CapDesc.Length=pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.Length;
	   		
	   		for(y = 0; y < pTotCaps->CapDesc.Length;y++)
			{
			   //Copy the length field.
			   pTotCaps->CapDesc.SimCapArray[y].Length=
			   pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[y].Length;

				for(z=0;
					z < pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[y].Length;
					z++)
				{
					pTotCaps->CapDesc.SimCapArray[y].AltCaps[z] =
						pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[y].AltCaps[z];
				}
			}
            pTotCaps++;            	
		}
	}
	else if (pAdvertisedSets)
	{
		// descriptors in pAdvertisedSets should be rebuilt at that time. There should be no need to test
		// if(bAudioPublicize && bVideoPublicize && pAdvertisedSets)

 		// HACK - put all audio or video caps in one AltCaps[], the T.120 cap in another AltCaps[]
	    // and put both of those in one single  capability descriptor (H245_TOTCAPDESC_T)
		// This hack will not extend past the assumption of one audio channel, one video channel, and
		// one T.120 channel.  If arbitrary media is supported, or multiple audio channels are supported,
		// this code will be wrong
		
		pCombinations->wLength=1;
	   	// point pCombinations->pTermCapDescriptorArray past the header (CC_TERMCAPDESCRIPTORS)
        pCombinations->pTermCapDescriptorArray
			= (H245_TOTCAPDESC_T **)((BYTE *)pCombinations + sizeof(CC_TERMCAPDESCRIPTORS));
        // the first H245_TOTCAPDESC_T follows the array of [H245_TOTCAPDESC_T *]
        pTotCaps = (H245_TOTCAPDESC_T *)((BYTE *)pCombinations->pTermCapDescriptorArray +
            pAdvertisedSets->wLength*sizeof(H245_TOTCAPDESC_T **));			
   		pTotCaps->CapDescId=(H245_CAPDESCID_T)x;
   		pTotCaps->CapDesc.Length=0;
		if(pTermListAud)
		{
			uNumAud = min(pTermListAud->wLength, H245_MAX_ALTCAPS);
			pTotCaps->CapDesc.SimCapArray[x].Length=(unsigned short)uNumAud;
			for(y = 0; y<uNumAud;y++)
			{
				pTotCaps->CapDesc.SimCapArray[x].AltCaps[y] = pTermListAud->pTermCapArray[y]->CapId;
			}
			x++;
			pTotCaps->CapDesc.Length++;
		}

		if(pTermListVid && pTermListVid->wLength)
		{
			uNumVid = min(pTermListVid->wLength,  H245_MAX_ALTCAPS);
			pTotCaps->CapDesc.SimCapArray[x].Length=(unsigned short)uNumVid;
			for(y = 0; y<uNumVid;y++)
			{
				pTotCaps->CapDesc.SimCapArray[x].AltCaps[y] = pTermListVid->pTermCapArray[y]->CapId;
			}
			x++;
			pTotCaps->CapDesc.Length++;
		}
		// the T.120 cap
		if((m_localT120cap != INVALID_MEDIA_FORMAT) && bT120Publicize)
		{
			pTotCaps->CapDesc.SimCapArray[x].Length=1;
			pTotCaps->CapDesc.SimCapArray[x].AltCaps[0] = (H245_CAPID_T)m_localT120cap;
			pTotCaps->CapDesc.Length++;
		}
		
		// write into the array of descriptor pointers. pointer[x] = this one
		*ppThisDescriptor = pTotCaps;
		
	}
	m_pVidTermCaps = pTermListVid;
	m_pAudTermCaps = pTermListAud;
	
	*ppCapBuf = pTermCapList;
	*ppCombinations = pCombinations;
	return hrSuccess;
	
ERROR_EXIT:
	m_pAudTermCaps = NULL;
	m_pVidTermCaps = NULL;
	if(pTermCapList)
		MemFree(pTermCapList);
	if(pCombinations)
		MemFree(pCombinations);

	if(pAudCaps && pTermListAud)
	{
		hr=pAudCaps->DeleteCapList(pTermListAud);
	}
	if(pVidCaps && pTermListVid)
	{
		hr=pVidCaps->DeleteCapList(pTermListVid);
	}
	return hr;
}

HRESULT CapsCtl::DeleteCapList(PCC_TERMCAPLIST pCapBuf, PCC_TERMCAPDESCRIPTORS pCombinations)
{
	MemFree(pCapBuf);
	MemFree(pCombinations);
	if(m_pAudTermCaps && pAudCaps)
	{
		pAudCaps->DeleteCapList(m_pAudTermCaps);
	}
	if(m_pVidTermCaps)
	{
		pVidCaps->DeleteCapList(m_pVidTermCaps);
	}
	
	m_pAudTermCaps = NULL;
	m_pVidTermCaps = NULL;
	return hrSuccess;
}

HRESULT CapsCtl::GetEncodeParams(LPVOID pBufOut, UINT uBufSize,LPVOID pLocalParams, UINT uLocalSize,DWORD idRemote, DWORD idLocal)
{
	LPIH323MediaCap pMediaCap = FindHostForID(idLocal);
	if(!pMediaCap)
		return CAPS_E_INVALID_PARAM;

	// HACK
	// Adjust audio packetization depending on call scenario
	// unless there is an overriding registry setting
	if (pMediaCap == pAudCaps)
	{
		VIDEO_FORMAT_ID vidLocal=INVALID_MEDIA_FORMAT, vidRemote=INVALID_MEDIA_FORMAT;
		VIDEO_CHANNEL_PARAMETERS vidParams;
		CC_TERMCAP vidCaps;
		UINT audioPacketLength;
		// modify the audio packetization parameters based on local bandwidth
		// and presence of video
		audioPacketLength = AUDIO_PACKET_DURATION_LONG;
		// the registry setting overrides, if it is present
		if (g_fRegAudioPacketDuration)
			audioPacketLength = g_AudioPacketDurationMs;
		else if (!m_fNM20)		// dont try smaller packets for NM20 because it cant handle them
		{
			if (pVidCaps && pVidCaps->ResolveEncodeFormat(&vidLocal,&vidRemote) == S_OK
				&& (pVidCaps->GetEncodeParams(&vidCaps,sizeof(vidCaps), &vidParams, sizeof(vidParams), vidRemote, vidLocal) == S_OK))
			{
				// we may potentially send video
				if (vidParams.ns_params.maxBitRate*100 > BW_ISDN_BITS)
					audioPacketLength = AUDIO_PACKET_DURATION_SHORT;
					
			}
			else
			{
				// no video
				// since we dont know the actual connection bandwidth we use
				// the local user setting.
				// Note: if the remote is on a slow-speed net and the local is on a LAN
				// we may end up with an inappropriate setting.
				if (dwConSpeed > BW_288KBS_BITS)
					audioPacketLength = AUDIO_PACKET_DURATION_SHORT;
				else if (dwConSpeed > BW_144KBS_BITS)
					audioPacketLength = AUDIO_PACKET_DURATION_MEDIUM;
			}
		}
		// Setting the AudioPacketDurationMs  affects the subsequent GetEncodeParams call
		pMediaCap->SetAudioPacketDuration(audioPacketLength);
	}
	
	return pMediaCap->GetEncodeParams (pBufOut,uBufSize, pLocalParams,
			uLocalSize,idRemote,idLocal);
	
}

HRESULT CapsCtl::GetPublicDecodeParams(LPVOID pBufOut, UINT uBufSize, VIDEO_FORMAT_ID id)
{
	LPIH323MediaCap pMediaCap = FindHostForID(id);
	if(!pMediaCap)
		return CAPS_E_INVALID_PARAM;
		
	return pMediaCap->GetPublicDecodeParams (pBufOut,uBufSize,id);
}

HRESULT CapsCtl::GetDecodeParams(PCC_RX_CHANNEL_REQUEST_CALLBACK_PARAMS  pChannelParams,DWORD * pFormatID, LPVOID lpvBuf, UINT uBufSize)
{
	LPIH323MediaCap pMediaCap = FindHostForMediaType(pChannelParams->pChannelCapability);
	if(!pMediaCap)
		return CAPS_E_INVALID_PARAM;
	return pMediaCap->GetDecodeParams (pChannelParams,pFormatID,lpvBuf,uBufSize);
}

HRESULT CapsCtl::ResolveToLocalFormat(MEDIA_FORMAT_ID FormatIDLocal,
		MEDIA_FORMAT_ID * pFormatIDRemote)
{
	LPIH323MediaCap pMediaCap = FindHostForID(FormatIDLocal);
	if(!pMediaCap)
		return CAPS_E_INVALID_PARAM;
	return pMediaCap->ResolveToLocalFormat (FormatIDLocal,pFormatIDRemote);

}
UINT CapsCtl::GetSimCapBufSize (BOOL bRxCaps)
{
   	UINT uSize;

	// get size of cached advertised sets if it exists and more than one media
	// type is enabled for publication
	if(bAudioPublicize && bVideoPublicize && pAdvertisedSets)
	{
		// use size of cached buffer
		uSize = uAdvertizedSize;
	}
	else
	{
   		// calculate size of capability descriptors and simultaneous capability structures.

		#pragma message ("Figure out the size this needs to be...")
		#define NUMBER_TERMCAP_DESCRIPTORS 1
		uSize = sizeof(H245_TOTCAPDESC_T) * NUMBER_TERMCAP_DESCRIPTORS+
						  sizeof (CC_TERMCAPDESCRIPTORS)+NUMBER_TERMCAP_DESCRIPTORS*
						  sizeof (H245_TOTCAPDESC_T *);
	}				
   	return uSize;
}

UINT CapsCtl::GetNumCaps(BOOL bRXCaps)
{
	UINT u=0;
	if(pAudCaps && bAudioPublicize)
	{
		u = pAudCaps->GetNumCaps(bRXCaps);
	}
	if(pVidCaps && bVideoPublicize)
	{
		u += pVidCaps->GetNumCaps(bRXCaps);
	}
	if(bT120Publicize)
		u++;
	return u;
}

UINT CapsCtl::GetLocalSendParamSize(MEDIA_FORMAT_ID dwID)
{
	LPIH323MediaCap pMediaCap = FindHostForID(dwID);
	if(!pMediaCap)
		return 0;
	return (pMediaCap->GetLocalSendParamSize(dwID));
}
UINT CapsCtl::GetLocalRecvParamSize(PCC_TERMCAP pCapability)
{
	LPIH323MediaCap pMediaCap = FindHostForMediaType(pCapability);
	if(!pMediaCap)
		return 0;
	return (pMediaCap->GetLocalRecvParamSize(pCapability));
}

STDMETHODIMP CapsCtl::GetEncodeFormatDetails(MEDIA_FORMAT_ID FormatID, VOID **ppFormat, UINT *puSize)
{
	LPIH323MediaCap pMediaCap = FindHostForID(FormatID);
	if(!pMediaCap)
	{
		*ppFormat = NULL;
		*puSize = 0;
		return E_INVALIDARG;
	}
	return pMediaCap->GetEncodeFormatDetails (FormatID, ppFormat, puSize);
}

STDMETHODIMP CapsCtl::GetDecodeFormatDetails(MEDIA_FORMAT_ID FormatID, VOID **ppFormat, UINT *puSize)
{
	LPIH323MediaCap pMediaCap = FindHostForID(FormatID);
	if(!pMediaCap)
	{
		*ppFormat = NULL;
		*puSize = 0;
		return E_INVALIDARG;
	}
	return pMediaCap->GetDecodeFormatDetails (FormatID, ppFormat, puSize);
}

//
//  EnableMediaType controls whether or not capabilities for that media type
//  are publicized.  In a general implementation (next version?) w/ arbitrary
//	number  of media types, each of the media capability objects would keep
//  track of their own state.   This version of Capsctl tracks h323 audio and
//  video only
//

HRESULT CapsCtl::EnableMediaType(BOOL bEnable, LPGUID pGuid)
{
	if(!pGuid)
		return CAPS_E_INVALID_PARAM;
		
	if(*pGuid == MEDIA_TYPE_H323AUDIO)
	{
		bAudioPublicize = bEnable;
	}
	else if (*pGuid == MEDIA_TYPE_H323VIDEO)
	{
		bVideoPublicize = bEnable;
	}
	else
	{
		return CAPS_E_INVALID_PARAM;
	}
	return hrSuccess;
}
//
// Build the PCC_TERMCAPDESCRIPTORS list that we will advertise.
//
// puAudioFormatList/puVideoFormatList MUST BE sorted by preference!
//
//



HRESULT CapsCtl::AddCombinedEntry (MEDIA_FORMAT_ID *puAudioFormatList,UINT uAudNumEntries,MEDIA_FORMAT_ID *puVideoFormatList, UINT uVidNumEntries,DWORD *pIDOut)
{
   static USHORT dwLastIDUsed;
   DWORD x,y;
   BOOL bAllEnabled=TRUE,bRecv,bSend;
   unsigned short Length =0;	
	
   *pIDOut= (ULONG )CCO_E_SYSTEM_ERROR;
   //Validate the Input
   if ((!puAudioFormatList && uAudNumEntries > 0 ) || (!puVideoFormatList && uVidNumEntries > 0 ) || (uVidNumEntries == 0 && uAudNumEntries == 0 )) {
      //What error code should we return here?
      return CCO_E_SYSTEM_ERROR;
   }

   for (x=0;x<uAudNumEntries;x++)
   {
      ASSERT(pAudCaps);
      pAudCaps->IsFormatEnabled (puAudioFormatList[x],&bRecv,&bSend);
      bAllEnabled &= bRecv;

   }
   for (x=0;x<uVidNumEntries;x++) {
      ASSERT(pVidCaps);
      pVidCaps->IsFormatEnabled (puAudioFormatList[x],&bRecv,&bSend);
      bAllEnabled &= bRecv;
   }

   if (!bAllEnabled) {
      return CCO_E_INVALID_PARAM;
   }

   if (uAudNumEntries > H245_MAX_ALTCAPS || uVidNumEntries > H245_MAX_ALTCAPS) {
	  DEBUGMSG (1,("WARNING: Exceeding callcontrol limits!! \r\n"));
      return CCO_E_INVALID_PARAM;
   }

   //If this is the first call, allocate space
	if (!pAdvertisedSets){
	    pAdvertisedSets=(PCC_TERMCAPDESCRIPTORS)MemAlloc (sizeof (CC_TERMCAPDESCRIPTORS));
        if (!pAdvertisedSets){
	 		//Error code?
	 		return  CCO_E_SYSTEM_ERROR;
        }
        uAdvertizedSize = sizeof (CC_TERMCAPDESCRIPTORS);

        //Allocate space of NUM_SIMCAP_SETS
        pAdvertisedSets->pTermCapDescriptorArray=(H245_TOTCAPDESC_T **)
                MemAlloc (sizeof (H245_TOTCAPDESC_T *)*NUM_SIMCAP_SETS);
        if (!pAdvertisedSets->pTermCapDescriptorArray) {
	        //Error code?
	        return CCO_E_SYSTEM_ERROR;
        }

        //Update the indicies
        uAdvertizedSize += sizeof (H245_TOTCAPDESC_T *)*NUM_SIMCAP_SETS;
        dwNumInUse=NUM_SIMCAP_SETS;
        pAdvertisedSets->wLength=0;
    }

    //Find an Index to use.
    for (x=0;x<pAdvertisedSets->wLength;x++){
        if (pAdvertisedSets->pTermCapDescriptorArray[x] == NULL){
	        break;
        }
    }

    //Did we find space, or do we need a new one?
    if (x >= dwNumInUse) {
      	//Increment the number in use
       	dwNumInUse++;

        PVOID  pTempTermCapDescriptorArray = NULL;
        pTempTermCapDescriptorArray = MemReAlloc (pAdvertisedSets->pTermCapDescriptorArray,sizeof (H245_TOTCAPDESC_T *)*(dwNumInUse));

		if(pTempTermCapDescriptorArray)
		{
            pAdvertisedSets->pTermCapDescriptorArray = (H245_TOTCAPDESC_T **)pTempTermCapDescriptorArray;
		}
		else
		{
       		 return CCO_E_SYSTEM_ERROR;
		}

       	uAdvertizedSize += (sizeof (H245_TOTCAPDESC_T *)*(dwNumInUse))+sizeof (CC_TERMCAPDESCRIPTORS);
       	//Index is 0 based, point at the new entry
       	x=dwNumInUse-1;
    }


    //x is now the element we are using. Allocate space for a TermCapDescriptorArray
    pAdvertisedSets->pTermCapDescriptorArray[x]=(H245_TOTCAPDESC_T *)MemAlloc (sizeof (H245_TOTCAPDESC_T));
    if (!pAdvertisedSets->pTermCapDescriptorArray[x]){
        return CCO_E_SYSTEM_ERROR;
    }
    uAdvertizedSize += sizeof (H245_TOTCAPDESC_T);
    //Need to update the SetID. (start at 1)...
    pAdvertisedSets->pTermCapDescriptorArray[x]->CapDescId=++dwLastIDUsed;
    //Set the # of sets

    if((m_localT120cap != INVALID_MEDIA_FORMAT) && bT120Publicize)
    	Length++;
   	if(uVidNumEntries)
   		Length++;
   	if(uAudNumEntries)
   		Length++;
    pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.Length= Length;

   //Copy the Audio into SimCapArray[0], Video into SimCapArray[1] (if both)

    if ((uVidNumEntries > 0 && uAudNumEntries > 0)) {
        pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[0].Length=(unsigned short)uAudNumEntries;
        pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[1].Length=(unsigned short)uVidNumEntries;
        if((m_localT120cap != INVALID_MEDIA_FORMAT) && bT120Publicize)
	        pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[2].Length=1;
        //Copy the format IDs
        for (y=0;y<uAudNumEntries;y++) {
            pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[0].AltCaps[y]=(USHORT)puAudioFormatList[y];
        }
        for (y=0;y<uVidNumEntries;y++) {
	        pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[1].AltCaps[y]=(USHORT)puVideoFormatList[y];
        }
        if((m_localT120cap != INVALID_MEDIA_FORMAT)  && bT120Publicize)
	        pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[2].AltCaps[0]= (H245_CAPID_T)m_localT120cap;


   } else {
        if (uAudNumEntries > 0)  {
            pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[0].Length=(unsigned short)uAudNumEntries;
            if((m_localT120cap != INVALID_MEDIA_FORMAT) && bT120Publicize)
		        pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[1].Length=1;
	        //Copy Audio only
	        for (y=0;y<uAudNumEntries;y++) {
	            pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[0].AltCaps[y]=(USHORT)puAudioFormatList[y];
	        }
	        if((m_localT120cap != INVALID_MEDIA_FORMAT)  && bT120Publicize)	
		        pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[1].AltCaps[0]= (H245_CAPID_T)m_localT120cap;

        } else {
	        pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[0].Length=(unsigned short)uVidNumEntries;
            if((m_localT120cap != INVALID_MEDIA_FORMAT)  && bT120Publicize)
		        pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[1].Length=1;

	        //copy video entries
	        for (y=0;y<uVidNumEntries;y++) {
	            pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[0].AltCaps[y]=(USHORT)puVideoFormatList[y];
	        }
	        if((m_localT120cap != INVALID_MEDIA_FORMAT)  && bT120Publicize)
		        pAdvertisedSets->pTermCapDescriptorArray[x]->CapDesc.SimCapArray[1].AltCaps[0]= (H245_CAPID_T)m_localT120cap;
        }
   }

   //Need to update the wLength
   pAdvertisedSets->wLength++;
   *pIDOut=dwLastIDUsed;

   return hrSuccess;
}


HRESULT CapsCtl::RemoveCombinedEntry (DWORD ID)
{

   DWORD x;

   if (!pAdvertisedSets) {
      return CAPS_E_INVALID_PARAM;
   }

   for (x=0;x<dwNumInUse;x++) {
      if (pAdvertisedSets->pTermCapDescriptorArray[x]) {

		if (pAdvertisedSets->pTermCapDescriptorArray[x]->CapDescId == ID) {
		   //Found the one to remove
		   MemFree ((VOID *)pAdvertisedSets->pTermCapDescriptorArray[x]);
		   uAdvertizedSize -= sizeof (H245_TOTCAPDESC_T *);
		   if (x != (dwNumInUse -1)) {
			  //Not the last one, swap the two pointers
			  pAdvertisedSets->pTermCapDescriptorArray[x]=pAdvertisedSets->pTermCapDescriptorArray[dwNumInUse-1];
			  pAdvertisedSets->pTermCapDescriptorArray[dwNumInUse-1]=NULL;
		   }

		   //Decrement the number in use, and set the wLengthField
		   dwNumInUse--;
		   pAdvertisedSets->wLength--;
		   return hrSuccess;
		}
	  }
   }


   //Shouldn't get here, unless it was not found.
   return CAPS_E_NOCAPS;
}


// Given a sized list of capability IDs (pointer to array of H245_CAPID_T)
// and a sized list of alternate capabilities (AltCaps) within a single simultaneous
// capability set, (pointer to an array of pointers to H245_SIMCAP_T)
// Determine if the entire list of capability IDs can simultaneously coexist
// with respect to the given set of AltCaps.

BOOL CapsCtl::AreSimCaps(
	H245_CAPID_T* pIDArray, UINT uIDArraySize,
	H245_SIMCAP_T **ppAltCapArray,UINT uAltCapArraySize)
{
	UINT i, u;
	SHORT j;
	BOOL bSim;
	
	H245_SIMCAP_T *pAltCapEntry, *pFirstAltCapEntry;

	// If there are fewer AltCaps than capabilities, doom is obvious.  Don't bother searching.
	if(uAltCapArraySize < uIDArraySize)
		return FALSE;
	
	// find an altcaps entry containing the first ID in the list
	for (i=0;i<uAltCapArraySize;i++)
	{
		pAltCapEntry = *(ppAltCapArray+i);
		// scan this altcaps entry for a matching ID
		for(j=0;j<pAltCapEntry->Length;j++)
		{
			if(*pIDArray == pAltCapEntry->AltCaps[j])
			{
				// found a spot for this capability!
				if(uIDArraySize ==1)
					return TRUE; // Done! all the capabilities have been found to coexist
		
				// Otherwise, look for the next capability in the *remaining* AltCaps
				// *This* AltCaps contains the capability we were looking for
				// So, we "used up" this AltCaps and can't select from it anymore

				// Pack the array of H245_SIMCAP_T pointers in place so that
				// "used" entries are at the beginning and "unused" at the end
				// (a la shell sort swap pointers)
				if(i != 0)	// if not already the same, swap
				{
					pFirstAltCapEntry = *ppAltCapArray;
					*ppAltCapArray = pAltCapEntry;
					*(ppAltCapArray+i) = pFirstAltCapEntry;
				}
				// continue the quest using the remaining capabilities
				// and the remaining AltCaps
				bSim = AreSimCaps(pIDArray + 1, uIDArraySize - 1,
					ppAltCapArray + 1,  uAltCapArraySize - 1);
				
				if(bSim)		
				{
					return bSim;// success
				}
				else	// why not?  Either a fit does not exist (common), or the altcaps contain
						// an odd pattern of multiple instances of some capability IDs, and another
						// search order *might* fit.  Do not blindly try all permutations of search
						// order.
				{
					// If it failed simply because the recently grabbed slot in the altcaps
					// (the one in *(ppAltCapArray+i)) could have been needed by subsequent
					// capability IDs, give this one up and look for another instance.
					// If not, we know for sure that the n! approach will not yield
					// fruit and can be avoided.
					for(u=1;(bSim == FALSE)&&(u<uAltCapArraySize);u++)
					{
						for(j=0;(bSim == FALSE)&&(j<pAltCapEntry->Length);j++)
						{	// another capability needed the altcaps we grabbed ?
							if(*(pIDArray+u) == pAltCapEntry->AltCaps[j])	
							{	
								bSim=TRUE;
								break;	// look no more here, bail to try again	because a fit *might* exist
							}
						}
					}
					if(bSim)	// going to continue searching - Swap pointers back if they were swapped above
					{
						if(i != 0)	// if not the same, swap back
						{
							*ppAltCapArray = *(ppAltCapArray+i);
							*(ppAltCapArray+i) = pAltCapEntry;
						}		
						break;	// next i
					}
					else	// don't waste CPU - a fit does not exist
					{
						return bSim;
					}
				}
			}
		}
	}
	return FALSE;
}

// Given a sized list of capability IDs (pointer to array of H245_CAPID_T)
// and a list of simultaneous capabilities, try each simultaneous capability
// and determine if the entire list of capability IDs can simultaneously coexist.
BOOL CapsCtl::TestSimultaneousCaps(H245_CAPID_T* pIDArray, UINT uIDArraySize,
	PCC_TERMCAPDESCRIPTORS pTermCaps)
{
	int iSimSet, iAltSet;
	BOOL bResolved = FALSE;
	H245_SIMCAP_T * pAltCapArray[H245_MAX_SIMCAPS];
	
    if (!pAdvertisedSets)
        return(TRUE);

	// try each independent local SimCaps set (each descriptor) until success
	for (iSimSet=0; (bResolved == FALSE) && (iSimSet < pTermCaps->wLength);iSimSet++)
	{
		// EXTRA STEP:
		// Build a sortable representation of the AltCaps set.  This step will not be necessary if
		// and when we change the native representation of a capability descriptor to a variable
		// length list of pointers to AltCaps.  In the meantime, we know that there are no more
		// than H245_MAX_SIMCAPS AltCaps in this SimCaps.  This is imposed by the 2 dimensional
		// arrays of hardcoded size forced upon us by CALLCONT.DLL.
		for (iAltSet=0;iAltSet < pTermCaps->pTermCapDescriptorArray[iSimSet]->CapDesc.Length;iAltSet++)
		{
			pAltCapArray[iAltSet] = &pTermCaps->pTermCapDescriptorArray[iSimSet]->CapDesc.SimCapArray[iAltSet];
	   	}
		// do the work		
		bResolved = AreSimCaps(pIDArray, uIDArraySize,
			(H245_SIMCAP_T **)pAltCapArray,
			MAKELONG(pTermCaps->pTermCapDescriptorArray[iSimSet]->CapDesc.Length, 0));
	}

	return bResolved;
}

// Function: CapsCtl::ResolvePermutations(PRES_CONTEXT pResContext, UINT uNumFixedColumns)
//
// This functions as both a combination generator and a validation mechanism for the
// combinations it generates.
//
// Given a pointer to a resolution context and the number of fixed (i.e. not permutable,
// if "permutable" is even a real word) columns, generate one combination at a time.
// Try each combination until a working combination is found or until all combinations
// have been tried.
//
// The resolution context structure contains a variable number of columns of variable
// length media format ID lists. Each column tracks its current index.  When this
// function returns TRUE, the winning combination is indicated by the current column
// indices.
//
// The caller can control which combinations are tried first by arranging the columns
// in descending importance.
//
// Incremental searches can be performed without redundant comparisons by adding 1 format
// at a time to a column, arranging the column order so that the appended column is
// first, and "fixing" that one column at the newly added format. For example,
// some calling function could force evaluations on a round-robin column basis by
// calling this function inside a loop which does the following:
//		1 - adds one format at a time to the rightmost column and sets the current index
//			of that column to the new entry
// 		2 - rotates the column order so that the rightmost column is now the leftmost
//  	3 - fixing the new leftmost column before calling this function again
//	The result will be that only the permutations which contain the newly added format
// 	will be generated.


BOOL CapsCtl::ResolvePermutations(PRES_CONTEXT pResContext, UINT uNumFixedColumns)
{
	RES_PAIR *pResolvedPair;
	BOOL bResolved = FALSE;
	UINT i, uColumns;
	UINT uPairIndex;

	// converge on one combination in the permutation
	if(uNumFixedColumns != pResContext->uColumns)
	{
		RES_PAIR_LIST *pThisColumn;
		// take the first non-fixed column, make that column fixed and
		// iterate on it (loop through indices), and try each sub-permutation
		// of remaining columns.  (until success or all permutations tried)
		
		pThisColumn = *(pResContext->ppPairLists+uNumFixedColumns);
		for (i=0; (bResolved == FALSE) && (i<pThisColumn->uSize); i++)
		{
			pThisColumn->uCurrentIndex = i;
			bResolved = ResolvePermutations(pResContext, uNumFixedColumns+1);
		}
		return bResolved;
	}
	else
	{
		// Bottomed out on the final column.  Test the viability of this combination
		
		// Build array of local IDs that contians the combination and test the
		// combination against local simultaneous capabilities, then against
		// remote simultaneous capabilities
		
		// NOTE: be sure to skip empty columns (which represent unresolvable
		// or unsupported/nonexistent media types or unsupported additional
		// instances of media types)
		
		for(i=0, uColumns=0;i<pResContext->uColumns;i++)
		{
			if(((*pResContext->ppPairLists)+i)->uSize)
			{
				// get index (row #) for this column
				uPairIndex = ((*pResContext->ppPairLists)+i)->uCurrentIndex;
				// get the row
				pResolvedPair =  ((*pResContext->ppPairLists)+i)->pResolvedPairs+uPairIndex;
				// add the ID to the array
				*(pResContext->pIDScratch+uColumns) = (H245_CAPID_T)pResolvedPair->idPublicLocal;
				uColumns++;
			}
			// else empty column
		}
		// Determine if this combination can exist simultaneously
		if(TestSimultaneousCaps(pResContext->pIDScratch,
			uColumns, pResContext->pTermCapsLocal))
		{	
			// now test remote
			// build array of remote IDs and test those against remote
			// simultaneous capabilities
			for(i=0, uColumns=0;i<pResContext->uColumns;i++)
			{
				if(((*pResContext->ppPairLists)+i)->uSize)
				{
					// get index (row #) for this column
					uPairIndex = ((*pResContext->ppPairLists)+i)->uCurrentIndex;
					// get the row
					pResolvedPair =  ((*pResContext->ppPairLists)+i)->pResolvedPairs+uPairIndex;
					// add the ID to the array
					*(pResContext->pIDScratch+uColumns) =(H245_CAPID_T) pResolvedPair->idRemote;
					uColumns++;
				}
				// else empty column
			}
			bResolved = TestSimultaneousCaps(pResContext->pIDScratch,
				uColumns, pResContext->pTermCapsRemote);
		}
					
		return bResolved;		
		// if(bResolved == TRUE)
			// The resolved combination of pairs is indicated by the current indices
			// of **ppPairList;
	}
}

//
// Given a counted list of desired instances of media, produce an output array of
// resolved media format IDs which correspond to the input media type IDs.
// This function returns success if at least one media instance is resolved.
// When an instance of media is unresolveable, the output corresponding to that
// instance contains the value INVALID_MEDIA_FORMAT for local and remote media
// format IDs.
//
// The input is treated as being in preferential order: permutations of the latter
// media type instance are varied first. If all permutations do not yield success,
// then one media type instance at a time is removed from the end.
//

HRESULT CapsCtl::ResolveFormats (LPGUID pMediaGuidArray, UINT uNumMedia,
	PRES_PAIR pResOutput)
{
	HRESULT hr = hrSuccess;
	PRES_PAIR_LIST pResColumnArray = NULL;
	PRES_PAIR_LIST *ppPairLists;
	RES_PAIR *pResPair;
	PRES_CONTEXT pResContext;
	LPIH323MediaCap pMediaResolver;
	UINT i;
	UINT uMaxFormats = 0;
	UINT uFixedColumns =0;
	UINT uFailedMediaCount = 0;
	BOOL bResolved = FALSE;
	
	RES_PAIR UnresolvedPair = {INVALID_MEDIA_FORMAT, INVALID_MEDIA_FORMAT, INVALID_MEDIA_FORMAT};
	// create a context structure for the resolution
	pResContext = (PRES_CONTEXT)MemAlloc(sizeof(RES_CONTEXT)+ (uNumMedia*sizeof(H245_CAPID_T)));
	if(!pResContext)
	{
		hr = CAPS_E_NOMEM;
		goto ERROR_OUT;
	}
	// initialize resolution context
	pResContext->uColumns = 0;
	pResContext->pIDScratch = (H245_CAPID_T*)(pResContext+1);
	pResContext->pTermCapsLocal = pAdvertisedSets;
	pResContext->pTermCapsRemote = pRemAdvSets;

	// allocate array of RES_PAIR_LIST (one per column/media type) and
	// array of pointers to same
	pResColumnArray = (PRES_PAIR_LIST)MemAlloc((sizeof(RES_PAIR_LIST) * uNumMedia)
		+ (sizeof(PRES_PAIR_LIST) * uNumMedia));
	if(!pResColumnArray)
	{
		hr = CAPS_E_NOMEM;
		goto ERROR_OUT;
	}
	pResContext->ppPairLists = ppPairLists = (PRES_PAIR_LIST*)(pResColumnArray+uNumMedia);
			
	// build columns of media capabilities
	for(i=0;i<uNumMedia;i++)
	{
		// build array of pointers to RES_PAIR_LIST
		*(ppPairLists+i) = pResColumnArray+i;
		// initialize RES_PAIR_LIST members
		(pResColumnArray+i)->pResolvedPairs = NULL;
		(pResColumnArray+i)->uSize =0;
		(pResColumnArray+i)->uCurrentIndex = 0;

		// Get resolver for this media. Special case: there is no T120 resolver.
		// T120 caps are handled right here in this object
		if(MEDIA_TYPE_H323_T120 == *(pMediaGuidArray+i))
		{
			pMediaResolver = NULL;
			if((m_localT120cap != INVALID_MEDIA_FORMAT) &&(m_remoteT120cap != INVALID_MEDIA_FORMAT) )
			{
				(pResColumnArray+i)->uSize =1;
				uMaxFormats = 1;	// only one T.120 cap
				
				pResPair = (pResColumnArray+i)->pResolvedPairs =
					(RES_PAIR *)MemAlloc(uMaxFormats * sizeof(RES_PAIR));
				if(!pResPair)
				{
					hr = CAPS_E_NOMEM;
					goto ERROR_OUT;
				}
				
				//
				pResPair->idLocal = m_localT120cap;
				pResPair->idRemote = m_remoteT120cap;
				pResPair->idPublicLocal = pResPair->idLocal;
			}
		}
		else
		{
			pMediaResolver = FindHostForMediaGuid(pMediaGuidArray+i);
		}
			
		pResContext->uColumns++;
		(pResColumnArray+i)->pMediaResolver = pMediaResolver;
		
		if(pMediaResolver)
		{
			uMaxFormats = pMediaResolver->GetNumCaps(FALSE);	// get transmit format count
			if(uMaxFormats)
			{
				pResPair = (pResColumnArray+i)->pResolvedPairs =
					(RES_PAIR *)MemAlloc(uMaxFormats * sizeof(RES_PAIR));
				if(!pResPair)
				{
					hr = CAPS_E_NOMEM;
					goto ERROR_OUT;
				}
				
				// resolve the best choice for each media type (gotta start somewhere)
				pResPair->idLocal = INVALID_MEDIA_FORMAT;
				pResPair->idRemote = INVALID_MEDIA_FORMAT;		
				hr=pMediaResolver->ResolveEncodeFormat (&pResPair->idLocal,&pResPair->idRemote);
				if(!HR_SUCCEEDED(hr))
				{
					if((hr == CAPS_W_NO_MORE_FORMATS)	
						|| (hr == CAPS_E_NOMATCH)
						|| (hr == CAPS_E_NOCAPS))
					{	
						// No resolved format for this media type.  Remove this "column"
						(pResColumnArray+i)->pResolvedPairs = NULL;
						MemFree(pResPair);
						(pResColumnArray+i)->uSize =0;

						hr = hrSuccess;
					}
					else
					{
						goto ERROR_OUT;
					}
				}
				else
				{
					// this column has one resolved format
					pResPair->idPublicLocal = pMediaResolver->GetPublicID(pResPair->idLocal);
					(pResColumnArray+i)->uSize =1;
				}
			}
			// else // No formats exist for this media type.  this "column" has zero size
		}
	}

	// Special case test simultaneous caps for the most preferred combination:
	uFixedColumns = pResContext->uColumns;	// << make all columns fixed
	bResolved = ResolvePermutations(pResContext, uFixedColumns);

	// if the single most preferred combination can't be used, need to handle
	// the general case and try permutations until a workable combination is found
	while(!bResolved)
	{
		// make one column at a time permutable, starting with the least-critical media
		// type.  (e.g. it would be typical for the last column to be video because
		// audio+data are more important. Then we try less and less
		// preferable video formats before doing anything that would degrade the audio)

		if(uFixedColumns > 0)	// if not already at the end of the rope...
		{
			uFixedColumns--;	// make another column permutable
		}
		else
		{
			// wow - tried all permutations and still no luck ......
			// nuke the least important remaining media type (e.g. try it w/o video)
			if(pResContext->uColumns <= 1)	// already down to one media type?
			{
				hr = CAPS_E_NOMATCH;
				goto ERROR_OUT;
			}
			// Remove the end column (representing the least important media type)
			// and try it with the remaining columns			
			uFixedColumns = --pResContext->uColumns; 	// one less column

			// set the formats of the nuked column to the unresolved state
			(pResColumnArray+uFixedColumns)->uSize =0;
			(pResColumnArray+uFixedColumns)->uCurrentIndex =0;
			pResPair = (pResColumnArray+uFixedColumns)->pResolvedPairs;
			if (NULL != pResPair)
			{
				pResPair->idLocal = INVALID_MEDIA_FORMAT;
				pResPair->idRemote = INVALID_MEDIA_FORMAT;
				pResPair->idPublicLocal = INVALID_MEDIA_FORMAT;
			}

			uFailedMediaCount++;	// track the nuking of a column to avoid
									// redundantly grabbing all the formats again
									// ... would not be here if all permutations
									// had not been tried!
			// reset the combination indices
			for(i=0;i<uFixedColumns;i++)
			{
				(pResColumnArray+i)->uCurrentIndex = 0;
			}
		}
		
		// get the rest of the formats for the last known fixed column, make that column
		// permutable, etc.
		pMediaResolver = (pResColumnArray+uFixedColumns)->pMediaResolver;
		if(!pMediaResolver || ((pResColumnArray+uFixedColumns)->uSize ==0))
		{
			continue;	// this media type has no further possibility
		}

 		if(uFailedMediaCount ==0)	// If all of the possible resolved pairs
 									// have not yet been obtained, get them!
 		{
 			// get resolved pair IDs for every mutual format of this media type
			// first: get pointer to array of pair IDs, then use ResolveEncodeFormat()
			// to fill up the array
			pResPair =  (pResColumnArray+uFixedColumns)->pResolvedPairs;
			// Get total # of formats less the one that was already obtained
			uMaxFormats = pMediaResolver->GetNumCaps(FALSE) -1;	
			
			while(uMaxFormats--)	// never exceed the # of remaining local formats...
			{
				RES_PAIR *pResPairNext;
						
				// recall that ResolveEncodeFormat parameters are I/O - the input
				// is the local ID of the last resolved mutual format.  (remote id
				// is ignored as input).  Fixup the input.
				pResPairNext = pResPair+1;
				// start where the previous resolve stopped
				pResPairNext->idLocal = pResPair->idLocal;	
				// not necessary, ignored ->>> pResPairNext->idRemote = pResPair->idRemote
				pResPair = pResPairNext;
				hr=pMediaResolver->ResolveEncodeFormat (&pResPair->idLocal,&pResPair->idRemote);
				if((hr == CAPS_W_NO_MORE_FORMATS)	
					|| (hr == CAPS_E_NOMATCH))
				// got all of the formats, but not an error
				{	// this is likely when less than 100% of local formats have a remote match
					hr = hrSuccess;
					break;
				}	
				if(!HR_SUCCEEDED(hr))
					goto ERROR_OUT;

				// get the public ID of the local format (it's *usually* the same, but not always)
				pResPair->idPublicLocal = pMediaResolver->GetPublicID(pResPair->idLocal);
				// this column has another format - count it!
				(pResColumnArray+uFixedColumns)->uSize++;
			}
		}
		// now try the new permutations
		bResolved = ResolvePermutations(pResContext, uFixedColumns);
	}
	if(bResolved)
	{
		// spew the output
		for(i=0;i<uNumMedia;i++)
		{
			if((pResColumnArray+i)->uSize)
			{
				pResPair = (pResColumnArray+i)->pResolvedPairs
					+ (pResColumnArray+i)->uCurrentIndex;
			}
			else
			{
				pResPair = &UnresolvedPair;

			}
			*(pResOutput+i) = *pResPair;
		}
	}
	else
	{
		// if there was some error, preserve that error code,
		if(HR_SUCCEEDED(hr))	
		// otherwise the error is....
			hr = CAPS_E_NOMATCH;		
	}

ERROR_OUT:	// well, the success case falls out here too
	if(pResColumnArray)
	{
		for(i=0;i<uNumMedia;i++)
		{	
			if((pResColumnArray+i)->pResolvedPairs)
				MemFree((pResColumnArray+i)->pResolvedPairs);
		}
		MemFree(pResColumnArray);
	}
	if(pResContext)
	{
		MemFree(pResContext);
	}
	return hr;
}

HRESULT CapsCtl::ResetCombinedEntries (void)
{
    DWORD x;

    if (pAdvertisedSets)
    {
        for (x = 0; x < pAdvertisedSets->wLength; x++)
        {
            if (pAdvertisedSets->pTermCapDescriptorArray[x])
            {
	    	    MemFree (pAdvertisedSets->pTermCapDescriptorArray[x]);
            }
        }
        MemFree (pAdvertisedSets->pTermCapDescriptorArray);

        pAdvertisedSets->wLength=0;
        MemFree (pAdvertisedSets);
        pAdvertisedSets = NULL;
    }

    if (pSetIDs)
    {
        MemFree(pSetIDs);
        pSetIDs = NULL;
    }

    dwNumInUse=0;
    uAdvertizedSize=0;

    return hrSuccess;
}