diff options
Diffstat (limited to 'addons/ooh323c/src/ooCapability.c')
| -rw-r--r-- | addons/ooh323c/src/ooCapability.c | 2349 |
1 files changed, 2349 insertions, 0 deletions
diff --git a/addons/ooh323c/src/ooCapability.c b/addons/ooh323c/src/ooCapability.c new file mode 100644 index 000000000..aeecbee10 --- /dev/null +++ b/addons/ooh323c/src/ooCapability.c @@ -0,0 +1,2349 @@ +/* + * Copyright (C) 2004-2005 by Objective Systems, Inc. + * + * This software is furnished under an open source license and may be + * used and copied only in accordance with the terms of this license. + * The text of the license may generally be found in the root + * directory of this installation in the COPYING file. It + * can also be viewed online at the following URL: + * + * http://www.obj-sys.com/open/license.html + * + * Any redistributions of this file including modified versions must + * maintain this copyright notice. + * + *****************************************************************************/ +#include "ooCapability.h" +#include "ootrace.h" +#include "ooCalls.h" +#include "ooh323ep.h" +#include "ooUtils.h" +/** Global endpoint structure */ +extern OOH323EndPoint gH323ep; + +static int giDynamicRTPPayloadType = 101; + +int ooCapabilityEnableDTMFRFC2833 + (OOH323CallData *call, int dynamicRTPPayloadType) +{ + if(!call) + { + gH323ep.dtmfmode |= OO_CAP_DTMF_RFC2833; + OOTRACEINFO1("Enabled RFC2833 DTMF capability for end-point\n"); + } + else{ + call->dtmfmode |= OO_CAP_DTMF_RFC2833; + OOTRACEINFO3("Enabled RFC2833 DTMF capability for (%s, %s) \n", + call->callType, call->callToken); + } + + /*Dynamic RTP payload type range is from 96 - 127 */ + if(dynamicRTPPayloadType >= 96 && dynamicRTPPayloadType <= 127) + giDynamicRTPPayloadType = dynamicRTPPayloadType; + + return OO_OK; +} + + + +int ooCapabilityDisableDTMFRFC2833(OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode ^= OO_CAP_DTMF_RFC2833; + OOTRACEINFO1("Disabled RFC2833 DTMF capability for end-point\n"); + } + else{ + call->dtmfmode ^= OO_CAP_DTMF_RFC2833; + OOTRACEINFO3("Disabled RFC2833 DTMF capability for (%s, %s)\n", + call->callType, call->callToken); + } + + return OO_OK; +} + +int ooCapabilityEnableDTMFH245Alphanumeric(OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode |= OO_CAP_DTMF_H245_alphanumeric; + OOTRACEINFO1("Dtmf mode set to H.245(alphanumeric) for endpoint\n"); + } + else { + call->dtmfmode |= OO_CAP_DTMF_H245_alphanumeric; + OOTRACEINFO3("Dtmf mode set to H.245(alphanumeric) for (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityDisableDTMFH245Alphanumeric(OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode ^= OO_CAP_DTMF_H245_alphanumeric; + OOTRACEINFO1("Dtmf mode H.245(alphanumeric) disabled for endpoint\n"); + } + else { + call->dtmfmode ^= OO_CAP_DTMF_H245_alphanumeric; + OOTRACEINFO3("Dtmf mode H.245(alphanumeric) disabled for (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityEnableDTMFH245Signal(OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode |= OO_CAP_DTMF_H245_signal; + OOTRACEINFO1("Dtmf mode set to H.245(signal) for endpoint\n"); + } + else { + call->dtmfmode |= OO_CAP_DTMF_H245_signal; + OOTRACEINFO3("Dtmf mode set to H.245(signal) for (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityDisableDTMFH245Signal(OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode ^= OO_CAP_DTMF_H245_signal; + OOTRACEINFO1("Dtmf mode H.245(signal) disabled for endpoint\n"); + } + else { + call->dtmfmode ^= OO_CAP_DTMF_H245_signal; + OOTRACEINFO3("Dtmf mode H.245(signal) disabled for (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityEnableDTMFQ931Keypad(struct OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode |= OO_CAP_DTMF_Q931; + OOTRACEINFO1("Dtmf mode set to Q.931(keypad) for the endpoint\n"); + } + else { + call->dtmfmode |= OO_CAP_DTMF_Q931; + OOTRACEINFO3("Dtmf mode set to Q.931(keypad) for the call (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityDisableDTMFQ931Keypad(struct OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode ^= OO_CAP_DTMF_Q931; + OOTRACEINFO1("Dtmf mode Q.931(keypad) disabled for the endpoint\n"); + } + else { + call->dtmfmode ^= OO_CAP_DTMF_Q931; + OOTRACEINFO3("Dtmf mode Q.931(keypad) disabled for the call (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityAddH263VideoCapability(ooCallData *call, + unsigned sqcifMPI, unsigned qcifMPI, + unsigned cifMPI, unsigned cif4MPI, + unsigned cif16MPI, unsigned maxBitRate, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote) +{ + int ret = OO_OK; + if(sqcifMPI>0) + { + ret = ooCapabilityAddH263VideoCapability_helper(call, sqcifMPI, 0, + 0, 0, 0, maxBitRate, dir, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, remote); + if(ret != OO_OK) + { + OOTRACEERR1("Error: Failed to add H263 sqcifMPI capability\n"); + return OO_FAILED; + } + } + if(qcifMPI>0) + { + ret = ooCapabilityAddH263VideoCapability_helper(call, 0, qcifMPI, 0, + 0, 0, maxBitRate, dir, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, remote); + if(ret != OO_OK) + { + OOTRACEERR1("Error: Failed to add H263 qcifMPI capability\n"); + return OO_FAILED; + } + } + if(cifMPI>0) + { + ret = ooCapabilityAddH263VideoCapability_helper(call, 0, 0, cifMPI, + 0, 0, maxBitRate, dir, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, remote); + if(ret != OO_OK) + { + OOTRACEERR1("Error: Failed to add H263 cifMPI capability\n"); + return OO_FAILED; + } + } + if(cif4MPI>0) + { + ret = ooCapabilityAddH263VideoCapability_helper(call, 0, 0, 0, + cif4MPI, 0, maxBitRate, dir, + startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, remote); + if(ret != OO_OK) + { + OOTRACEERR1("Error: Failed to add H263 cif4MPI capability\n"); + return OO_FAILED; + } + } + if(cif16MPI>0) + { + ret = ooCapabilityAddH263VideoCapability_helper(call, dir, 0, 0, 0, 0, + cif16MPI, maxBitRate, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, remote); + if(ret != OO_OK) + { + OOTRACEERR1("Error: Failed to add H263 cif16MPI capability\n"); + return OO_FAILED; + } + } + return OO_OK; + +} + +int ooCapabilityAddH263VideoCapability_helper(ooCallData *call, + unsigned sqcifMPI, unsigned qcifMPI, + unsigned cifMPI, unsigned cif4MPI, + unsigned cif16MPI, unsigned maxBitRate, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote) +{ + + ooH323EpCapability *epCap = NULL, *cur=NULL; + OOH263CapParams *params=NULL; + OOCTXT *pctxt=NULL; + char *pictureType = NULL; + int cap = OO_H263VIDEO; + + if(!call) pctxt = &gH323ep.ctxt; + else pctxt = call->pctxt; + + epCap = (ooH323EpCapability*)memAllocZ(pctxt, sizeof(ooH323EpCapability)); + params = (OOH263CapParams*) memAllocZ(pctxt, sizeof(OOH263CapParams)); + if(!epCap || !params) + { + OOTRACEERR1("Error:Memory - ooCapabilityAddH263Capability - epCap/params" + ".\n"); + return OO_FAILED; + } + + if(sqcifMPI>0) + { + params->MPI = sqcifMPI; + params->picFormat = OO_PICFORMAT_SQCIF; + pictureType = "SQCIF"; + } + if(qcifMPI>0) + { + params->MPI = qcifMPI; + params->picFormat = OO_PICFORMAT_QCIF; + pictureType = "QCIF"; + } + if(cifMPI>0) + { + params->MPI = cifMPI; + params->picFormat = OO_PICFORMAT_CIF; + pictureType = "CIF"; + } + if(cif4MPI>0) + { + params->MPI = cif4MPI; + params->picFormat = OO_PICFORMAT_CIF4; + pictureType = "CIF4"; + } + if(cif16MPI>0) + { + params->MPI = cif16MPI; + params->picFormat = OO_PICFORMAT_CIF16; + pictureType = "CIF16"; + } + + params->maxBitRate = maxBitRate; + + + if(dir & OORXANDTX) + { + epCap->dir = OORX; + epCap->dir |= OOTX; + } + else + epCap->dir = dir; + + epCap->cap = OO_H263VIDEO; + epCap->capType = OO_CAP_TYPE_VIDEO; + epCap->params = (void*)params; + epCap->startReceiveChannel = startReceiveChannel; + epCap->startTransmitChannel = startTransmitChannel; + epCap->stopReceiveChannel = stopReceiveChannel; + epCap->stopTransmitChannel = stopTransmitChannel; + + epCap->next = NULL; + + if(!call) + {/*Add as local capability */ + OOTRACEDBGC2("Adding endpoint H263 video capability %s.\n", pictureType); + if(!gH323ep.myCaps) + gH323ep.myCaps = epCap; + else{ + cur = gH323ep.myCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(NULL, cap); + gH323ep.noOfCaps++; + } + else{ + if(remote) + { + /*Add as remote capability */ + if(!call->remoteCaps) + call->remoteCaps = epCap; + else{ + cur = call->remoteCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + } + else{ + /*Add as our capability */ + OOTRACEDBGC4("Adding call specific H263 video capability %s. " + "(%s, %s)\n", pictureType, call->callType, + call->callToken); + if(!call->ourCaps){ + call->ourCaps = epCap; + ooResetCapPrefs(call); + } + else{ + cur = call->ourCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(call, cap); + } + } + + return OO_OK; +} + +/* Used for g711 ulaw/alaw, g728, g729 and g7231 */ +int ooCapabilityAddSimpleCapability + (OOH323CallData *call, int cap, int txframes, + int rxframes, OOBOOL silenceSuppression, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote) +{ + ooH323EpCapability *epCap = NULL, *cur=NULL; + OOCapParams *params=NULL; + OOCTXT *pctxt=NULL; + if(!call) pctxt = &gH323ep.ctxt; + else pctxt = call->pctxt; + + epCap = (ooH323EpCapability*)memAlloc(pctxt, sizeof(ooH323EpCapability)); + params = (OOCapParams*) memAlloc(pctxt, sizeof(OOCapParams)); + if(!epCap || !params) + { + OOTRACEERR1("ERROR: Memory - ooCapabilityAddSimpleCapability - " + "epCap/params\n"); + return OO_FAILED; + } + + + params->txframes = txframes; + params->rxframes = rxframes; + /* Ignore silence suppression parameter unless cap is g7231 */ + if(cap == OO_G7231) + params->silenceSuppression = silenceSuppression; + else + params->silenceSuppression = FALSE; /* Set to false for g711 and g729*/ + + if(dir & OORXANDTX) { + epCap->dir = OORX; + epCap->dir |= OOTX; + } + else { + epCap->dir = dir; + } + + epCap->cap = cap; + epCap->capType = OO_CAP_TYPE_AUDIO; + epCap->params = (void*)params; + epCap->startReceiveChannel = startReceiveChannel; + epCap->startTransmitChannel = startTransmitChannel; + epCap->stopReceiveChannel = stopReceiveChannel; + epCap->stopTransmitChannel = stopTransmitChannel; + epCap->next = NULL; + + if(!call) + { + /* Add as local capability */ + OOTRACEDBGC2("Adding endpoint capability %s. \n", + ooGetCapTypeText(epCap->cap)); + if(!gH323ep.myCaps) { + gH323ep.myCaps = epCap; + } + else{ + cur = gH323ep.myCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(NULL, cap); + gH323ep.noOfCaps++; + } + else{ + if(remote) + { + /* Add as remote capability */ + if(!call->remoteCaps) { + call->remoteCaps = epCap; + } + else{ + cur = call->remoteCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + } + else{ + /* Add as our capability */ + OOTRACEDBGC4("Adding call specific capability %s. (%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, + call->callToken); + if(!call->ourCaps){ + call->ourCaps = epCap; + ooResetCapPrefs(call); + } + else{ + cur = call->ourCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(call, cap); + } + } + + return OO_OK; +} + + +int ooCapabilityAddGSMCapability(OOH323CallData *call, int cap, + unsigned framesPerPkt, OOBOOL comfortNoise, + OOBOOL scrambled, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote) +{ + + ooH323EpCapability *epCap = NULL, *cur=NULL; + OOGSMCapParams *params=NULL; + OOCTXT *pctxt = NULL; + + if(!call) pctxt = &gH323ep.ctxt; + else pctxt = call->pctxt; + + epCap = (ooH323EpCapability*)memAlloc(pctxt, sizeof(ooH323EpCapability)); + params = (OOGSMCapParams*) memAlloc(pctxt, sizeof(OOGSMCapParams)); + if(!epCap || !params) + { + OOTRACEERR1("Error:Memory - ooCapabilityAddGSMCapability - " + "epCap/params\n"); + return OO_FAILED; + } + + + params->rxframes = framesPerPkt; + params->txframes = framesPerPkt; + params->comfortNoise = comfortNoise; + params->scrambled = scrambled; + if(dir & OORXANDTX) + { + epCap->dir = OORX; + epCap->dir |= OOTX; + } + else + epCap->dir = dir; + + epCap->cap = cap; + epCap->capType = OO_CAP_TYPE_AUDIO; + epCap->params = (void*)params; + epCap->startReceiveChannel = startReceiveChannel; + epCap->startTransmitChannel = startTransmitChannel; + epCap->stopReceiveChannel = stopReceiveChannel; + epCap->stopTransmitChannel = stopTransmitChannel; + + epCap->next = NULL; + /* Add as local capability */ + if(!call) + { + if(!gH323ep.myCaps) + gH323ep.myCaps = epCap; + else{ + cur = gH323ep.myCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(NULL, cap); + gH323ep.noOfCaps++; + } + else{ + if(remote) + { + /*Add as remote capability */ + if(!call->remoteCaps) + call->remoteCaps = epCap; + else{ + cur = call->remoteCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + } + else{ + OOTRACEDBGC4("Adding call specific capability %s. (%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, + call->callToken); + /*Add as our capability */ + if(!call->ourCaps){ + call->ourCaps = epCap; + ooResetCapPrefs(call); + } + else{ + cur = call->ourCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(call, cap); + } + } + + return OO_OK; +} + + + + +struct H245VideoCapability* ooCapabilityCreateVideoCapability + (ooH323EpCapability *epCap, OOCTXT *pctxt, int dir) +{ + + if(!epCap) + { + OOTRACEERR1("Error:Invalid capability parameter passed to " + "ooCapabilityCreateVideoCapability.\n"); + return NULL; + } + + if(!(epCap->dir & dir)) + { + OOTRACEERR1("Error:Failed to create capability due to direction " + "mismatch.\n"); + return NULL; + } + + switch(epCap->cap) + { + case OO_H263VIDEO: + return ooCapabilityCreateH263VideoCapability(epCap, pctxt, dir); + + case OO_NONSTDVIDEO: + case OO_H261VIDEO: + case OO_H262VIDEO: + case OO_IS11172VIDEO: + case OO_GENERICVIDEO: + case OO_EXTELEMVIDEO: + default: + OOTRACEERR2("ERROR: Don't know how to create video capability %s\n", + ooGetCapTypeText(epCap->cap)); + } + return NULL; +} + + + +struct H245AudioCapability* ooCapabilityCreateAudioCapability + (ooH323EpCapability *epCap, OOCTXT *pctxt, int dir) +{ + + if(!epCap) + { + OOTRACEERR1("Error:Invalid capability parameter passed to " + "ooCapabilityCreateAudioCapability.\n"); + return NULL; + } + + if(!(epCap->dir & dir)) + { + OOTRACEERR1("Error:Failed to create capability due to direction " + "mismatch.\n"); + return NULL; + } + + switch(epCap->cap) + { + case OO_G711ALAW64K: + case OO_G711ALAW56K: + case OO_G711ULAW64K: + case OO_G711ULAW56K: + /*case OO_G726:*/ + case OO_G728: + case OO_G729: + case OO_G729A: + case OO_G7231: + return ooCapabilityCreateSimpleCapability(epCap, pctxt, dir); + case OO_GSMFULLRATE: + return ooCapabilityCreateGSMFullRateCapability(epCap, pctxt, dir); + default: + OOTRACEERR2("ERROR: Don't know how to create audio capability %d\n", + epCap->cap); + } + return NULL; +} + + + +void* ooCapabilityCreateDTMFCapability(int cap, OOCTXT *pctxt) +{ + H245AudioTelephonyEventCapability *pATECap=NULL; + H245UserInputCapability *userInput = NULL; + char *events=NULL; + switch(cap) + { + case OO_CAP_DTMF_RFC2833: + pATECap = (H245AudioTelephonyEventCapability*)memAlloc(pctxt, + sizeof(H245AudioTelephonyEventCapability)); + if(!pATECap) + { + OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - pATECap\n"); + return NULL; + } + memset(pATECap, 0, sizeof(H245AudioTelephonyEventCapability)); + pATECap->dynamicRTPPayloadType = giDynamicRTPPayloadType; + events = (char*)memAlloc(pctxt, strlen("0-16")+1); + if(!events) + { + OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - events\n"); + memFreePtr(pctxt, pATECap); + return NULL; + } + strncpy(events, "0-16", strlen("0-16")); + pATECap->audioTelephoneEvent = events; + return pATECap; + case OO_CAP_DTMF_H245_alphanumeric: + userInput = (H245UserInputCapability*)memAllocZ(pctxt, + sizeof(H245UserInputCapability)); + if(!userInput) + { + OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - " + "userInput\n"); + return NULL; + } + userInput->t = T_H245UserInputCapability_basicString; + return userInput; + case OO_CAP_DTMF_H245_signal: + userInput = (H245UserInputCapability*)memAllocZ(pctxt, + sizeof(H245UserInputCapability)); + if(!userInput) + { + OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - " + "userInput\n"); + return NULL; + } + userInput->t = T_H245UserInputCapability_dtmf; + return userInput; + default: + OOTRACEERR1("Error:unknown dtmf capability type\n"); + } + return NULL; +} + + + +struct H245VideoCapability* ooCapabilityCreateH263VideoCapability + (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir) +{ + H245VideoCapability *pVideo=NULL; + OOH263CapParams *params=NULL; + H245H263VideoCapability *pH263Cap=NULL; + + if(!epCap || !epCap->params) + { + OOTRACEERR1("Error:Invalid capability parameters to " + "ooCapabilityCreateH263VideoCapability.\n"); + return NULL; + } + params =(OOH263CapParams*)epCap->params; + + pVideo = (H245VideoCapability*)memAllocZ(pctxt, + sizeof(H245VideoCapability)); + pH263Cap = (H245H263VideoCapability*) memAllocZ(pctxt, + sizeof(H245H263VideoCapability)); + if(!pVideo || !pH263Cap) + { + OOTRACEERR1("ERROR:Memory - ooCapabilityCreateH263VideoCapability - " + "pVideo/pH263Cap\n"); + return NULL; + } + + pVideo->t = T_H245VideoCapability_h263VideoCapability; + pVideo->u.h263VideoCapability = pH263Cap; + + + if(params->picFormat == OO_PICFORMAT_SQCIF) { + pH263Cap->m.sqcifMPIPresent = TRUE; + pH263Cap->sqcifMPI = params->MPI; + } + else if(params->picFormat == OO_PICFORMAT_QCIF) { + pH263Cap->m.qcifMPIPresent = TRUE; + pH263Cap->qcifMPI = params->MPI; + } + else if(params->picFormat == OO_PICFORMAT_CIF) { + pH263Cap->m.cifMPIPresent = TRUE; + pH263Cap->cifMPI = params->MPI; + } + else if(params->picFormat == OO_PICFORMAT_CIF4) { + pH263Cap->m.cif4MPIPresent = TRUE; + pH263Cap->cif4MPI = params->MPI; + } + else if(params->picFormat == OO_PICFORMAT_CIF16) { + pH263Cap->m.cif16MPIPresent = TRUE; + pH263Cap->cif16MPI = params->MPI; + } + + pH263Cap->m.errorCompensationPresent = TRUE; + pH263Cap->maxBitRate = params->maxBitRate; + pH263Cap->unrestrictedVector = FALSE; + pH263Cap->arithmeticCoding = FALSE; + pH263Cap->advancedPrediction = FALSE; + pH263Cap->pbFrames = FALSE; + pH263Cap->temporalSpatialTradeOffCapability = FALSE; + pH263Cap->hrd_B = 0; + pH263Cap->bppMaxKb = 0; + pH263Cap->slowSqcifMPI = FALSE; + pH263Cap->slowQcifMPI = FALSE; + pH263Cap->slowCifMPI = FALSE; + pH263Cap->slowCif4MPI = FALSE; + pH263Cap->slowCif16MPI = FALSE; + pH263Cap->errorCompensation = FALSE; + return pVideo; +} + +struct H245AudioCapability* ooCapabilityCreateGSMFullRateCapability + (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir) +{ + H245AudioCapability *pAudio=NULL; + H245GSMAudioCapability *pGSMCap=NULL; + if(!epCap || !epCap->params) + { + OOTRACEERR1("Error:Invalid capability parameters to " + "ooCapabilityCreateGSMFullRateCapability.\n"); + return NULL; + } + + pAudio = (H245AudioCapability*)memAlloc(pctxt, + sizeof(H245AudioCapability)); + pGSMCap = (H245GSMAudioCapability*)memAlloc(pctxt, + sizeof(H245GSMAudioCapability)); + if(!pAudio || !pGSMCap) + { + OOTRACEERR1("ERROR:Memory - ooCapabilityCreateGSMFullRateCapability - " + "pAudio/pGSMCap\n"); + return NULL; + } + + pAudio->t = T_H245AudioCapability_gsmFullRate; + pAudio->u.gsmFullRate = pGSMCap; + if(dir & OORX) + pGSMCap->audioUnitSize = ((OOGSMCapParams*)epCap->params)->rxframes*OO_GSMFRAMESIZE; + else + pGSMCap->audioUnitSize = ((OOGSMCapParams*)epCap->params)->txframes*OO_GSMFRAMESIZE; + + pGSMCap->comfortNoise = ((OOGSMCapParams*)epCap->params)->comfortNoise; + pGSMCap->scrambled = ((OOGSMCapParams*)epCap->params)->scrambled; + + return pAudio; +} + +/* This is used for g711 ulaw/alaw, g728, g729, g729A, g7231*/ +struct H245AudioCapability* ooCapabilityCreateSimpleCapability + (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir) +{ + H245AudioCapability *pAudio=NULL; + OOCapParams *params; + if(!epCap || !epCap->params) + { + OOTRACEERR1("Error:Invalid capability parameters to " + "ooCapabilityCreateSimpleCapability.\n"); + return NULL; + } + params =(OOCapParams*)epCap->params; + pAudio = (H245AudioCapability*)memAlloc(pctxt, + sizeof(H245AudioCapability)); + if(!pAudio) + { + OOTRACEERR1("ERROR:Memory - ooCapabilityCreateSimpleCapability - pAudio\n"); + return NULL; + } + + + switch(epCap->cap) + { + case OO_G711ALAW64K: + pAudio->t = T_H245AudioCapability_g711Alaw64k; + if(dir & OORX) + pAudio->u.g711Alaw64k = params->rxframes; + else + pAudio->u.g711Alaw64k = params->txframes; + return pAudio; + case OO_G711ALAW56K: + pAudio->t = T_H245AudioCapability_g711Alaw56k; + if(dir & OORX) + pAudio->u.g711Alaw56k = params->rxframes; + else + pAudio->u.g711Alaw56k = params->txframes; + return pAudio; + case OO_G711ULAW64K: + pAudio->t = T_H245AudioCapability_g711Ulaw64k; + if(dir & OORX) + pAudio->u.g711Ulaw64k = params->rxframes; + else + pAudio->u.g711Ulaw64k = params->txframes; + return pAudio; + case OO_G711ULAW56K: + pAudio->t = T_H245AudioCapability_g711Ulaw56k; + if(dir & OORX) + pAudio->u.g711Ulaw56k = params->rxframes; + else + pAudio->u.g711Ulaw64k = params->txframes; + return pAudio; + /*case OO_G726: + pAudio->t = T_H245AudioCapability_g726; + if(dir & OORX) + pAudio->u.g726 = params->rxframes; + else + pAudio->u.g726 = params->txframes; + return pAudio;*/ + case OO_G728: + pAudio->t = T_H245AudioCapability_g728; + if(dir & OORX) + pAudio->u.g728 = params->rxframes; + else + pAudio->u.g728 = params->txframes; + return pAudio; + case OO_G729: + pAudio->t = T_H245AudioCapability_g729; + if(dir & OORX) + pAudio->u.g729 = params->rxframes; + else + pAudio->u.g729 = params->txframes; + return pAudio; + case OO_G729A: + pAudio->t = T_H245AudioCapability_g729AnnexA; + if(dir & OORX) + pAudio->u.g729AnnexA = params->rxframes; + else + pAudio->u.g729AnnexA = params->txframes; + return pAudio; + case OO_G7231: + pAudio->t = T_H245AudioCapability_g7231; + pAudio->u.g7231 = (H245AudioCapability_g7231*)memAlloc(pctxt, + sizeof(H245AudioCapability_g7231)); + if(!pAudio->u.g7231) + { + OOTRACEERR1("Error:Memory - ooCapabilityCreateSimpleCapability - g7231\n"); + memFreePtr(pctxt, pAudio); + return NULL; + } + pAudio->u.g7231->silenceSuppression = params->silenceSuppression; + if(dir & OORX) + pAudio->u.g7231->maxAl_sduAudioFrames = params->rxframes; + else + pAudio->u.g7231->maxAl_sduAudioFrames = params->txframes; + return pAudio; + + default: + OOTRACEERR2("ERROR: Don't know how to create audio capability %d\n", + epCap->cap); + } + return NULL; +} + +/* Used for g711 ulaw/alaw, g728, g729, g729a, g7231 */ +ASN1BOOL ooCapabilityCheckCompatibility_Simple + (OOH323CallData *call, ooH323EpCapability* epCap, + H245AudioCapability* audioCap, int dir) +{ + int noofframes=0, cap; + + OOTRACEDBGC2("Comparing channel with codec type: %d\n", audioCap->t); + + switch(audioCap->t) + { + case T_H245AudioCapability_g711Ulaw56k: + cap = OO_G711ULAW56K; + noofframes = audioCap->u.g711Ulaw56k; + break; + case T_H245AudioCapability_g711Ulaw64k: + cap = OO_G711ULAW64K; + noofframes = audioCap->u.g711Ulaw64k; + break; + case T_H245AudioCapability_g711Alaw64k: + cap = OO_G711ALAW64K; + noofframes = audioCap->u.g711Alaw64k; + break; + case T_H245AudioCapability_g711Alaw56k: + cap = OO_G711ALAW56K; + noofframes = audioCap->u.g711Alaw56k; + break; + /*case T_H245AudioCapability_g726: + cap = OO_G726; + noofframes = audioCap->u.g726; + break;*/ + case T_H245AudioCapability_g728: + cap = OO_G728; + noofframes = audioCap->u.g728; + break; + case T_H245AudioCapability_g729: + cap = OO_G729; + noofframes = audioCap->u.g729; + break; + case T_H245AudioCapability_g729AnnexA: + cap = OO_G729A; + noofframes = audioCap->u.g729AnnexA; + break; + case T_H245AudioCapability_g7231: + cap = OO_G7231; + noofframes = audioCap->u.g7231->maxAl_sduAudioFrames; + break; + default: + return FALSE; + } + + OOTRACEDBGC3("Comparing codecs: current=%d, requested=%d\n", + epCap->cap, cap); + if(cap != epCap->cap) { return FALSE; } + + /* Can we receive this capability */ + if(dir & OORX) + { + OOTRACEDBGC3("Comparing RX frame rate: channel's=%d, requested=%d\n", + ((OOCapParams*)epCap->params)->rxframes, noofframes); + if(((OOCapParams*)epCap->params)->rxframes >= noofframes) { + return TRUE; + } + //else { + // not supported, as already told other ep our max. receive rate + // our ep can't receive more rate than it + // return FALSE; + //} + } + + /* Can we transmit compatible stream */ + if(dir & OOTX) + { + OOTRACEDBGC3("Comparing TX frame rate: channel's=%d, requested=%d\n", + ((OOCapParams*)epCap->params)->txframes, noofframes); + if(((OOCapParams*)epCap->params)->txframes <= noofframes) { + return TRUE; + } + //else { + // TODO: reduce our ep transmission rate, as peer EP has low receive + // cap, than return TRUE + //} + } + return FALSE; + +} + + +OOBOOL ooCapabilityCheckCompatibility_GSM + (OOH323CallData *call, ooH323EpCapability* epCap, + H245AudioCapability* audioCap, int dir) +{ + unsigned noofframes=0, cap; + switch(audioCap->t) + { + case T_H245AudioCapability_gsmFullRate: + cap = OO_GSMFULLRATE; + noofframes = (audioCap->u.gsmFullRate->audioUnitSize)/OO_GSMFRAMESIZE; + break; + case T_H245AudioCapability_gsmHalfRate: + cap = OO_GSMHALFRATE; + noofframes = (audioCap->u.gsmHalfRate->audioUnitSize)/OO_GSMFRAMESIZE; + break; + case T_H245AudioCapability_gsmEnhancedFullRate: + cap = OO_GSMENHANCEDFULLRATE; + noofframes = (audioCap->u.gsmEnhancedFullRate->audioUnitSize)/OO_GSMFRAMESIZE; + break; + default: + return FALSE; + } + + /* can we receive this capability */ + if(dir & OORX) + { + if(((OOGSMCapParams*)epCap->params)->rxframes >= noofframes) + return TRUE; + } + + /* Make sure we transmit compatible stream */ + if(dir & OOTX) + { + if(((OOGSMCapParams*)epCap->params)->txframes > noofframes){ + OOTRACEDBGA5("Reducing txframes for GSM from %d to %d to match " + "receive capability of remote end.(%s, %s)\n", + ((OOGSMCapParams*)epCap->params)->txframes, noofframes, + call->callType, call->callToken); + ((OOGSMCapParams*)epCap->params)->txframes = noofframes; + } + return TRUE; + } + return FALSE; + +} + + +OOBOOL ooCapabilityCheckCompatibility_H263Video + (struct OOH323CallData *call, ooH323EpCapability *epCap, + H245VideoCapability *pVideoCap, int dir) +{ + H245H263VideoCapability *pH263Cap = NULL; + + OOH263CapParams *params = epCap->params; + if(!pVideoCap->u.h263VideoCapability) + { + OOTRACEERR3("Error:No H263 video capability present in video capability" + "structure. (%s, %s)\n", call->callType, call->callToken); + return FALSE; + } + pH263Cap = pVideoCap->u.h263VideoCapability; + + /* can we receive/transmit this capability */ + if(OORX & dir) + { + if(pH263Cap->m.sqcifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_SQCIF) + { + return FALSE; + } + else{ + if(pH263Cap->sqcifMPI >= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.qcifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_QCIF) + { + return FALSE; + } + else{ + if(pH263Cap->qcifMPI >= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF) + { + return FALSE; + } + else{ + if(pH263Cap->cifMPI >= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cif4MPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF4) + { + return FALSE; + } + else{ + if(pH263Cap->cif4MPI >= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cif16MPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF16) + { + return FALSE; + } + else{ + if(pH263Cap->cif16MPI >= params->MPI) + return TRUE; + else + return FALSE; + } + } + } + + /* Can we transmit */ + if(OOTX & dir) + { + if(pH263Cap->m.sqcifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_SQCIF) + { + return FALSE; + } + else{ + if(pH263Cap->sqcifMPI <= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.qcifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_QCIF) + { + return FALSE; + } + else{ + if(pH263Cap->qcifMPI <= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF) + { + return FALSE; + } + else{ + if(pH263Cap->cifMPI <= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cif4MPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF4) + { + return FALSE; + } + else{ + if(pH263Cap->cif4MPI <= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cif16MPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF16) + { + return FALSE; + } + else{ + if(pH263Cap->cif16MPI <= params->MPI) + return TRUE; + else + return FALSE; + } + } + } + + return FALSE; + +} + + +OOBOOL ooCapabilityCheckCompatibility_Audio + (OOH323CallData *call, ooH323EpCapability* epCap, + H245AudioCapability* audioCap, int dir) +{ + + switch(audioCap->t) + { + case T_H245AudioCapability_g711Ulaw56k: + case T_H245AudioCapability_g711Ulaw64k: + case T_H245AudioCapability_g711Alaw64k: + case T_H245AudioCapability_g711Alaw56k: + /*case T_H245AudioCapability_g726:*/ + case T_H245AudioCapability_g728: + case T_H245AudioCapability_g729: + case T_H245AudioCapability_g729AnnexA: + case T_H245AudioCapability_g7231: + return ooCapabilityCheckCompatibility_Simple(call, epCap, audioCap, dir); + case T_H245AudioCapability_gsmFullRate: + return ooCapabilityCheckCompatibility_GSM(call, epCap, audioCap, dir); + default: + return FALSE; + } + + return FALSE; +} + +OOBOOL ooCapabilityCheckCompatibility_Video + (OOH323CallData *call, ooH323EpCapability* epCap, + H245VideoCapability* videoCap, int dir) +{ + switch(videoCap->t) + { + case T_H245VideoCapability_h263VideoCapability: + return ooCapabilityCheckCompatibility_H263Video(call, epCap, + videoCap, dir); + default: + OOTRACEDBGC3("ooCapabilityCheckCompatibility_Video - Unsupported video " + "capability. (%s, %s)\n", call->callType, call->callToken); + } + return FALSE; +} +/* + Note: In faststart if we sent transmit rate (x>y) and remote + can receive only y, then we can't reduce our transmit rate +*/ +OOBOOL ooCapabilityCheckCompatibility + (struct OOH323CallData *call, ooH323EpCapability* epCap, + H245DataType* dataType, int dir) +{ + switch(dataType->t) + { + case T_H245DataType_audioData: + if(epCap->capType == OO_CAP_TYPE_AUDIO) + return ooCapabilityCheckCompatibility_Audio(call, epCap, + dataType->u.audioData, dir); + break; + case T_H245DataType_videoData: + if(epCap->capType == OO_CAP_TYPE_VIDEO) + return ooCapabilityCheckCompatibility_Video(call, epCap, + dataType->u.videoData, dir); + break; + case T_H245DataType_data: + default: + OOTRACEDBGC3("ooCapabilityCheckCompatibility - Unsupported " + "capability. (%s, %s)\n", call->callType, call->callToken); + } + + return FALSE; +} + +#if 0 +/** + TODO: If txCap is local and number of txframes is greater than remote can + receive, we should automatically decrease it. And logical channel cap should + be the one where it should be decreased. The start logical channel will + indicate the application that it is supposed to tx and a reduced rate. + */ +ASN1BOOL ooCheckCompatibility + (OOH323CallData *call, ooH323EpCapability *txCap, ooH323EpCapability *rxCap) +{ + + if(txCap->cap != rxCap->cap) return FALSE; + + if(!(txCap->dir & OOTX)) return FALSE; + + if(!(rxCap->dir & OORX)) return FALSE; + + switch(txCap->cap) + { + case OO_G711ALAW64K: + case OO_G711ALAW56K: + case OO_G711ULAW64K: + case OO_G711ULAW56K: + /*case OO_G726:*/ + case OO_G728: + case OO_G729: + case OO_G729A: + case OO_G7231: + if(((OOCapParams*)txCap->params)->txframes <= + ((OOCapParams*)rxCap->params)->rxframes) + return TRUE; + else{ + OOTRACEDBGA4("Simple caps %s are not compatible.(%s, %s)\n", + ooGetCapTypeText(txCap->cap), call->callType, + call->callToken); + return FALSE; + } + case OO_GSMFULLRATE: + case OO_GSMHALFRATE: + case OO_GSMENHANCEDFULLRATE: + if(((OOGSMCapParams*)txCap->params)->txframes <= + ((OOGSMCapParams*)rxCap->params)->rxframes) + return TRUE; + else{ + OOTRACEDBGA3("GSM caps are not compatible. (%s, %s)\n", call->callType, + call->callToken); + return FALSE; + } + default: + OOTRACEWARN3("WARN: Unsupported capabilities being compared. (%s, %s)\n", + call->callType, call->callToken); + } + return FALSE; + +} + +#endif + +ooH323EpCapability* ooIsAudioDataTypeGSMSupported + (OOH323CallData *call, H245AudioCapability* audioCap, int dir) +{ + unsigned framesPerPkt=0; + int cap=0; + ooH323EpCapability *cur = NULL, *epCap=NULL; + OOGSMCapParams *params = NULL; + + switch(audioCap->t) + { + case T_H245AudioCapability_gsmFullRate: + framesPerPkt = (audioCap->u.gsmFullRate->audioUnitSize)/OO_GSMFRAMESIZE; + cap = OO_GSMFULLRATE; + break; + case T_H245AudioCapability_gsmHalfRate: + framesPerPkt = (audioCap->u.gsmHalfRate->audioUnitSize)/OO_GSMFRAMESIZE; + cap = OO_GSMHALFRATE; + break; + case T_H245AudioCapability_gsmEnhancedFullRate: + framesPerPkt = (audioCap->u.gsmEnhancedFullRate->audioUnitSize)/OO_GSMFRAMESIZE; + cap = OO_GSMENHANCEDFULLRATE; + break; + default: + OOTRACEERR3("Error:Invalid GSM capability type.(%s, %s)\n", + call->callType, call->callToken); + return NULL; + } + + OOTRACEDBGC4("Determined audio data type to be of type %d. Searching" + " for matching capability.(%s, %s)\n", cap, call->callType, + call->callToken); + + /* If we have call specific caps then we use them, otherwise we use + general endpoint caps*/ + if(call->ourCaps) + cur = call->ourCaps; + else + cur = gH323ep.myCaps; + + while(cur) + { + OOTRACEDBGC4("Local cap being compared %d. (%s, %s)\n", cur->cap, + call->callType, call->callToken); + + if(cur->cap == cap && (cur->dir & dir)) + break; + cur = cur->next; + } + + if(!cur) return NULL; + + OOTRACEDBGC4("Found matching audio capability type %d. Comparing" + " other parameters. (%s, %s)\n", cap, call->callType, + call->callToken); + + /* can we receive this capability */ + if(dir & OORX) + { + if(((OOGSMCapParams*)cur->params)->rxframes < framesPerPkt) + return NULL; + else{ + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params =(OOGSMCapParams*)memAlloc(call->pctxt,sizeof(OOGSMCapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsAudioDataTypeGSMSupported - " + "epCap/params (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOGSMCapParams)); + return epCap; + } + } + + /* Can we transmit compatible stream */ + if(dir & OOTX) + { + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params =(OOGSMCapParams*)memAlloc(call->pctxt,sizeof(OOGSMCapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsAudioDataTypeGSMSupported - " + "epCap/params (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOGSMCapParams)); + if(params->txframes > framesPerPkt) + { + OOTRACEINFO5("Reducing framesPerPkt for transmission of GSM " + "capability from %d to %d to match receive capability of" + " remote endpoint.(%s, %s)\n", params->txframes, + framesPerPkt, call->callType, call->callToken); + params->txframes = framesPerPkt; + } + + return epCap; + + } + return NULL; + +} + +/* used for g711 ulaw/alaw, g728, g729, g729a, g7231 */ +ooH323EpCapability* ooIsAudioDataTypeSimpleSupported + (OOH323CallData *call, H245AudioCapability* audioCap, int dir) +{ + int cap, framesPerPkt=0; + ooH323EpCapability *cur=NULL, *epCap=NULL; + OOCapParams * params= NULL; + + /* Find similar capability */ + switch(audioCap->t) + { + case T_H245AudioCapability_g711Alaw64k: + framesPerPkt = audioCap->u.g711Alaw64k; + cap = OO_G711ALAW64K; + break; + case T_H245AudioCapability_g711Alaw56k: + framesPerPkt = audioCap->u.g711Alaw56k; + cap = OO_G711ALAW56K; + break; + case T_H245AudioCapability_g711Ulaw56k: + framesPerPkt = audioCap->u.g711Ulaw56k; + cap = OO_G711ULAW56K; + break; + case T_H245AudioCapability_g711Ulaw64k: + framesPerPkt = audioCap->u.g711Ulaw64k; + cap = OO_G711ULAW64K; + break; + +/* case T_H245AudioCapability_g726: + framesPerPkt = audioCap->u.g726; + cap = OO_G726; + break; +*/ + case T_H245AudioCapability_g728: + framesPerPkt = audioCap->u.g728; + cap = OO_G728; + break; + + case T_H245AudioCapability_g729: + framesPerPkt = audioCap->u.g729; + cap = OO_G729; + break; + case T_H245AudioCapability_g729AnnexA: + framesPerPkt = audioCap->u.g729AnnexA; + cap = OO_G729A; + break; + case T_H245AudioCapability_g7231: + framesPerPkt = audioCap->u.g7231->maxAl_sduAudioFrames; + cap = OO_G7231; + break; + default: + return NULL; + } + + OOTRACEDBGC4("Determined Simple audio data type to be of type %s. Searching" + " for matching capability.(%s, %s)\n", + ooGetCapTypeText(cap), call->callType, call->callToken); + + /* If we have call specific caps, we use them; otherwise use general + endpoint caps + */ + if(call->ourCaps) + cur = call->ourCaps; + else + cur = gH323ep.myCaps; + + while(cur) + { + OOTRACEDBGC4("Local cap being compared %s. (%s, %s)\n", + ooGetCapTypeText(cur->cap),call->callType, call->callToken); + + if(cur->cap == cap && (cur->dir & dir)) + break; + cur = cur->next; + } + + if(!cur) return NULL; + + OOTRACEDBGC4("Found matching simple audio capability type %s. Comparing" + " other parameters. (%s, %s)\n", ooGetCapTypeText(cap), + call->callType, call->callToken); + + /* can we receive this capability */ + if(dir & OORX) + { + if(((OOCapParams*)cur->params)->rxframes < framesPerPkt) + return NULL; + else{ + OOTRACEDBGC4("We can receive Simple capability %s. (%s, %s)\n", + ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params=(OOCapParams*)memAlloc(call->pctxt,sizeof(OOCapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsAudioDataTypeSimpleSupported - " + "epCap/params (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOCapParams)); + OOTRACEDBGC4("Returning copy of matched receive capability %s. " + "(%s, %s)\n", + ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + return epCap; + } + } + + /* Can we transmit compatible stream */ + if(dir & OOTX) + { + OOTRACEDBGC4("We can transmit Simple capability %s. (%s, %s)\n", + ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params =(OOCapParams*)memAlloc(call->pctxt,sizeof(OOCapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsAudioDataTypeSimpleSupported - " + "epCap/params (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOCapParams)); + if(params->txframes > framesPerPkt) + { + OOTRACEINFO5("Reducing framesPerPkt for transmission of Simple " + "capability from %d to %d to match receive capability of" + " remote endpoint.(%s, %s)\n", params->txframes, + framesPerPkt, call->callType, call->callToken); + params->txframes = framesPerPkt; + } + OOTRACEDBGC4("Returning copy of matched transmit capability %s." + "(%s, %s)\n", + ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + return epCap; + } + return NULL; +} + + + +ooH323EpCapability* ooIsAudioDataTypeSupported + (OOH323CallData *call, H245AudioCapability* audioCap, int dir) +{ + /* Find similar capability */ + switch(audioCap->t) + { + case T_H245AudioCapability_g711Alaw64k: + case T_H245AudioCapability_g711Alaw56k: + case T_H245AudioCapability_g711Ulaw56k: + case T_H245AudioCapability_g711Ulaw64k: + /*case T_H245AudioCapability_g726:*/ + case T_H245AudioCapability_g728: + case T_H245AudioCapability_g729: + case T_H245AudioCapability_g729AnnexA: + case T_H245AudioCapability_g7231: + return ooIsAudioDataTypeSimpleSupported(call, audioCap, dir); + case T_H245AudioCapability_gsmFullRate: + case T_H245AudioCapability_gsmHalfRate: + case T_H245AudioCapability_gsmEnhancedFullRate: + return ooIsAudioDataTypeGSMSupported(call, audioCap, dir); + default: + return NULL; + } +} + + +ooH323EpCapability* ooIsVideoDataTypeH263Supported + (OOH323CallData *call, H245H263VideoCapability* pH263Cap, int dir, + OOPictureFormat picFormat) +{ + int cap; + ooH323EpCapability *cur=NULL, *epCap=NULL; + OOH263CapParams *params= NULL; + char *pictureType=NULL; + unsigned mpi=0; + cap = OO_H263VIDEO; + + if(picFormat == OO_PICFORMAT_SQCIF && pH263Cap->m.sqcifMPIPresent) + { + pictureType = "SQCIF"; + mpi = pH263Cap->sqcifMPI; + } + if(picFormat == OO_PICFORMAT_QCIF && pH263Cap->m.qcifMPIPresent) + { + pictureType = "QCIF"; + mpi = pH263Cap->qcifMPI; + } + if(picFormat == OO_PICFORMAT_CIF && pH263Cap->m.cifMPIPresent) + { + pictureType = "CIF"; + mpi = pH263Cap->cifMPI; + } + if(picFormat == OO_PICFORMAT_CIF4 && pH263Cap->m.cif4MPIPresent) + { + pictureType = "CIF4"; + mpi = pH263Cap->cif4MPI; + } + if(picFormat == OO_PICFORMAT_CIF16 && pH263Cap->m.cif16MPIPresent) + { + pictureType = "CIF16"; + mpi = pH263Cap->cif16MPI; + } + + + OOTRACEDBGA4("Looking for H263 video capability(%s). (%s, %s)\n", + pictureType, call->callType, call->callToken); + + /* If we have call specific caps, we use them; otherwise use general + endpoint caps + */ + if(call->ourCaps) + cur = call->ourCaps; + else + cur = gH323ep.myCaps; + + while(cur) + { + OOTRACEDBGC4("Local cap being compared %s. (%s, %s)\n", + ooGetCapTypeText(cur->cap),call->callType, call->callToken); + + if(cur->cap == cap && (cur->dir & dir)) + { + if(((OOH263CapParams*)cur->params)->picFormat == picFormat) + break; + } + cur = cur->next; + } + + if(!cur) return NULL; + + OOTRACEDBGC4("Found matching H.263 video capability type %s. Comparing" + " other parameters. (%s, %s)\n", ooGetCapTypeText(cap), + call->callType, call->callToken); + if(dir & OORX) + { + if(mpi < ((OOH263CapParams*)cur->params)->MPI) + return NULL; + else{ + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params = (OOH263CapParams*) memAlloc(call->pctxt, + sizeof(OOH263CapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsVideoDataTypeH263Supported - " + "epCap/params. (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOH263CapParams)); + OOTRACEDBGC4("Returning copy of matched receive capability %s. " + "(%s, %s)\n", ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + return epCap; + } + } + if(dir & OOTX) + { + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params = (OOH263CapParams*) memAlloc(call->pctxt, + sizeof(OOH263CapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsVideoDataTypeH263Supported - " + "epCap/params. (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOH263CapParams)); + if(params->MPI < mpi) + { + OOTRACEINFO5("Increasing minimum picture interval for transmission of" + " H263 video capability from %d to %d to match receive " + "capability of remote endpoint.(%s, %s)\n", params->MPI, + mpi, call->callType, call->callToken); + params->MPI = mpi; + } + OOTRACEDBGC4("Returning copy of matched receive capability %s. " + "(%s, %s)\n", ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + return epCap; + } + return NULL; + +} + +ooH323EpCapability* ooIsVideoDataTypeSupported + (OOH323CallData *call, H245VideoCapability* pVideoCap, int dir) +{ + switch(pVideoCap->t) + { + case T_H245VideoCapability_h263VideoCapability: + if(pVideoCap->u.h263VideoCapability->m.sqcifMPIPresent) + return ooIsVideoDataTypeH263Supported(call, + pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_SQCIF); + else if(pVideoCap->u.h263VideoCapability->m.qcifMPIPresent) + return ooIsVideoDataTypeH263Supported(call, + pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_QCIF); + else if(pVideoCap->u.h263VideoCapability->m.cifMPIPresent) + return ooIsVideoDataTypeH263Supported(call, + pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_CIF); + else if(pVideoCap->u.h263VideoCapability->m.cif4MPIPresent) + return ooIsVideoDataTypeH263Supported(call, + pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_CIF4); + else if(pVideoCap->u.h263VideoCapability->m.cif16MPIPresent) + return ooIsVideoDataTypeH263Supported(call, + pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_CIF16); + break; + case T_H245VideoCapability_nonStandard: + case T_H245VideoCapability_h261VideoCapability: + case T_H245VideoCapability_h262VideoCapability: + case T_H245VideoCapability_is11172VideoCapability: + case T_H245VideoCapability_genericVideoCapability: + case T_H245VideoCapability_extElem1: + default: + OOTRACEDBGA1("Unsupported video capability type in " + "ooIsVideoDataTypeSupported\n"); + return NULL; + } + return NULL; +} + +ooH323EpCapability* ooIsDataTypeSupported + (OOH323CallData *call, H245DataType *data, int dir) +{ + OOTRACEDBGC3("Looking for data type support. (%s, %s)\n", call->callType, + call->callToken); + + switch(data->t) + { + case T_H245DataType_nonStandard: + OOTRACEDBGC3("NonStandard data type not supported.(%s, %s)\n", + call->callType, call->callToken); + return NULL; + case T_H245DataType_nullData: + OOTRACEDBGC3("Null data type not supported.(%s, %s)\n", + call->callType, call->callToken); + return NULL; + case T_H245DataType_videoData: + OOTRACEDBGC3("Looking for video dataType support. (%s, %s)\n", + call->callType, call->callToken); + return ooIsVideoDataTypeSupported(call, data->u.videoData, dir); + case T_H245DataType_audioData: + OOTRACEDBGC3("Looking for audio dataType support. (%s, %s)\n", + call->callType, call->callToken); + return ooIsAudioDataTypeSupported(call, data->u.audioData, dir); + case T_H245DataType_data: + OOTRACEDBGC3("Data type not supported.(%s, %s)\n", + call->callType, call->callToken); + return NULL; + case T_H245DataType_encryptionData: + OOTRACEDBGC3("Encryption data type not supported.(%s, %s)\n", + call->callType, call->callToken); + return NULL; + case T_H245DataType_h235Control: + return NULL; + case T_H245DataType_h235Media: + return NULL; + case T_H245DataType_multiplexedStream: + return NULL; + default: + OOTRACEINFO3("Unknown data type (%s, %s)\n", call->callType, + call->callToken); + } + return NULL; +} + +int ooResetCapPrefs(OOH323CallData *call) +{ + OOCapPrefs *capPrefs=NULL; + if(call) + capPrefs = &call->capPrefs; + else + capPrefs = &gH323ep.capPrefs; + memset(capPrefs, 0, sizeof(OOCapPrefs)); + return OO_OK; +} + +int ooRemoveCapFromCapPrefs(OOH323CallData *call, int cap) +{ + int i=0, j=0; + OOCapPrefs *capPrefs=NULL, oldPrefs; + if(call) + capPrefs = &call->capPrefs; + else + capPrefs = &gH323ep.capPrefs; + + memcpy(&oldPrefs, capPrefs, sizeof(OOCapPrefs)); + memset(capPrefs, 0, sizeof(OOCapPrefs)); + for(i=0; i<oldPrefs.index; i++) + { + if(oldPrefs.order[i] != cap) + capPrefs->order[j++] = oldPrefs.order[i]; + } + capPrefs->index = j; + return OO_OK; +} + + +int ooAppendCapToCapPrefs(OOH323CallData *call, int cap) +{ + OOCapPrefs *capPrefs=NULL; + if(call) + capPrefs = &call->capPrefs; + else + capPrefs = &gH323ep.capPrefs; + + capPrefs->order[capPrefs->index++] = cap; + return OO_OK; +} + +int ooChangeCapPrefOrder(OOH323CallData *call, int cap, int pos) +{ + int i=0, j=0; + OOCapPrefs *capPrefs = NULL; + + /* Whether to change prefs for call or for endpoint as a whole */ + if(call) + capPrefs = &call->capPrefs; + else + capPrefs = &gH323ep.capPrefs; + + /* check whether cap exists, cap must exist */ + for(i=0; i<capPrefs->index; i++) + { + if(capPrefs->order[i] == cap) + break; + } + if(i == capPrefs->index) return OO_FAILED; + + if(i==pos) return OO_OK; /* No need to change */ + + /* Decrease Pref order */ + if(i < pos) + { + for( ; i<pos; i++) + capPrefs->order[i] = capPrefs->order[i+1]; + capPrefs->order[i]=cap; + return OO_OK; + } + /* Increase Pref order */ + if(i>pos) + { + for(j=i; j>pos; j--) + capPrefs->order[j] = capPrefs->order[j-1]; + capPrefs->order[j] = cap; + return OO_OK; + } + + return OO_FAILED; + +} + +int ooPreppendCapToCapPrefs(OOH323CallData *call, int cap) +{ + int i=0, j=0; + OOCapPrefs *capPrefs=NULL, oldPrefs; + if(call) + capPrefs = &call->capPrefs; + else + capPrefs = &gH323ep.capPrefs; + + memcpy(&oldPrefs, capPrefs, sizeof(OOCapPrefs)); + + + capPrefs->order[j++] = cap; + + for(i=0; i<oldPrefs.index; i++) + { + if(oldPrefs.order[i] != cap) + capPrefs->order[j++] = oldPrefs.order[i]; + } + capPrefs->index = j; + return OO_OK; +} + + +int ooAddRemoteCapability(OOH323CallData *call, H245Capability *cap) +{ + switch(cap->t) + { + case T_H245Capability_receiveAudioCapability: + return ooAddRemoteAudioCapability(call, cap->u.receiveAudioCapability, + OORX); + case T_H245Capability_transmitAudioCapability: + return ooAddRemoteAudioCapability(call, cap->u.transmitAudioCapability, + OOTX); + case T_H245Capability_receiveAndTransmitAudioCapability: + return ooAddRemoteAudioCapability(call, + cap->u.receiveAndTransmitAudioCapability, OORXTX); + default: + OOTRACEDBGA3("Unsupported cap type encountered. Ignoring. (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooAddRemoteAudioCapability(OOH323CallData *call, + H245AudioCapability *audioCap, + int dir) +{ + int rxframes=0, txframes=0; + + switch(audioCap->t) + { + case T_H245AudioCapability_g711Alaw64k: + if(dir&OOTX) txframes = audioCap->u.g711Alaw64k; + else if(dir&OORX) rxframes = audioCap->u.g711Alaw64k; + else{ + txframes = audioCap->u.g711Alaw64k; + rxframes = audioCap->u.g711Alaw64k; + } + return ooCapabilityAddSimpleCapability(call, OO_G711ALAW64K, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL,TRUE); + case T_H245AudioCapability_g711Alaw56k: + if(dir&OOTX) txframes = audioCap->u.g711Alaw56k; + else if(dir&OORX) rxframes = audioCap->u.g711Alaw56k; + else{ + txframes = audioCap->u.g711Alaw56k; + rxframes = audioCap->u.g711Alaw56k; + } + return ooCapabilityAddSimpleCapability(call, OO_G711ALAW56K, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + case T_H245AudioCapability_g711Ulaw64k: + if(dir&OOTX) txframes = audioCap->u.g711Ulaw64k; + else if(dir&OORX) rxframes = audioCap->u.g711Ulaw64k; + else{ + txframes = audioCap->u.g711Ulaw64k; + rxframes = audioCap->u.g711Ulaw64k; + } + return ooCapabilityAddSimpleCapability(call, OO_G711ULAW64K, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + case T_H245AudioCapability_g711Ulaw56k: + if(dir&OOTX) txframes = audioCap->u.g711Ulaw56k; + else if(dir&OORX) rxframes = audioCap->u.g711Ulaw56k; + else{ + txframes = audioCap->u.g711Ulaw56k; + rxframes = audioCap->u.g711Ulaw56k; + } + return ooCapabilityAddSimpleCapability(call, OO_G711ULAW56K, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + +/* case T_H245AudioCapability_g726: + if(dir&OOTX) txframes = audioCap->u.g726; + else if(dir&OORX) rxframes = audioCap->u.g726; + else{ + txframes = audioCap->u.g726; + rxframes = audioCap->u.g726; + } + return ooCapabilityAddSimpleCapability(call, OO_G726, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); +*/ + case T_H245AudioCapability_g728: + if(dir&OOTX) txframes = audioCap->u.g728; + else if(dir&OORX) rxframes = audioCap->u.g728; + else{ + txframes = audioCap->u.g728; + rxframes = audioCap->u.g728; + } + return ooCapabilityAddSimpleCapability(call, OO_G728, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + + case T_H245AudioCapability_g729: + if(dir&OOTX) txframes = audioCap->u.g729; + else if(dir&OORX) rxframes = audioCap->u.g729; + else{ + txframes = audioCap->u.g729; + rxframes = audioCap->u.g729; + } + return ooCapabilityAddSimpleCapability(call, OO_G729, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + + case T_H245AudioCapability_g729AnnexA: + if(dir&OOTX) txframes = audioCap->u.g729AnnexA; + else if(dir&OORX) rxframes = audioCap->u.g729AnnexA; + else{ + txframes = audioCap->u.g729AnnexA; + rxframes = audioCap->u.g729AnnexA; + } + return ooCapabilityAddSimpleCapability(call, OO_G729A, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + + case T_H245AudioCapability_g7231: + if(dir&OOTX) txframes = audioCap->u.g7231->maxAl_sduAudioFrames; + else if(dir&OORX) rxframes = audioCap->u.g7231->maxAl_sduAudioFrames; + else{ + txframes = audioCap->u.g7231->maxAl_sduAudioFrames; + rxframes = audioCap->u.g7231->maxAl_sduAudioFrames; + } + return ooCapabilityAddSimpleCapability(call, OO_G7231, txframes,rxframes, + audioCap->u.g7231->silenceSuppression, + dir, NULL, NULL, NULL, NULL, TRUE); + case T_H245AudioCapability_gsmFullRate: + return ooCapabilityAddGSMCapability(call, OO_GSMFULLRATE, + (unsigned)(audioCap->u.gsmFullRate->audioUnitSize/OO_GSMFRAMESIZE), + audioCap->u.gsmFullRate->comfortNoise, + audioCap->u.gsmFullRate->scrambled, + dir, NULL, NULL, NULL, NULL, TRUE); + case T_H245AudioCapability_gsmHalfRate: + return ooCapabilityAddGSMCapability(call, OO_GSMHALFRATE, + (unsigned)(audioCap->u.gsmHalfRate->audioUnitSize/OO_GSMFRAMESIZE), + audioCap->u.gsmHalfRate->comfortNoise, + audioCap->u.gsmHalfRate->scrambled, + dir, NULL, NULL, NULL, NULL, TRUE); + case T_H245AudioCapability_gsmEnhancedFullRate: + return ooCapabilityAddGSMCapability(call, OO_GSMENHANCEDFULLRATE, + (unsigned)(audioCap->u.gsmEnhancedFullRate->audioUnitSize/OO_GSMFRAMESIZE), + audioCap->u.gsmEnhancedFullRate->comfortNoise, + audioCap->u.gsmEnhancedFullRate->scrambled, + dir, NULL, NULL, NULL, NULL, TRUE); + + default: + OOTRACEDBGA1("Unsupported audio capability type\n"); + + } + + return OO_OK; +} + + + + + +int ooCapabilityUpdateJointCapabilities + (OOH323CallData* call, H245Capability *cap) +{ + ooH323EpCapability * epCap = NULL, *cur = NULL; + OOTRACEDBGC3("checking whether we need to add cap to joint capabilities" + "(%s, %s)\n", call->callType, call->callToken); + + switch(cap->t) + { + case T_H245Capability_receiveAudioCapability: + epCap= ooIsAudioDataTypeSupported(call, cap->u.receiveAudioCapability, + OOTX); + break; + case T_H245Capability_transmitAudioCapability: + epCap = ooIsAudioDataTypeSupported(call, cap->u.transmitAudioCapability, + OORX); + break; + case T_H245Capability_receiveAndTransmitAudioCapability: + epCap = NULL; + break; + case T_H245Capability_receiveVideoCapability: + return ooCapabilityUpdateJointCapabilitiesVideo(call, + cap->u.receiveVideoCapability, OOTX); + case T_H245Capability_transmitVideoCapability: + return ooCapabilityUpdateJointCapabilitiesVideo(call, + cap->u.transmitVideoCapability, OORX); + case T_H245Capability_receiveUserInputCapability: + if((cap->u.receiveUserInputCapability->t == + T_H245UserInputCapability_basicString) && + (call->dtmfmode & OO_CAP_DTMF_H245_alphanumeric)) + { + call->jointDtmfMode |= OO_CAP_DTMF_H245_alphanumeric; + return OO_OK; + } + else if((cap->u.receiveUserInputCapability->t == + T_H245UserInputCapability_dtmf) && + (call->dtmfmode & OO_CAP_DTMF_H245_signal)) + { + call->jointDtmfMode |= OO_CAP_DTMF_H245_signal; + return OO_OK; + } + //break; + default: + OOTRACEDBGA3("Unsupported cap type encountered. Ignoring. (%s, %s)\n", + call->callType, call->callToken); + } + + if(epCap) + { + OOTRACEDBGC3("Adding cap to joint capabilities(%s, %s)\n",call->callType, + call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + + return OO_OK; + } + + OOTRACEDBGC3("Not adding to joint capabilities. (%s, %s)\n", call->callType, + call->callToken); + return OO_OK; +} + + + +int ooCapabilityUpdateJointCapabilitiesVideo + (OOH323CallData *call, H245VideoCapability *videoCap, int dir) +{ + switch(videoCap->t) + { + case T_H245VideoCapability_h263VideoCapability: + return ooCapabilityUpdateJointCapabilitiesVideoH263(call, + videoCap->u.h263VideoCapability, dir); + default: + OOTRACEDBGC3("ooCapabilityUpdateJointCapabilitiesVideo - Unsupported" + "capability type. (%s, %s)\n", call->callType, + call->callToken); + } + return OO_OK; +} + + +int ooCapabilityUpdateJointCapabilitiesVideoH263 + (OOH323CallData *call, H245H263VideoCapability *pH263Cap, int dir) +{ + ooH323EpCapability *epCap = NULL, *cur = NULL; + if(pH263Cap->m.sqcifMPIPresent) + { + epCap = ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, + OO_PICFORMAT_SQCIF); + if(epCap) + { + OOTRACEDBGC3("Adding H263-SQCIF to joint capabilities(%s, %s)\n", + call->callType, call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + + } + } + + epCap = NULL; + + if(pH263Cap->m.qcifMPIPresent) + { + epCap = ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, + OO_PICFORMAT_QCIF); + if(epCap) + { + OOTRACEDBGC3("Adding H263-QCIF to joint capabilities(%s, %s)\n", + call->callType, call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + + } + } + + epCap = NULL; + + if(pH263Cap->m.cifMPIPresent) + { + epCap = ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, + OO_PICFORMAT_CIF); + if(epCap) + { + OOTRACEDBGC3("Adding H263-CIF to joint capabilities(%s, %s)\n", + call->callType, call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + + } + } + + epCap = NULL; + + if(pH263Cap->m.cif4MPIPresent) + { + epCap = ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, + OO_PICFORMAT_CIF4); + if(epCap) + { + OOTRACEDBGC3("Adding H263-CIF4 to joint capabilities(%s, %s)\n", + call->callType, call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + } + } + + epCap = NULL; + + if(pH263Cap->m.cif16MPIPresent) + { + epCap = ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, + OO_PICFORMAT_CIF16); + if(epCap) + { + OOTRACEDBGC3("Adding H263-CIF16 to joint capabilities(%s, %s)\n", + call->callType, call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + + } + } + + return OO_OK; +} + +const char* ooGetCapTypeText (OOCapabilities cap) +{ + static const char *capTypes[]={ + "unknown", + "OO_NONSTANDARD", + "OO_G711ALAW64K", + "OO_G711ALAW56K", + "OO_G711ULAW64K", + "OO_G711ULAW56K", + "OO_G72264K", + "OO_G72256K", + "OO_G72248K", + "OO_G7231", + "OO_G728", + "OO_G729", + "OO_G729ANNEXA", + "OO_IS11172AUDIO", + "OO_IS13818AUDIO", + "OO_G729WANNEXB", + "OO_G729ANNEXAWANNEXB", + "OO_G7231ANNEXC", + "OO_GSMFULLRATE", + "OO_GSMHALFRATE", + "OO_GSMENHANCEDFULLRATE", + "OO_GENERICAUDIO", + "OO_G729EXTENSIONS", + "OO_VBD", + "OO_AUDIOTELEPHONYEVENT", + "OO_AUDIOTONE", + "OO_EXTELEM1", + "OO_VIDEO_BASE", + "OO_NONSTDVIDEO", + "OO_H261VIDEO", + "OO_H262VIDEO", + "OO_H263VIDEO", + "OO_IS11172VIDEO", /* mpeg */ + "OO_GENERICVIDEO", + "OO_EXTELEMVIDEO" + }; + return ooUtilsGetText (cap, capTypes, OONUMBEROF(capTypes)); +} |