cbkstack.c

h.248源代码

/********************************************************************
 *
 * File:        CbkStack.c
 *
 * Description:
 * Call back functions. These are called from the satck.
 *
 * Revisions:
 *   04-may-01    J.H and S.J.M        initial version.
 *
 * Copyright 2003 Netergy Microelectronics, Inc. All rights reserved.
 *
 ********************************************************************/

#include "h248app.h"

/**************************************************************************
 * _H248InstanceCB
 *   ASYNCHRONOUS notification callback from H248 Instance
 *     hInstance - instance handle
 *     hConn - connection handle
 *     dwUserData - pointer to user data
 *     eMsg - callback type
 *     pData - callback specific data     
 **************************************************************************/

LONG H248StackCB(H_PROTOCOL_INSTANCE hInstance, DWORD dwUserData,
		 E_H248_CBKMSG eMsg, H248_CBKDATA* pData)
{
  CONNECTION *pConn;
  H_MEDIA_STREAM hStream;
  LONG lRv = PROTOCOL_SUCCESS;
  END_POINT *pEndPoint = (END_POINT*)dwUserData;

  CALLLOG(LOG_INFO, hInstance, dwUserData,
	  "_H248InstanceCB hInst=%lx,msgtype %d\n", hInstance,eMsg);
 
  /* Service type of callback */
  switch(eMsg) {

  case H248_CBKMSG_REGISTER_COMPLETE:
    g_bIsRegistered = TRUE;
    RegisteringComplete();
    break;
    
  case H248_CBKMSG_SIGNAL:
    {

      H248_CBKDATA_SIGNAL *pSignal = (H248_CBKDATA_SIGNAL *) &(pData->Signal);

      if (pSignal->lTimeOutCode == H248_SIGNAL_OFF)
	HandsetGenerateTone(pEndPoint->wChannel, AUDIO_TONE_ALL, OFF);
      else {
	switch (pSignal->eType) {

	case H248_SIGNAL_CG_DL:           /* Dial Tone */
	  HandsetGenerateTone(pEndPoint->wChannel, AUDIO_DIALTONE, ON);
	  break;

	case H248_SIGNAL_CG_RT:           /* Ringback Tone */
	  HandsetGenerateTone(pEndPoint->wChannel, AUDIO_RINGBACK, ON);
	  break;

	case H248_SIGNAL_CG_BT:           /* Busy Tone */
	  HandsetGenerateTone(pEndPoint->wChannel, AUDIO_NETWORKBUSY, ON);
	  break;

	case H248_SIGNAL_CG_CT:           /* Congestion Tone */
	case H248_SIGNAL_CG_SIT:          /* Special Information Tone */
	case H248_SIGNAL_CG_WT:           /* Warning Tone */
	case H248_SIGNAL_CG_PT:           /* Payphone Recognition Tone */
	  HandsetGenerateTone(pEndPoint->wChannel, AUDIO_TONE_ALL, OFF);
	  break;

	case H248_SIGNAL_CG_CW:           /* Call Waiting Tone */
	  HandsetGenerateTone(pEndPoint->wChannel, AUDIO_CALLWAITING, ON);
	  break;

	case H248_SIGNAL_CG_CR:           /* Caller Waiting Tone */
	  break;
	
	case H248_SIGNAL_L_CI:        /*Caller ID*/	
	  {
	    CALLER_ID_INFO xCallerIdInfo;
	    memset(&xCallerIdInfo,0,sizeof(CALLER_ID_INFO));   
	    strncpy(xCallerIdInfo.pcCallerNumber,
                    pSignal->xSigParam.xCiData.pcNumber, 19);
	    strncpy(xCallerIdInfo.pcCallerName,
                    pSignal->xSigParam.xCiData.pcName, 19);
	    HandsetStoreCallerID(pEndPoint->wChannel,&xCallerIdInfo);
  	    HandsetDisplayCallerID(pEndPoint->wChannel,&xCallerIdInfo); 
	  }
	  break;
 
	case H248_SIGNAL_L_RI:	       /* Ringing Tone */
	  HandsetGenerateTone(pEndPoint->wChannel, HANDSET_RING_CADENCE_0, ON);
	  break;

	default:
	  break;
	}
      }
    }
    break;

  case H248_CBKMSG_CREATE:
    {     
      ASSERT(NULL == ConnFindInstance(hInstance));
      pConn = ConnCreate(hInstance);

      CALLLOG(LOG_INFO, hInstance, dwUserData,
	      "_H248InstanceCB():: %lx H248_CBKMSG_CREATE\n", hInstance);
      pData->MediaCreate.dwUser = (DWORD)pConn;

    }
    break;

  case H248_CBKMSG_RESERV:
    if (NULL == (pConn = ConnFindInstance(hInstance))) {
      lRv = PROTOCOL_GEN_FAIL;
    }
    else {
      PROTOCOL_MEDIA_CAP *pCap = &pData->MediaReserv.xCap;
      /* to-do: use audio query api tp find the capability */
      if (MediaCapSupported(pCap->oPayload) == TRUE &&
	  ReservResource(pConn, pCap,pData->MediaReserv.eReservType)== TRUE){
	pData->MediaReserv.bAvailable = TRUE;
	if(pCap->eTxRx == PROTOCOL_TXRX_RX){
	  /* Local stream; fill in the local information */

	  PROTOCOL_CAP xCap;

	    hStream = MediaStreamFind(pConn->hInstance);
	    ASSERT(hStream);
	    
	    MediaStreamGetCap(hStream, &xCap, PROTOCOL_TXRX_RX);
	   
	    pCap->dwIPAddress = xCap.xCmn.dwIPAddress;
	    pCap->wRTPPort = xCap.xCmn.wPort;
	    pCap->wRTCPPort = xCap.xCmn.wCtlPort;
	    // pCap->bSilenceSuppression = xCap.u.xAudio.bSilenceSuppression;

	}
      }
      else {
	pData->MediaReserv.bAvailable = FALSE;
      }
    }
    break;
    
  case H248_CBKMSG_DELETE:
    lRv = ConnDestroy(hInstance);
    break;

  case H248_CBKMSG_MODIFY:
    break;
    
  case H248_CBKMSG_SETMEDIAMODE:
    CALLLOG(LOG_INFO, hInstance, dwUserData, 
	    "_H248InstanceCB():: %lx H248_CBKMSG_SETMEDIAMODE\n", hInstance);
    CALLLOG(LOG_INFO, hInstance, dwUserData,
	    "Set mode on channel %lx %s %s to %d.%d.%d.%d:%d:%d\n>",
	    pData->SetMediaMode.dwMediaChannelId,
	    (pData->SetMediaMode.xTxCapMedia.eTxRx == 
             PROTOCOL_TXRX_TX)?"TX":"RX",
	    (pData->SetMediaMode.xTxCapMedia.oPayload==PROTOCOL_RTPPAYLOAD_PCMU)?
	    "G711U":  
	    (pData->SetMediaMode.xTxCapMedia.oPayload==PROTOCOL_RTPPAYLOAD_PCMA)?
	    "G711A":
	    (pData->SetMediaMode.xTxCapMedia.oPayload==PROTOCOL_RTPPAYLOAD_G723)?
	    "G723":
	    (pData->SetMediaMode.xTxCapMedia.oPayload==PROTOCOL_RTPPAYLOAD_G729)?
	    "G729":
	    (pData->SetMediaMode.xTxCapMedia.oPayload==PROTOCOL_RTPPAYLOAD_G726)?
	    "G726":
	    "unknown codec",
	    ((OCTET)(pData->SetMediaMode.xTxCapMedia.dwIPAddress>>24)&0xff),
	    ((OCTET)(pData->SetMediaMode.xTxCapMedia.dwIPAddress>>16)&0xff),
	    ((OCTET)(pData->SetMediaMode.xTxCapMedia.dwIPAddress>>8)&0xff),
	    ((OCTET)(pData->SetMediaMode.xTxCapMedia.dwIPAddress)&0xff),
	    pData->SetMediaMode.xTxCapMedia.wRTPPort,
	    pData->SetMediaMode.xTxCapMedia.wRTCPPort
	    );

    if (NULL == (pConn = ConnFindInstance(hInstance))) {
      lRv = PROTOCOL_GEN_FAIL;
    }
    else {

      memcpy(&(pConn->xCapTx),
             &(pData->SetMediaMode.xTxCapMedia),
             sizeof(PROTOCOL_MEDIA_CAP));
      memcpy(&(pConn->xCapRx),
             &(pData->SetMediaMode.xRxCapMedia),
             sizeof(PROTOCOL_MEDIA_CAP));
      pConn->eMediaMode =  pData->SetMediaMode.eMode;
      lRv = ConnSetMediaMode(pConn);
    }
    break;
        
  case H248_CBKMSG_ASSOCIATE:
    {
      END_POINT *plEndPoint = NULL; 
      pConn = NULL;

      ASSERT(pData->Associate.eAPartType !=  H248_ASSOCIATION_PART_ENDPOINT || 
	     pData->Associate.eBPartType !=  H248_ASSOCIATION_PART_ENDPOINT);

      if(pData->Associate.eAPartType ==  H248_ASSOCIATION_PART_STREAM &&
	 pData->Associate.eBPartType ==  H248_ASSOCIATION_PART_STREAM &&
	 pData->Associate.eAssociationType == H248_ASSOCIATION_BOTH_WAYS){

	ConnMixMedia( ConnFindInstance(pData->Associate.dwAPart),
		  ConnFindInstance(pData->Associate.dwBPart));
	break;

      }
      
      if(pData->Associate.eAPartType ==  H248_ASSOCIATION_PART_ENDPOINT)
	plEndPoint = (END_POINT*)pData->Associate.dwAPart;
      else
	pConn = ConnFindInstance(pData->Associate.dwAPart);

      if(pData->Associate.eBPartType ==  H248_ASSOCIATION_PART_ENDPOINT)
	plEndPoint = (END_POINT*)pData->Associate.dwBPart;
      else
	pConn = ConnFindInstance(pData->Associate.dwBPart);
      
      ASSERT(pConn);
      CALLLOG(LOG_INFO, hInstance, plEndPoint,
              "Associate connection %lx with endpoint %s\n",
	      (DWORD)pConn, plEndPoint->szTermName);

      ConnAssociate(pConn, plEndPoint, pData->Associate.eAssociationType);
    }
    break;

  case H248_CBKMSG_QUERY_HANDSET_STATUS:
    {
      DWORD dwStatus = 0;
      /* foofoo this was not defined previously */
      /* dwStatus = HandsetGetHandsetStatus(pEndPoint->wChannel);*/

      switch(dwStatus){

      case 1: 
	pData->HandSetStatus.eStatus = HANDSET_STATUS_OFF_HOOK;
	break;

      case 2: 
	pData->HandSetStatus.eStatus = HANDSET_STATUS_ON_HOOK;
	break;
      }
    }
    break;

  case H248_CBKMSG_SET_EC:
    HandsetSetChannelEchoCancellation(pEndPoint->wChannel,
                                      pData->ECMode.bECMode);
    break;

  default: 
    CALLLOG(LOG_INFO, 0, hInstance,
	    "Callback message type %d not processed\n",eMsg);
    ASSERT(0);
  }
    
  return PROTOCOL_SUCCESS;
}