connection.c

h.248源代码

/********************************************************************
 *
 * File:        connection.c
 *
 * Description:
 *        
 * Revisions:
 *
 * Copyright 2003 Netergy Microelectronics, Inc. All rights reserved.
 *
 ********************************************************************/
#include "h248app.h"

CONNECTION* ConnCreate(H_PROTOCOL_INSTANCE hInstance)
{
  CONNECTION *pConn;
  H_MEDIA_STREAM hStream;
  PROTOCOL_CAP xCapLocal;

  if (NULL != (pConn = ConnFindInstance(hInstance)) ||
      NULL == (pConn = calloc(1, sizeof(CONNECTION)))) {
    return NULL;
  }

  pthread_mutex_lock(&mMutexConn);

  DLLIST_append(pdllConn, pConn);
  pConn->hInstance = hInstance;

  ASSERT(NULL == MediaStreamFind(hInstance));
  hStream = MediaStreamCreate(PROTOCOL_MEDIA_AUDIO, hInstance);
  ASSERT(hStream);

  memset(&xCapLocal, 0 , sizeof(PROTOCOL_CAP));
  /* This is a dume stream. It will be used to 
     retrieve date about the local rtp and rtcp*/
  xCapLocal.eMedia = PROTOCOL_MEDIA_AUDIO;
  xCapLocal.xCmn.eTxRx = PROTOCOL_TXRX_RX;
  xCapLocal.xCmn.oPayload = PROTOCOL_RTPPAYLOAD_PCMA;
  xCapLocal.xCmn.pcEncodeName =  NULL;

  MediaStreamSetCap(hStream, &xCapLocal);

  pConn->eMediaMode =  PROTOCOL_TXRX_STOP; 
  pConn->bIsModeUpToDate = FALSE;
  pthread_mutex_unlock(&mMutexConn);
  
  return pConn;
}


LONG ConnDestroy(H_PROTOCOL_INSTANCE hInstance)
{
  CONNECTION *pConn = ConnFindInstance(hInstance);
  LONG lRv = PROTOCOL_SUCCESS;
  H_MEDIA_STREAM hStream, hStreamEndPoint;

  if (pConn == NULL) {
    lRv = PROTOCOL_GEN_FAIL;

  }
  else {
    pthread_mutex_lock(&mMutexConn);
    hStream = MediaStreamFind(hInstance);
    ASSERT(hStream);

    /*Media stream needs to be associated before calling MediaStreamDestroy*/
    if(!pConn->pEndPoint){
      hStreamEndPoint = MediaStreamFind(xEndPoint[0].hInstance);
      MediaStreamAssociate(hStream, hStreamEndPoint,
                           PROTOCOL_ASSOCIATE_BIDIRECTION);
    }

    MediaStreamDestroy(hStream);
    DLLIST_remove(pdllConn);
    free(pConn);   
    pthread_mutex_unlock(&mMutexConn);
  }
  
  return lRv;
}


CONNECTION* ConnFindInstance(H_PROTOCOL_INSTANCE hInstance)
{
  CONNECTION *pConn;

  pthread_mutex_lock(&mMutexConn);

  DLLIST_head(pdllConn);

  while ((pConn = DLLIST_read(pdllConn))) {
    if (pConn->hInstance == hInstance)
      break;
    else
      DLLIST_next(pdllConn);
  }
  
  pthread_mutex_unlock(&mMutexConn);

  return pConn;
}


CONNECTION* ConnFindEndpoint(END_POINT *pEndPoint)
{
  CONNECTION *pConn;

  pthread_mutex_lock(&mMutexConn);

  DLLIST_head(pdllConn);

  while ((pConn = DLLIST_read(pdllConn))) {
    if (pConn->pEndPoint == pEndPoint)
      break;
    else
      DLLIST_next(pdllConn);
  }
  
  pthread_mutex_unlock(&mMutexConn);

  return pConn;
}


LONG ConnSetMediaMode(CONNECTION *pConn)
{
  H_MEDIA_STREAM hStream;
  PROTOCOL_CAP xCapLocal, xCapRemote;

  pthread_mutex_lock(&mMutexConn);
 
  if(!pConn->pEndPoint)
    return 0;
 	
  hStream = MediaStreamFind(pConn->hInstance);
  ASSERT(hStream);
  
  memset(&xCapLocal, 0, sizeof(PROTOCOL_CAP));
  memset(&xCapRemote, 0, sizeof(PROTOCOL_CAP));

  xCapLocal.eMedia = PROTOCOL_MEDIA_AUDIO;
  xCapLocal.u.xAudio.oPacketization =  pConn->xCapRx.oPacketization;
  xCapLocal.u.xAudio.bSilenceSuppression =  pConn->xCapRx.bSilenceSuppression;
  xCapLocal.xCmn.eTxRx =  PROTOCOL_TXRX_RX;
  xCapLocal.xCmn.dwIPAddress =  pConn->xCapRx.dwIPAddress;
  xCapLocal.xCmn.pcEncodeName =  NULL;
  xCapLocal.xCmn.wPort =  pConn->xCapRx.wRTPPort;
  xCapLocal.xCmn.wCtlPort =  pConn->xCapRx.wRTCPPort;
  xCapLocal.xCmn.oPayload =  pConn->xCapRx.oPayload;

  xCapRemote.eMedia = PROTOCOL_MEDIA_AUDIO;
  xCapRemote.u.xAudio.oPacketization = pConn->xCapTx.oPacketization;
  xCapRemote.u.xAudio.bSilenceSuppression = pConn->xCapTx.bSilenceSuppression;
  xCapRemote.xCmn.eTxRx =  PROTOCOL_TXRX_TX;
  xCapRemote.xCmn.dwIPAddress =  pConn->xCapTx.dwIPAddress;
  xCapRemote.xCmn.pcEncodeName =  NULL;
  xCapRemote.xCmn.wPort =  pConn->xCapTx.wRTPPort;
  xCapRemote.xCmn.wCtlPort =  pConn->xCapTx.wRTCPPort;
  xCapRemote.xCmn.oPayload =  pConn->xCapTx.oPayload;

  MediaStreamSetCap(hStream, &xCapLocal);
  MediaStreamSetCap(hStream, &xCapRemote);
  
  MediaStreamStatus(hStream, pConn->eMediaMode);

  pConn->bIsModeUpToDate = TRUE;  

  pthread_mutex_unlock(&mMutexConn);
  return 0;
}

LONG ConnAssociate(CONNECTION *pConn, END_POINT *pEndPoint, 
		   E_H248_ASSOCIATION_TYPE eAssociationType)
{
  H_MEDIA_STREAM hStream1,hStream2;
  pthread_mutex_lock(&mMutexConn);

  if(pConn->pEndPoint)
    return 0;

  pConn->pEndPoint = pEndPoint;

  hStream1 = MediaStreamFind(pConn->hInstance);
  ASSERT(hStream1);
  
  hStream2 = MediaStreamFind(pEndPoint->hInstance);
  ASSERT(hStream2);

  switch(eAssociationType){
  case H248_ASSOCIATION_BOTH_WAYS:
    MediaStreamAssociate(hStream1, hStream2,  PROTOCOL_ASSOCIATE_BIDIRECTION);
    break;
    
  case H248_ASSOCIATION_ISOLATE:
    /* MediaStreamAssociate(hStream1, hStream2,  PROTOCOL_ASSOCIATE_ISOLATE); */
    break;
    
  case H248_ASSOCIATION_ONE_WAY:
    /*MediaStreamAssociate(hStream1, hStream2,  PROTOCOL_ASSOCIATE_ONEWAY);*/
    break;	
  }

  if((pConn->eMediaMode == PROTOCOL_TXRX_TXRX) &&
     pConn->pEndPoint &&!pConn->bIsModeUpToDate)
    ConnSetMediaMode(pConn);
      
  pthread_mutex_unlock(&mMutexConn);
  return 0;
}


LONG ConnMixMedia(CONNECTION *pConnA, CONNECTION *pConnB)
{
  H_MEDIA_STREAM hStreamA,hStreamB;
  ASSERT(pConnA->pEndPoint && pConnB->pEndPoint);  
 
  hStreamA = MediaStreamFind(pConnA->hInstance);
  hStreamB = MediaStreamFind(pConnB->hInstance);

  ASSERT(hStreamB && hStreamB);

  MediaStreamAssociate(hStreamA, hStreamB, PROTOCOL_ASSOCIATE_BIDIRECTION);
  return 0;
}