iptdevice.cpp

Conferencing code using Dialogic hardware

void CnfDemoResourceList::Init(IPM_CODER_INFO *pCoder){
	count = 0;
    switch(pCoder->eCoderType){
        case CODER_TYPE_G711ALAW64K:
        case CODER_TYPE_G711ALAW56K:
        case CODER_TYPE_G711ULAW64K:
        case CODER_TYPE_G711ULAW56K:
        case CODER_TYPE_G721ADPCM:

		default:
             switch (pCoder->eFrameSize){
                default:
                     GLBLOG(LOG_ERR2, "CnfDemoResourceList", "FrameSize %d: not supported",pCoder->eFrameSize);
                     break;
                case CODER_FRAMESIZE_5:
                    // Not supported
                     GLBLOG(LOG_ERR2, "CnfDemoResourceList", "CODER_FRAMESIZE_5: not supported");       
                     break;
                case CODER_FRAMESIZE_10:
                     rsList[count++] = RESOURCE_IPM_G711_10MS;
                     break;
                case CODER_FRAMESIZE_20:
                     rsList[count++] = RESOURCE_IPM_G711_20MS;
                     break;
                case CODER_FRAMESIZE_30:
   			         rsList[count++] = RESOURCE_IPM_G711_30MS;
                     break;
             }  // switch ip_frame_size
			 break;

		case CODER_TYPE_G7231_5_3K:
		case CODER_TYPE_G7231_6_3K:
			 rsList[count++] = RESOURCE_IPM_G723;
			 break;
	}
 return;
};

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//*****************************************************************************
// Purpose	: 
//    Constructor
// Parameters:	
//    Configuration parameters ( from configuration file )
// Returns:	
//    none
//*****************************************************************************
CIptDevice::CIptDevice(PCommonParams pCommonParams,
                       PIptParams pIptParams ) 
                     : CNtwkDevice(DEV_IPT, pCommonParams, 0) { 

    m_pIptParams = pIptParams;
    SelectCoder();  
    m_ipm_name = 0;


    if (EXIT_OK == GetExitCode()){
       if (! OpenPrivateLog(m_pIptParams->m_private_log) ){
                SetExitCode(EXIT_LOG);
       }

       if ( EXIT_OK == GetExitCode() ){
             // dx_open etc. 
           if (!open_dx()){
               SetExitCode(EXIT_INIT);
           }
       }

       if ( EXIT_OK == GetExitCode() ){
             // gc_open  etc. 
           if (! Open() ){
               SetExitCode(EXIT_INIT);
           }
       }

    }

    pIptParams->Dump(GetLog());

    m_pSdpParser = 0;
	if (Is3PCCMode()){
		if (GetLog()) {
			m_pSdpParser = new CSdpParser(GetLog());	// parcer for 3PCC mode
		}else {
			m_pSdpParser = new CSdpParser(glb_pAppLog);
		}
	}

    memset(&m_LocalRtpPort, 0, sizeof(m_LocalRtpPort));
    memset(&m_LocalRtcpPort, 0, sizeof(m_LocalRtpPort));
    m_ipm_started = false;

 return;
} // End of Constructor() 

//*****************************************************************************
// Purpose	: 
//    Destructor
// Parameters:	
//    none
// Returns:	
//    none
//*****************************************************************************
CIptDevice::~CIptDevice() {
    
    delete m_pSdpParser;
   // UnReserve
   glb_pDetectCfg->UnReserve(DEV_IPM,m_ipm_name);

 return;
} // End of Destructor() 

//*****************************************************************************
// Function	: 
//    OnNewCall():    specific cleanup and init for new call
//    OnNewCall:      specific one-time initialization
// Parameters:	
//    none
// Returns:	
//    true = success
//    false = failure
//*****************************************************************************
bool CIptDevice::OnNewCall() {
   LOG(LOG_APP, GetName(), "Ready to answer %s calls", m_pIptParams->ip_protocol);
   return SetDtmfTransfer();

} // End of OnNewCall() 

bool CIptDevice::OnInitComplete() {
  bool brc = SetCoders();
       brc = SetDtmfTransfer() && brc;
       brc = EnableEchoCancel() && brc;
 return brc;
} // End of OnInitComplete() 

//*****************************************************************************
// Purpose	: 
//    Close device
// Parameters:	
//    none
// Returns:	
//    true = success
//    false = failure
//*****************************************************************************
bool CIptDevice::Close(){
int rc;
	if (separate_ntwk_open){
        UnReserveResource();
		rc = ipm_Close(m_ntwk_srl_handle,0);
		m_ntwk_srl_handle = INV_SRL_HANDLE;
        LOG( RC(rc), m_ipm_name,
             "%d = ipm_Close (0x%x, 0)",
             rc, m_ntwk_srl_handle );

	}
  return CNtwkDevice::Close();
}

//*****************************************************************************
// Purpose	: 
//    Open device
// Parameters:	
//    none
// Returns:	
//    true = success
//    false = failure
//*****************************************************************************
bool CIptDevice::Open(){
 bool brc = false;
 int rc;
 if (IsSrlState(SRLSTATE_VOICEOPENED, true) ) {
     if (    IsSrlState(SRLSTATE_RESERVED, true)  ) { 
          if ( glb_pDetectCfg->Reserve(DEV_IPM, &m_ipm_name) ){
               char gc_name[200];
			   if (Is3PCCMode()){
				   snprintf(gc_name, sizeof(gc_name), ":N_%s:P_%s",
                            GetName(), m_pIptParams->ip_protocol);
			   }else {
				   snprintf(gc_name, sizeof(gc_name), ":N_%s:P_%s:M_%s",
                            GetName(), m_pIptParams->ip_protocol, m_ipm_name);
			   }

	   		   OpenIpml(); // 3PCC mode

               rc = gc_OpenEx(&m_srl_handle, gc_name,EV_ASYNC, this);
               LOG( RC(rc), GetName(),
                    "%d = gc_OpenEx(hndl := 0x%x, %s, EV_ASYNC,0x%x(this) )",
                    rc, m_srl_handle, gc_name, this);

               if (rc == GC_SUCCESS){
                    brc = true ;
                    SetCurrentState(S_OPEN);
                    SetSrlState(SRLSTATE_OPENED);
               }else {
                    process_gc_error();
                    SetCurrentState(S_FINAL);
               }

          }
     } // if ipt is reserved
     else {
           LOG( LOG_ERR1, GetName(), "gc_Open(): (board) - device not reserved");
     } 
 } // if voice is opened
 if (!brc){     
     SetSrlState(SRLSTATE_FAILED_FATAL);
 }

 return brc;
} // End of Open() 


//*****************************************************************************
// Purpose	: 
//    Retrieve IP data (SDP)
// Parameters:	
//   [in] METAEVENT 
// Returns:	
//    none
//*****************************************************************************
void CIptDevice::RetrieveIpData(METAEVENT *metaeventp){
  GC_PARM_BLK *pBlock = (GC_PARM_BLK *)(metaeventp->extevtdatap);
  GC_PARM_DATA_EXT parm;
  INIT_GC_PARM_DATA_EXT(&parm);

  while ( GC_SUCCESS == gc_util_next_parm_ex(pBlock, &parm) ){
		  dump_parm(&parm);
          if (Is3PCCMode()){
			  if ((IPSET_SDP == parm.set_ID ) && (IPPARM_SDP_OFFER == parm.parm_ID) ) {
					 m_pSdpParser->SetBuffer((const char *)parm.pData);
					 m_pSdpParser->ParseSdpOffer();
                     // according to offered sdp, select coder in selected_coder
                     SelectCoder();
                     // According to selected_coder, reserve appropriate resource
                     // This may switch between HOST IP and Board IP 
                     ReserveResource();
                     // In Titusville, local media info depends of selected coder
                     // GetLocalMediaInfo is executed after each coder selection
                     GetLocalMediaInfo(MEDIATYPE_AUDIO_LOCAL_RTP_INFO, &m_LocalRtpPort);
			  }
          }
  } // while
  if (Is3PCCMode()) {
	  m_pSdpParser->Dump();
	  if (m_pSdpParser->m_MediaInfo.sdp_k){
		 // encryption not supported
			LOG(LOG_WARNING, GetName(), "Encryprtion not supported, dropping this call");
            DropRequest();
	  }
  }
 return;
}

//*****************************************************************************
// Purpose	: 
//    Handle events
// Parameters:	
//   [in] event
//   [in] event data
//   [in] data length
//   [in] METAEVENT 
// Returns:	
//    none
//*****************************************************************************
void CIptDevice::HandleEvent(int event,
                             void *evtdata, int evtlen,
                             METAEVENT *metaeventp){

    switch (event){
        case GCEV_OPENEX:
            // Permanent setup
            // Get Network handle ( GC_MEDIADEVICE or GC_NETWORKDEVICE
             GetMediaResourceHandle();
             break;

		case GCEV_ANSWERED:
             RetrieveIpData(metaeventp);
             break;

		case GCEV_ACCEPT:
             RetrieveIpData(metaeventp);
             break;

        case GCEV_REQ_MODIFY_CALL:
        case GCEV_OFFERED:
             RetrieveIpData(metaeventp);
             break;

        case IPMEV_QOS_ALARM:
             OnReceiveAlarmEvent((IPM_QOS_ALARM_DATA *)evtdata);
             break;

        default:
             break;
    } // switch  (event)

    CNtwkDevice::HandleEvent(event, evtdata, evtlen, metaeventp);

 return ;
} // End of HandleEvent

static NAME_TABLE qos_name_table[] = {
    { "QOSTYPE_DTMFDISCARDED", QOSTYPE_DTMFDISCARDED },
    { "QOSTYPE_LOSTPACKETS", QOSTYPE_LOSTPACKETS},
    { "QOSTYPE_JITTER", QOSTYPE_JITTER},
    { "QOSTYPE_ROUNDTRIPLATENCY", QOSTYPE_ROUNDTRIPLATENCY},
    { "QOSTYPE_RTCPTIMEOUT", QOSTYPE_RTCPTIMEOUT},
    { "QOSTYPE_RTPTIMEOUT", QOSTYPE_RTPTIMEOUT},
    { "QOSTYPE_SEC_AUTH_FAIL_AUDIO", QOSTYPE_SEC_AUTH_FAIL_AUDIO},
    { "QOSTYPE_SEC_AUTH_FAIL_VIDEO", QOSTYPE_SEC_AUTH_FAIL_VIDEO},
    { "QOSTYPE_SEC_PKT_REPLAY_AUDIO", QOSTYPE_SEC_PKT_REPLAY_AUDIO},
    { "QOSTYPE_SEC_PKT_REPLAY_VIDEO", QOSTYPE_SEC_PKT_REPLAY_VIDEO},
    { "QOSTYPE_SEC_MKI_NOMATCH_AUDIO", QOSTYPE_SEC_MKI_NOMATCH_AUDIO},
    { "QOSTYPE_SEC_MKI_NOMATCH_VIDEO", QOSTYPE_SEC_MKI_NOMATCH_VIDEO},
    { "QOSTYPE_NETWORKFAILURE", QOSTYPE_NETWORKFAILURE},
    { 0, 0}
};

static NAME_TABLE state_name_table[] = {
    { "ALARM_STATE_OFF",  ALARM_STATE_OFF },
    { "ALARM_STATE_ON",  ALARM_STATE_ON },
    { 0,0 }
};

static CNameTable state_table (state_name_table);
static CNameTable qos_table (qos_name_table);

//*****************************************************************************
// Purpose	: 
//    Handle QOS Alarm
// Parameters:	
//    alarm data
// Returns:	
//    true = success
//*****************************************************************************
void CIptDevice::OnReceiveAlarmEvent(IPM_QOS_ALARM_DATA * alarm_data){
    const char *state_name = qos_table.find_name(alarm_data->eQoSType);
    const char *alarm_type = state_table.find_name(alarm_data->eAlarmState);

	LOG(LOG_WARNING, GetName(), "Received QOS Alarm" );
	LOG(LOG_WARNING, GetName(), "    Type  = %d %s",alarm_data->eQoSType,alarm_type );
	LOG(LOG_WARNING, GetName(), "    State = %d %s",alarm_data->eAlarmState,state_name );
 return;
}
//*****************************************************************************
// Purpose	: 
//    Set coders according to configuration file
// Parameters:	
//    none
// Returns:	
//    true = success
//*****************************************************************************
bool CIptDevice::SetCoders(){

if (Is3PCCMode()){
	 LOG( LOG_API, GetName(),
		 "SetCoders(): skip in 3PCC mode");
	 return true;
} 

int rc;
bool brc;
IP_CAPABILITY ipCap;
GC_PARM_BLKP pParmBlk = 0;

 int coder = m_pIptParams->ip_coder;       // CODER_TYPE_G711ALAW64K;
 int vad   = m_pIptParams->ip_vad;         // CODER_VAD_DISABLE;
 int frame = m_pIptParams->ip_frame_size;  // CODER_FRAMESIZE_30;

	memset(&ipCap, 0, sizeof(ipCap));

	ipCap.capability = coder;
	ipCap.type = GCCAPTYPE_AUDIO;
	ipCap.extra.audio.frames_per_pkt = frame;  
	ipCap.extra.audio.VAD = (unsigned short)vad;
	ipCap.payload_type = m_pIptParams->ip_payoad_type;
	ipCap.direction = IP_CAP_DIR_LCLTRANSMIT;
	
    rc =  gc_util_insert_parm_ref( &pParmBlk,
                                   GCSET_CHAN_CAPABILITY, IPPARM_LOCAL_CAPABILITY,
						           sizeof (IP_CAPABILITY), &ipCap);


    brc = (rc == GC_SUCCESS);

	if (brc) {
		ipCap.direction = IP_CAP_DIR_LCLRECEIVE;
        rc =  gc_util_insert_parm_ref( &pParmBlk,
                                   GCSET_CHAN_CAPABILITY, IPPARM_LOCAL_CAPABILITY,
						           sizeof (IP_CAPABILITY), &ipCap);
        brc = (rc == GC_SUCCESS);

	    if (brc) {

			rc = gc_SetUserInfo(GCTGT_GCLIB_CHAN, m_srl_handle, pParmBlk, GC_ALLCALLS);
			brc = (rc == GC_SUCCESS);

		    LOG( LOG_API, GetName(),
                 "SetCoders(): Coder = %d %s GC_ALLCALLS",
                 ipCap.capability, ip_coder_name(ipCap.capability));

		    LOG( LOG_API, GetName(),
                 "             FrameSize = %d %s",
                 ipCap.extra.audio.frames_per_pkt, ip_framesize_name(ipCap.extra.audio.frames_per_pkt));

		    LOG( LOG_API, GetName(),
                 "             Vad = %d %s",
                 ipCap.extra.audio.VAD, ip_vad_name(ipCap.extra.audio.VAD));

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

            if (rc != GC_SUCCESS){
                process_gc_error();
            }
        } // if brc (success second insert parm)

    	gc_util_delete_parm_blk(pParmBlk);
    } // if brc (success first insert parm)
 	return brc;
} // End of SetCoders()

//*****************************************************************************
// Purpose	: 
//    Set DTMF transfer type according to configuration file
// Parameters:	
//    none
// Returns: