voip_adapter_configure.c

telcobridges voip develop

				pStreamRes->Params.fUseRtpOverRawIp	= TBX_TRUE;
				pStreamRes->Params.fUseRtcp			= TBX_FALSE;
				if( in_pConnectionParams->Type0.fRecordEnabled == TBX_TRUE )
				{
					strncpy(&pStreamRes->Params.szIPAddr0[0], &in_pConnectionParams->Type0.szStreamSocketIP[0], sizeof(pStreamRes->Params.szIPAddr0));
					pStreamRes->Params.szIPAddr0[ sizeof(pStreamRes->Params.szIPAddr0) - 1] = '\0';
					pStreamRes->Params.szIPAddr1[0] = '\0';
				}
				else
				{
					pStreamRes->Params.szIPAddr0[0] = '\0';
					pStreamRes->Params.szIPAddr1[0] = '\0';
				}
				pStreamRes->Params.RedundancyMode	= TBX_STREAM_NETWORK_REDUNDANCY_MODE_DUPLICATE;
				pStreamRes->Params.un8TosByte = 0;
			}
			#endif

			/*
			 *	Create and fill new connection context
			 */

			/* Get connection */
			pConnectionContext = TBXPoolOfBuffersAlloc
			(
				in_pAdapterContext->pTargetConfig->hPoolOfConnections,
				(TBX_HASH_KEY)NULL
			);
			if( pConnectionContext == NULL )
			{
				TBX_EXIT_ERROR(TBX_RESULT_FAIL, 0, "Maximum number of connections reached." );
			}

			/* Initialize connection context */
			pConnectionContext->hConn							= (TB640_CONNECTION_HANDLE)NULL;
			pConnectionContext->un32ConnectionId				= un32ConnectionId;
			pConnectionContext->un32ConnectionIdx				= un32ConnectionIdx;
			pConnectionContext->fAllocated						= TBX_TRUE;
			pConnectionContext->Params							= *in_pConnectionParams;
			pConnectionContext->un32PathDescCount				= 1;
			pConnectionContext->aPathDesc[0].un32StructVersion	= 1;
			pConnectionContext->aPathDesc[0].fFullDuplex		= in_pConnectionParams->Type0.fRecordEnabled && in_pConnectionParams->Type0.fPlaybackEnabled;
			pConnectionContext->aPathDesc[0].hResSrc			= (TB640_RESOURCE_HANDLE)TBX_HANDLE_INVALID;
			pConnectionContext->aPathDesc[0].hResDst			= (TB640_RESOURCE_HANDLE)TBX_HANDLE_INVALID;
		}
		else if( in_pConnectionParams->Type == VOIP_CONNECTION_TYPE_1 )
		{
			/*
			 *	Connection type 1 (VOIP connection)
			 */

			/* Create new connection identifier */
			un32ConnectionId = VOIP_CREATE_CONNECTION_ID(VOIP_CONNECTION_TYPE_1, un32ConnectionIdx);

			/*
			 *	Check for resource availability of source
			 */

			if( in_pConnectionParams->Type1.FirstRes.Type == VOIP_RESOURCE_TYPE_TRUNK )
			{
				un32SrcTrunkNb = in_pConnectionParams->Type1.FirstRes.un32TrunkNb;
				un32SrcTimeSlot = in_pConnectionParams->Type1.FirstRes.un32TimeSlot;
				pTrunkConfig = &in_pAdapterContext->pTargetConfig->aTrunk[un32SrcTrunkNb];
				if( pTrunkConfig->fAllocated == TBX_FALSE )
				{
					TBX_EXIT_ERROR( TBX_RESULT_FAIL, 0, "Trunk timeslot resource is not allocated" );
				}
			}
			else if( in_pConnectionParams->Type1.FirstRes.Type == VOIP_RESOURCE_TYPE_MBL_PORT )
			{
				un32SrcMblPortNb = in_pConnectionParams->Type1.FirstRes.un32MblPortNb;
				un32SrcMblStreamNb = in_pConnectionParams->Type1.FirstRes.un32MblStreamNb;
				un32SrcTimeSlot = in_pConnectionParams->Type1.FirstRes.un32MblTimeSlot;
				pMblPortConfig = &in_pAdapterContext->pTargetConfig->aMblPort[un32SrcMblPortNb];
				if( pMblPortConfig->fAllocated == TBX_FALSE )
				{
					TBX_EXIT_ERROR( TBX_RESULT_FAIL, 0, "MBL port timeslot resource is not allocated" );
				}
			}
			else if( in_pConnectionParams->Type1.FirstRes.Type == VOIP_RESOURCE_TYPE_RAW_DATA_FILE )
			{
				/* Find the raw data file context */
				TBXHashFind
				(
					in_pAdapterContext->pTargetConfig->hRawDataFileNameHash,
					(TBX_HASH_KEY) in_pConnectionParams->Type1.FirstRes.szRawDataFileResName,
					&pRawDataFileContext
				);
				if( !pRawDataFileContext )
				{
					sprintf( szErr, "Invalid raw data file name: %s", in_pConnectionParams->Type1.SecondRes.szRawDataFileResName );
					TBX_EXIT_ERROR (TBX_RESULT_NOT_FOUND, 0,szErr );
				}
				if( pRawDataFileContext->un32TdmConnectionId != 0 )
				{
					sprintf(	szErr,
								"Raw data file %s already connected (connId=%d)",
								in_pConnectionParams->Type1.SecondRes.szRawDataFileResName,
								pRawDataFileContext->un32TdmConnectionId );
					TBX_EXIT_ERROR (TBX_RESULT_NOT_FOUND, 0,szErr );
				}
				pRawDataFileContext->un32TdmConnectionId = un32ConnectionId;
				if( pRawDataFileContext->Params.Direction != VOIP_RAW_DATAFILE_DIRECTION_REC_PLAY )
				{
					fFullDuplex = TBX_FALSE;
				}
			}

			/*
			 *	Check for resource availability of destination
			 */

			if( in_pConnectionParams->Type1.SecondRes.Type == VOIP_RESOURCE_TYPE_TRUNK )
			{
				un32PathDescCount = 1;
				un32DstTrunkNb = in_pConnectionParams->Type1.SecondRes.un32TrunkNb;
				un32DstTimeSlot = in_pConnectionParams->Type1.SecondRes.un32TimeSlot;
				pTrunkConfig = &in_pAdapterContext->pTargetConfig->aTrunk[un32DstTrunkNb];
				if( pTrunkConfig->fAllocated == TBX_FALSE )
				{
					TBX_EXIT_ERROR( TBX_RESULT_FAIL, 0, "Trunk timeslot resource is not allocated" );
				}
			}
			else if( in_pConnectionParams->Type1.SecondRes.Type == VOIP_RESOURCE_TYPE_MBL_PORT )
			{
				un32PathDescCount = 1;
				un32DstMblPortNb = in_pConnectionParams->Type1.SecondRes.un32MblPortNb;
				un32DstMblStreamNb = in_pConnectionParams->Type1.SecondRes.un32MblStreamNb;
				un32DstTimeSlot = in_pConnectionParams->Type1.SecondRes.un32MblTimeSlot;
				pMblPortConfig = &in_pAdapterContext->pTargetConfig->aMblPort[un32DstMblPortNb];
				if( pMblPortConfig->fAllocated == TBX_FALSE )
				{
					TBX_EXIT_ERROR( TBX_RESULT_FAIL, 0, "MBL port timeslot resource is not allocated" );
				}

			}
			else if( in_pConnectionParams->Type1.SecondRes.Type == VOIP_RESOURCE_TYPE_STREAM_SOCKET )
			{
				un32PathDescCount = 2;

				/*
				 *	Create and fill new VP group context
				 */

				/* Get VP group context */
				pVpGroup = TBXPoolOfBuffersAlloc
				(
					in_pAdapterContext->pTargetConfig->hPoolOfVpGroups,
					(TBX_HASH_KEY)NULL
				);
				if( pVpGroup == NULL )
				{
					TBX_EXIT_ERROR( TBX_RESULT_FAIL, 0, "Maximum number of VP groups reached." );
				}

				/* Initialize voice processing resource context */
				pVpGroup->Common.hRes					= (TB640_VPGROUP_HANDLE)NULL;
				pVpGroup->Common.un32ConnectionId		= un32ConnectionId;
				pVpGroup->Common.fAllocated				= TBX_TRUE;

				if( in_pConnectionParams->Type1.SecondRes.GroupType == TB640_VP_GROUP_TYPE_0 )
				{
					/*
					 *	Using voice processing group 0
					 */
					pVpGroup->GroupParams.GroupType			= TB640_VP_GROUP_TYPE_0;
					pVpGroup->GroupParams.Group0.GroupType	= TB640_VP_GROUP_TYPE_0;
					{
						TB640_VP_GROUP0_CONF_PARAMS				ConfParams;
						TB640_VP_GROUP0_FSK_RX_AUTO_PARAMS		FskRxParams;
						TB640_VP_GROUP0_CONF_PARAMS_DEFAULT( &ConfParams );
						TB640_VP_GROUP0_FSK_RX_AUTO_PARAMS_DEFAULT( &FskRxParams );

						memcpy (&pVpGroup->GroupParams.Group0.Conf, &ConfParams, sizeof(ConfParams));
						memcpy (&pVpGroup->GroupParams.Group0.FskRxAuto, &FskRxParams, sizeof(FskRxParams));
					}
					pVpGroup->un32NbResources										= 2;

					/*
					 *	Stream resource
					 */
					pVpGroup->aRes[0].Params.Group0.ResType							= TB640_VP_RES_TYPE_STREAM;
					pVpGroup->aRes[0].Params.Group0.un64UserContext1				= un32ConnectionId;
					pVpGroup->aRes[0].Params.Group0.un64UserContext2				= 0;
					{
						TB640_VP_GROUP0_STREAM_PARAMS	StreamParams;
						TB640_VP_GROUP0_STREAM_PARAMS_DEFAULT( &StreamParams );

						if( pVpGrp0Params->fStreamParamsAvailable == TBX_TRUE )
						{
							/* Overwrite default stream parameters */
							StreamParams.PacketDurationMs	= pVpGrp0Params->StreamPacketDurationMs;
						}
						if( pVpGrp0Params->fStreamAgcParamsAvailable == TBX_TRUE )
						{
							/* Overwrite default stream AGC parameters */
							StreamParams.Agc.fEnabled = pVpGrp0Params->fStreamAgcEnabled;
						}
						if( pVpGrp0Params->fStreamToneParamsAvailable == TBX_TRUE )
						{
							/* Overwrite default stream tone parameters */
							StreamParams.Tone.fGenerationEnabled = pVpGrp0Params->fStreamToneGenerationEnabled;
							StreamParams.Tone.fDetectionEnabled = pVpGrp0Params->fStreamToneDetectionEnabled;
							StreamParams.Tone.fShortDetection = pVpGrp0Params->fStreamToneShortDetection;
							StreamParams.Tone.fSuppressionEnabled = pVpGrp0Params->fStreamToneSuppressionEnabled;
							StreamParams.Tone.fCompleteSuppression = pVpGrp0Params->fStreamToneCompleteSuppression;
						}
						if( pVpGrp0Params->fStreamJitterBufferParamsAvailable == TBX_TRUE )
						{
							/* Overwrite default stream jitter buffer parameters */
							StreamParams.un32JitterBufferSize = pVpGrp0Params->un32StreamJitterBufferSize;
						}

						memcpy( &pVpGroup->aRes[0].Params.Group0.Stream, &StreamParams, sizeof(StreamParams) );
					}
					pVpGroup->aRes[0].Params.Group0.Stream.PacketType				= in_pConnectionParams->Type1.SecondRes.PacketType;

					/*
					 *	TDM resource
					 */
					pVpGroup->aRes[1].Params.Group0.ResType 						= TB640_VP_RES_TYPE_TDM;
					pVpGroup->aRes[1].Params.Group0.un64UserContext1 				= 0;
					pVpGroup->aRes[1].Params.Group0.un64UserContext2 				= 0;
					{
						TB640_VP_GROUP0_TDM_PARAMS	TdmParams;
						TB640_VP_GROUP0_TDM_PARAMS_DEFAULT( &TdmParams );

						if( pVpGrp0Params->fTdmToneParamsAvailable == TBX_TRUE )
						{
							/* Overwrite default TDM tone parameters */
							TdmParams.Tone.fGenerationEnabled = pVpGrp0Params->fTdmToneGenerationEnabled;
							TdmParams.Tone.fDetectionEnabled = pVpGrp0Params->fTdmToneDetectionEnabled;
							TdmParams.Tone.fShortDetection = pVpGrp0Params->fTdmToneShortDetection;
							TdmParams.Tone.fSuppressionEnabled = pVpGrp0Params->fTdmToneSuppressionEnabled;
							TdmParams.Tone.fCompleteSuppression = pVpGrp0Params->fTdmToneCompleteSuppression;
						}
						if( pVpGrp0Params->fTdmAgcParamsAvailable == TBX_TRUE )
						{
							/* Overwrite default TDM AGC parameters */
							TdmParams.Agc.fEnabled = pVpGrp0Params->fTdmAgcEnabled;
						}
						if( pVpGrp0Params->fTdmVadParamsAvailable == TBX_TRUE )
						{
							/* Overwrite default TDM VAD parameters */
							TdmParams.Vad.fEnabled = pVpGrp0Params->fTdmVadEnabled;
						}

						memcpy( &pVpGroup->aRes[1].Params.Group0.Tdm, &TdmParams, sizeof(TdmParams) );
					}
				}
				else if( in_pConnectionParams->Type1.SecondRes.PacketType == TBX_STREAM_PACKET_TYPE_IFP )
				{
					/*
					 *	Using voice processing group 1 (fax)
					 */
					pVpGroup->GroupParams.GroupType			= TB640_VP_GROUP_TYPE_1;
					pVpGroup->GroupParams.Group1.GroupType	= TB640_VP_GROUP_TYPE_1;
					{
						TB640_VP_GROUP1_CONF_PARAMS	ConfParams;
						TB640_VP_GROUP1_CONF_PARAMS_DEFAULT( &ConfParams, 1 );

						memcpy( &pVpGroup->GroupParams.Group1.Conf, &ConfParams, sizeof(ConfParams) );
					}
					pVpGroup->un32NbResources = 2;

					/*
					 *	Stream T38 resource
					 */
					pVpGroup->aRes[0].Params.Group1.ResType							= TB640_VP_RES_TYPE_STREAM_T38;
					pVpGroup->aRes[0].Params.Group1.un64UserContext1				= un32ConnectionId;
					pVpGroup->aRes[0].Params.Group1.un64UserContext2				= 0;
					{
						TB640_VP_GROUP1_STREAM_T38_PARAMS	StreamT38Params;
						TB640_VP_GROUP1_STREAM_T38_DEFAULT( &StreamT38Params );

						if( pVpGrp1Params->fStreamT38ParamsAvailable == TBX_TRUE )
						{
							/* Overwrite default stream T38 parameters */
							StreamT38Params.PacketLossConcealment = pVpGrp1Params->StreamT38PacketLossConcealment;;
							StreamT38Params.un8RedundancyCountForFaxPages = pVpGrp1Params->un8StreamT38RedundancyCountForFaxPages;
							StreamT38Params.un8RedundancyCountForT38Msg = pVpGrp1Params->un8StreamT38RedundancyCountForT38Msg;
							StreamT38Params.un8NbFecPacketInUdptl = pVpGrp1Params->un8StreamT38NbFecPacketInUdptl;
							StreamT38Params.un8NbIfpPerFecPacket = pVpGrp1Params->un8StreamT38NbIfpPerFecPacket;
							StreamT38Params.fAllowEcmFaxes = pVpGrp1Params->fStreamT38AllowEcmFaxes;
							StreamT38Params.fEnableByteBasedT38 = pVpGrp1Params->fStreamT38EnableByteBasedT38;
							StreamT38Params.fEnableTsiFrameRemoval = pVpGrp1Params->fStreamT38EnableTsiFrameRemoval;
							StreamT38Params.fEnableCsiFrameRemoval = pVpGrp1Params->fStreamT38EnableCsiFrameRemoval;
							StreamT38Params.fEnableNsfFrameRemoval = pVpGrp1Params->fStreamT38EnableNsfFrameRemoval;
							StreamT38Params.fEnableDsiFrameRemoval = pVpGrp1Params->fStreamT38EnableDsiFrameRemoval;
							StreamT38Params.fGenerateFaxRelayPageStatsEvent = pVpGrp1Params->fStreamT38GenerateFaxRelayPageStatsEvent;
							StreamT38Params.fGenerateFaxRelayStateEvents = pVpGrp1Params->fStreamT38GenerateFaxRelayStateEvents;
							StreamT38Params.FaxSpeedLimit = pVpGrp1Params->StreamT38FaxSpeedLimit;
							StreamT38Params.RecoveryType = pVpGrp1Params->StreamT38RecoveryType;
							StreamT38Params.TcfProcedure = pVpGrp1Params->StreamT38TcfProcedure;
						}

						memcpy( &pVpGroup->aRes[0].Params.Group1.StreamT38, &StreamT38Params, sizeof(StreamT38Params) );
					}