iptdevice.cpp

Conferencing code using Dialogic hardware

//    true = success
//*****************************************************************************
bool CIptDevice::SetDtmfTransfer(){
int rc;
bool brc;

   if (Is3PCCMode()){
		int mode = DTMFXFERMODE_INBAND;  // Default
		const char *name = "INBAND";
		switch(m_pIptParams->ip_digits){
			case IP_DTMF_TYPE_INBAND_RTP:
				 mode = DTMFXFERMODE_INBAND;
				 break;
			case IP_DTMF_TYPE_RFC_2833:
				 mode = DTMFXFERMODE_RFC2833;
				 name = "RFC2833";
				 break;
		}

		IPM_PARM_INFO ParmInfo;
		ParmInfo.eParm = PARMCH_DTMFXFERMODE;
		ParmInfo.pvParmValue = &mode;

		rc = ipm_SetParm(m_ntwk_srl_handle, &ParmInfo, EV_SYNC);
		LOG( RC(rc), GetName(),
				 "ipm_SetParm([%s] XFERMODE, %d %s, EV_SYNC)",
				 m_ipm_name, *(int *)ParmInfo.pvParmValue, name);
		brc = ( rc == 0);
		if (!brc){
			process_ipml_error(m_ntwk_srl_handle, m_ipm_name);
		}

        int pltype = 101;
	    ParmInfo.eParm = PARMCH_RFC2833EVT_TX_PLT;
	    ParmInfo.pvParmValue = &pltype;

	    rc = ipm_SetParm(m_ntwk_srl_handle, &ParmInfo, EV_SYNC);
	    LOG( RC(rc), GetName(),
			     "ipm_SetParm([%s] PARMCH_RFC2833EVT_TX_PLT, %d, EV_SYNC)",
			     m_ipm_name, *(int *)ParmInfo.pvParmValue);
	    brc = ( rc == 0);

	    if (!brc){
		    process_ipml_error(m_ntwk_srl_handle, m_ipm_name);
	    }


	    ParmInfo.eParm = PARMCH_RFC2833EVT_RX_PLT;
	    rc = ipm_SetParm(m_ntwk_srl_handle, &ParmInfo, EV_SYNC);
	    LOG( RC(rc), GetName(),
			     "ipm_SetParm([%s] PARMCH_RFC2833EVT_RX_PLT, %d, EV_SYNC)",
			     m_ipm_name, *(int *)ParmInfo.pvParmValue);
	    brc = ( rc == 0);
	    if (!brc){
		    process_ipml_error(m_ntwk_srl_handle, m_ipm_name);
	    }

        int val = 1;
        ParmInfo.eParm = PARMCH_RFC2833GEN_TO_TDM;
		ParmInfo.pvParmValue = &val;
     	rc = ipm_SetParm(m_ntwk_srl_handle, &ParmInfo, EV_SYNC);
     	LOG( RC(rc), GetName(),
			 "ipm_SetParm([%s] PARMCH_RFC2833GEN_TO_TDM, %d,  EV_SYNC)",
              m_ipm_name, *(int *)ParmInfo.pvParmValue);
	    brc = ( rc == 0);
	    if (!brc){
		    process_ipml_error(m_ntwk_srl_handle, m_ipm_name);
	    }


        ParmInfo.eParm = PARMCH_RFC2833GEN_TO_IP;
		ParmInfo.pvParmValue = &val;
     	rc = ipm_SetParm(m_ntwk_srl_handle, &ParmInfo, EV_SYNC);
     	LOG( RC(rc), GetName(),
			 "ipm_SetParm([%s] PARMCH_RFC2833GEN_TO_IP, %d, EV_SYNC)",
             m_ipm_name, *(int *)ParmInfo.pvParmValue);
	    brc = ( rc == 0);
	    if (!brc){
		    process_ipml_error(m_ntwk_srl_handle, m_ipm_name);
	    }

     return brc;
   } 

// 1PCC mode:
int mode = m_pIptParams->ip_digits;
GC_PARM_BLKP pParmBlk = 0;

	rc = gc_util_insert_parm_val(&pParmBlk, IPSET_DTMF,
							     IPPARM_SUPPORT_DTMF_BITMASK,
							     sizeof (int), mode);

    brc = (rc == GC_SUCCESS);

	if (brc) {
		rc = gc_SetUserInfo(GCTGT_GCLIB_CHAN, m_srl_handle, pParmBlk, GC_SINGLECALL);
        LOG( RC(rc), GetName(),
             "SetDtmfTransfer(): mode = %d %s, GC_SINGLECALL",
             mode, ip_digit_type_name(mode)) ;

        LOG( RC(rc), GetName(),
             "%d = gc_SetUserInfo [Set digits](GCTGT_GCLIB_CHAN, hndl = 0x%x, pParmBlk, GC_SINGLECALL)",
             rc, m_srl_handle );
        
     	gc_util_delete_parm_blk(pParmBlk);

        if (rc != GC_SUCCESS){
            process_gc_error();
        }
    }

 	return brc;
}// End of SetDtmfTransfer()

//*****************************************************************************
// Purpose	: 
//    Enable echo cancellation
// Parameters:	
//    none
// Returns:	
//    true = success
//*****************************************************************************
bool CIptDevice::EnableEchoCancel(){
 int rc = 0;
#ifdef IPM_SET_ECHOCANCEL
 bool brc = true;
 int echoCancellation = ECACTIVE_ON;
 IPM_PARM_INFO ipmParmInfo;
 GC_PARM_BLKP gcParmBlk = 0;

   ipmParmInfo.eParm = PARMCH_ECACTIVE;
   ipmParmInfo.pvParmValue = (void *)&echoCancellation;

   if (Is3PCCMode() ) {
#ifdef IPM_SET_ECHOCANCEL
		rc = ipm_SetParm(m_ntwk_srl_handle, &ipmParmInfo, EV_SYNC);
		LOG( RC(rc), GetName(),
				 "ipm_SetParm([%s, EchoCancel] %d ECACTIVE_ON, EV_SYNC)",
				 m_ipm_name, ECACTIVE_ON);
		brc = ( rc == 0);
		if (!brc){
			process_ipml_error(m_ntwk_srl_handle, m_ipm_name);
		}
#endif
   }else {
      gc_util_insert_parm_ref( &gcParmBlk,
                              IPSET_CONFIG,
                              IPPARM_IPMPARM,
                              (unsigned long)sizeof(IPM_PARM_INFO),
                              &ipmParmInfo);
   }

   int echoTail = ECHO_TAIL_64;
   ipmParmInfo.eParm = PARMCH_ECHOTAIL;
   ipmParmInfo.pvParmValue = (void *)&echoTail;

   if (Is3PCCMode() ){
#ifdef IPM_SET_ECHOCANCEL
		rc = ipm_SetParm(m_ntwk_srl_handle, &ipmParmInfo, EV_SYNC);
		LOG( RC(rc), GetName(),
				 "ipm_SetParm([%s, EchoTail] %d ECHO_TAIL_64, EV_SYNC)",
				 m_ipm_name,  ECHO_TAIL_64);
		brc = ( rc == 0);
		if (!brc){
			process_ipml_error(m_ntwk_srl_handle, m_ipm_name);
		}
#endif
   } else {
		gc_util_insert_parm_ref(&gcParmBlk,
                            IPSET_CONFIG,
                            IPPARM_IPMPARM,
                            (unsigned long)sizeof(IPM_PARM_INFO),
                            &ipmParmInfo);

		rc = gc_SetUserInfo(GCTGT_GCLIB_CHAN, m_srl_handle, gcParmBlk, GC_ALLCALLS);

		LOG( RC(rc), GetName(),
			 "%d = gc_SetUserInfo [Echo cancel](GCTGT_GCLIB_CHAN, hndl = 0x%x, pParmBlk, GC_ALLCALLS)",
			rc, m_srl_handle );

		gc_util_delete_parm_blk(gcParmBlk);

		brc = (rc == GC_SUCCESS);

	    if (rc != GC_SUCCESS){
		    process_gc_error();
		}
   }
  return brc;
#else
    LOG( LOG_API, GetName(),
         "%d = gc_SetUserInfo [Echo cancel](is not supported in this release)",rc);
  return true; 
#endif
}

//*****************************************************************************
// Purpose	: 
//     Enable IPMP Events
// Parameters:	
//    none
// Returns:	
//    true = success
//*****************************************************************************
bool CIptDevice::EnableIpmlEvents(){
 // Enable IPML events
 eIPM_EVENT Events[20];
 int inx=0;
     Events[inx++] = EVT_LOSTPACKETS;
	 Events[inx++] = EVT_JITTER;
	 Events[inx++] = EVT_RTCPTIMEOUT;
	 Events[inx++] = EVT_RTPTIMEOUT;
	 Events[inx++] = EVT_RFC2833;
     Events[inx++] = EVT_DTMFDISCARDED;


  int rc  = ipm_EnableEvents(m_ntwk_srl_handle, Events, inx, EV_SYNC);

	LOG( RC(rc), m_ipm_name,
		 "%d = ipm_EnableEvents (handle=0x%x,{LOSTPACKETS,JITTER,RTCPTIMEOUT,RTPTIMEOUT,RFC2833})",
		 rc, m_ntwk_srl_handle );

  bool brc = true; 

  if (rc != 0 ){
	  brc = false;
	  process_ipml_error(m_ntwk_srl_handle, m_ipm_name);
  }
 return brc;
}

static NAME_TABLE info_name[] = {
    {  "MEDIATYPE_AUDIO_REMOTE_RTP_INFO",  MEDIATYPE_AUDIO_REMOTE_RTP_INFO }, 
    {  "MEDIATYPE_AUDIO_LOCAL_RTP_INFO",   MEDIATYPE_AUDIO_LOCAL_RTP_INFO }, 
    {  "MEDIATYPE_AUDIO_REMOTE_RTCP_INFO", MEDIATYPE_AUDIO_REMOTE_RTCP_INFO }, 
    {  "MEDIATYPE_AUDIO_LOCAL_RTCP_INFO",  MEDIATYPE_AUDIO_LOCAL_RTCP_INFO }, 
    {  "MEDIATYPE_AUDIO_REMOTE_CODER_INFO",MEDIATYPE_AUDIO_REMOTE_CODER_INFO }, 
    {  "MEDIATYPE_AUDIO_LOCAL_CODER_INFO", MEDIATYPE_AUDIO_LOCAL_CODER_INFO }, 
	//FAX
    {  "MEDIATYPE_LOCAL_UDPTL_T38_INFO",   MEDIATYPE_LOCAL_UDPTL_T38_INFO }, 
    {  "MEDIATYPE_REMOTE_UDPTL_T38_INFO",  MEDIATYPE_REMOTE_UDPTL_T38_INFO }, 
    {  "MEDIATYPE_FAX_SIGNAL",             MEDIATYPE_FAX_SIGNAL }, 

	//VIDEO
    {  "MEDIATYPE_VIDEO_REMOTE_RTP_INFO",  MEDIATYPE_VIDEO_REMOTE_RTP_INFO }, 
    {  "MEDIATYPE_VIDEO_LOCAL_RTP_INFO",   MEDIATYPE_VIDEO_LOCAL_RTP_INFO }, 
    {  "MEDIATYPE_VIDEO_REMOTE_RTCP_INFO", MEDIATYPE_VIDEO_REMOTE_RTCP_INFO }, 
    {  "MEDIATYPE_VIDEO_LOCAL_RTCP_INFO",  MEDIATYPE_VIDEO_LOCAL_RTCP_INFO }, 
    {  "MEDIATYPE_VIDEO_REMOTE_CODER_INFO",MEDIATYPE_VIDEO_REMOTE_CODER_INFO }, 
    {  "MEDIATYPE_VIDEO_LOCAL_CODER_INFO", MEDIATYPE_VIDEO_LOCAL_CODER_INFO }, 
    { 0, 0}
};

//*****************************************************************************
// Purpose	: 
//     GetLocalMediaInfo
// Parameters:	
//    none
// Returns:	
//    true = success
//*****************************************************************************
bool CIptDevice::GetLocalMediaInfo(eIPM_MEDIA_TYPE type, IPM_PORT_INFO * pInfo) {
 IPM_MEDIA_INFO LocalMediaInfo;

   // Get local media info (RTP)
   LocalMediaInfo.unCount = 1;
   LocalMediaInfo.MediaData[0].eMediaType = type;

   int rc = ipm_GetLocalMediaInfo(m_ntwk_srl_handle, &LocalMediaInfo, EV_SYNC );
   const char *name;
   str_findname(type, &name, info_name);
   LOG( RC(rc), m_ipm_name,
			 "%d = ipm_GetLocalMediaInfo (handle=0x%x,{%s}, EV_SYNC)",
			 rc, m_ntwk_srl_handle, name );

   bool brc = true;
   if (rc != 0){
       brc = false;
       process_ipml_error(m_ntwk_srl_handle, m_ipm_name);
   } else {
       bool found = false;
	   unsigned int inx;
       for (inx=0; inx<LocalMediaInfo.unCount; inx++){
           if (type == LocalMediaInfo.MediaData[inx].eMediaType) {
               *pInfo = LocalMediaInfo.MediaData[inx].mediaInfo.PortInfo;
               found = true;
           }
           const char *name;
           str_findname(LocalMediaInfo.MediaData[inx].eMediaType, &name, info_name);
           DumpPortInfo(pInfo);
           break;
       }
       if (!found){
	    	LOG( LOG_ERR1, m_ipm_name, "Error getting MEDIATYPE_AUDIO_LOCAL_RTP_INFO ( missing in responce)");
           brc = false;
       } 
       // rfc 2327:
       // Rtcp IP = Rtp IP
       // Rtcp port = IP port+ 1        
       m_LocalRtcpPort = m_LocalRtpPort;
       m_LocalRtcpPort.unPortId++;
       LOG(LOG_API, GetName(),"Local RTCP port (next)"); 
       DumpPortInfo(&m_LocalRtcpPort);
   }
  return brc; 
}

//*****************************************************************************
// Purpose	: 
//    Select coder ( 3PCC mode)
//  This procedure should select a coder using remote sdp offer 
//     Currently, only one selection is available - 
//                whatever is specified in config file
//
// Parameters:	
//    none, use received Media Info from SDP message
// Returns:	
//    true = success
//*****************************************************************************
bool CIptDevice::SelectCoder() {
 memset(&selected_coder,0,sizeof(selected_coder));

   selected_coder.eCoderType = m_pIptParams->ip_coder;
   selected_coder.eFrameSize = m_pIptParams->ip_frame_size;
   selected_coder.eVadEnable = m_pIptParams->ip_vad;

   if (m_pIptParams->ip_payoad_type == IP_USE_STANDARD_PAYLOADTYPE){
       selected_coder.unCoderPayloadType = standard_payload_type(m_pIptParams->ip_coder);
   } else {
       selected_coder.unCoderPayloadType = m_pIptParams->ip_payoad_type;
   }
   selected_coder.unRedPayloadType = 0;

 return true;
}

//*****************************************************************************
// Purpose	: 
//     Reserve Resource
// Parameters:	
//    none
// Returns:	
//    true = success
//*****************************************************************************
bool CIptDevice::ReserveResource() {
 int rc;
 bool brc = true;
 UnReserveResource();

 switch ( GetReserveResourceType() ) {
		default:
		case RESERVE_RESOURCE_NONE:
             dev_resource_list.m_type = RESERVE_RESOURCE_NONE;
			 break;

		case RESERVE_RESOURCE_EX:
             dev_resource_list.Init(&selected_coder);
             dev_resource_list.Dump(GetLog());
			 rc = dev_ReserveResourceEx(m_ntwk_srl_handle, &dev_resource_list , EV_SYNC);
			 LOG( RC(rc), m_ipm_name,
			 "%d = dev_ReserveResourceEx (0x%x, <ResourceList>, EV_SYNC)",
			  rc, m_ntwk_srl_handle );

			 if (rc == BRD_FAILURE){
  				 process_dev_error( );
				 brc = false;
			 } else {
				 dev_resource_list.m_type = RESERVE_RESOURCE_EX;
			 }
			 break;

		case RESERVE_RESOURCE:
		     rc = dev_ReserveResource(m_ntwk_srl_handle, RESOURCE_IPM_LBR , EV_SYNC);
				  LOG( RC(rc), m_ipm_name,
					   "%d = dev_ReserveResource(0x%x, RESOURCE_IPM_LBR, EV_SYNC)",
						rc, m_ntwk_srl_handle );

			  if (rc == BRD_FAILURE){
  					process_dev_error( );
					brc = false;
			  } else {
					dev_resource_list.m_type = RESERVE_RESOURCE;
			  }
			  break;
	 } // switch GetReserveResourceType()
 return brc;
}
//*****************************************************************************
// Purpose	: 
//     Reserve Resource
// Parameters:	
//    none
// Returns:	
//    true = success
//*****************************************************************************
bool CIptDevice::UnReserveResource(){
 int rc;
 bool brc = true;
	switch (dev_resource_list.m_type) {
		default:
		case RESERVE_RESOURCE_NONE:
			 break;

		case RESERVE_RESOURCE_EX:
             dev_resource_list.Dump(GetLog());
             rc = dev_ReleaseResourceEx(m_ntwk_srl_handle, &dev_resource_list, EV_SYNC);
		     LOG( RC(rc), m_ipm_name,
			       "%d = dev_ReleaseResourceEx (0x%x, <ResourceList>, EV_SYNC)",
				   rc, m_ntwk_srl_handle );

 			 if (rc == BRD_FAILURE){
  			     process_dev_error( );
                 brc = false;
			 } 
			 break;	

		case RESERVE_RESOURCE:
             rc = dev_ReleaseResource(m_ntwk_srl_handle, RESOURCE_IPM_LBR, EV_SYNC);
		     LOG( RC(rc), m_ipm_name,
			       "%d = dev_ReleaseResource (0x%x, RESOURCE_IPM_LBR, EV_SYNC)",
				   rc, m_ntwk_srl_handle );

 			 if (rc == BRD_FAILURE){
  			     process_dev_error( );
                 brc = false;
			 } 
			 break;	
	}// switch reserved_resource
 dev_resource_list.m_type = RESERVE_RESOURCE_NONE;
 return brc;
}