ms_create.c

DSP 播放语音文件例子

  hStream = DLLIST_find(g_pdllStream, pStream, NULL);

  if (NULL == hStream) {
    ASSERT(0);
  } else {
    DLLIST_remove(g_pdllStream);
    _MS_Destroy(pStream);
  }
  MS_UNLOCK();
}


LONG
MediaStreamAssociateChannel(H_MEDIA_STREAM pStream, DWORD dwChannel)
{
  LONG lRet = PROTOCOL_SUCCESS;

  ASSERT(dwChannel > 0);

  pStream->oChannel = dwChannel;

  switch (pStream->eType) {

  case PROTOCOL_MEDIA_AUDIO:
    if (pStream->pTx) {
      AudioStreamAssocChannel(((MS_AUDIO*)pStream->pTx)->hAudStream, dwChannel);
    }
    if (pStream->pRx) {
      AudioStreamAssocChannel(((MS_AUDIO*)pStream->pRx)->hAudStream, dwChannel);
    }
    break;
#ifdef MEDIASTREAM_T38_SUPPORT
  case PROTOCOL_MEDIA_DATA:
    if (pStream->pT38) {
      AudioStreamAssocChannel(pStream->pT38->hTxStream, dwChannel);
      AudioStreamAssocChannel(pStream->pT38->hRxStream, dwChannel);
    }
    break;
#endif
  default:
    ASSERT(0);
    lRet = PROTOCOL_GEN_FAIL;
    break;
  }

  return lRet;
}


void _AssocAudStream(H_MEDIA_STREAM hStream1, H_MEDIA_STREAM hStream2,
                     E_PROTOCOL_ASSOCIATE eAssociate)
{
  BOOL bMix1 = TRUE;
  BOOL bMix2 = TRUE;

  switch (eAssociate) {
  case PROTOCOL_ASSOCIATE_BIDIRECTION:
    break;
  case PROTOCOL_ASSOCIATE_ONEWAY:
    bMix2 = FALSE;
    break;
  case PROTOCOL_ASSOCIATE_ONEWAY_R:
    bMix1 = FALSE;
    break;
  case PROTOCOL_ASSOCIATE_ISOLATE:
    bMix1 = FALSE;
    bMix2 = FALSE;
    break;
  }

  if (hStream1->pTx && hStream2->pRx) {
    AudioStreamMix(hStream1->pTx->hAudStream, hStream2->pRx->hAudStream, bMix1);
  }
  if (hStream2->pTx && hStream1->pRx) {
    AudioStreamMix(hStream2->pTx->hAudStream, hStream1->pRx->hAudStream, bMix2);
  }
}


LONG MediaStreamAssociate(H_MEDIA_STREAM hStream1, H_MEDIA_STREAM hStream2,
                          E_PROTOCOL_ASSOCIATE eAssociate)
{
  LONG lRet = PROTOCOL_SUCCESS;

  switch (hStream1->eType) {

  case PROTOCOL_MEDIA_AUDIO:
    switch (hStream2->eType) {
    case PROTOCOL_MEDIA_LINE:
      MediaStreamAssociateChannel(hStream1, hStream2->oChannel);
      break;
    case PROTOCOL_MEDIA_AUDIO:
      _AssocAudStream(hStream1, hStream2, eAssociate);
      break;
    default:
      ASSERT(0);
      lRet = PROTOCOL_GEN_FAIL;
      break;
    }
    break;

  case PROTOCOL_MEDIA_DATA:
    switch (hStream2->eType) {
    case PROTOCOL_MEDIA_LINE:
      MediaStreamAssociateChannel(hStream1, hStream2->oChannel);
      break;
    default:
      lRet = PROTOCOL_GEN_FAIL;
      break;
    }
    break;

  case PROTOCOL_MEDIA_LINE:
    switch (hStream2->eType) {
    case PROTOCOL_MEDIA_AUDIO:
    case PROTOCOL_MEDIA_DATA:
      MediaStreamAssociateChannel(hStream2, hStream1->oChannel);
      break;
    case PROTOCOL_MEDIA_LINE:
      AudioChannelAssocChannel(hStream1->oChannel, hStream2->oChannel);
    default:
      ASSERT(0);
      lRet = PROTOCOL_GEN_FAIL;
      break;
    }
    break;

  default:
    ASSERT(0);
    lRet = PROTOCOL_GEN_FAIL;
    break;
  }

  return lRet;
}

LONG
MediaStreamCreateAudInstance(H_MEDIA_STREAM pStream, 
                             PROTOCOL_CAP *pCap,
                             E_PROTOCOL_TXRX eTxRx)
{
  MS_AUDIO *pInst = calloc(1, sizeof(MS_AUDIO));
  H_SYS_BUFFER hAudio = 0;
  H_PROTOCOL_INSTANCE hRtp;
  uAudioStreamParam uParam;
  PROTOCOL_CAP_COMMON *pCapCmn = &pCap->xCmn;
  PROTOCOL_CAP_COMMON *pInstCapCmn = &pInst->xCapCmn;
  LONG lRet;

  ASSERT(pInst);
  SET_TAG(pInst, MS_TAG_AUD);

  memcpy(&pInst->xCapAud, &pCap->u.xAudio, sizeof(PROTOCOL_CAP_AUDIO));
  memcpy(pInstCapCmn, pCapCmn, sizeof(PROTOCOL_CAP_COMMON));
  if (pCapCmn->pcEncodeName) {
    pInstCapCmn->pcEncodeName = strdup(pCapCmn->pcEncodeName);
  }

  /* create RTP instance */
  lRet = RTPInstanceCreate(&hRtp, (DWORD)pStream, &_RTPInstanceCB);
  ASSERT(lRet==PROTOCOL_SUCCESS);
  RTPInstanceSetPolling(hRtp, TRUE);

  if (eTxRx == PROTOCOL_TXRX_TX) {
    ASSERT(pStream->pTx == NULL);
    pStream->pTx = pInst;

    /* Create Audio Encoder Instance */
    uParam.xEncoder.eCodecType = _MapPayloadToCodec(pCapCmn);
    uParam.xEncoder.dwPacketDuration = pCap->u.xAudio.oPacketization;
    
    lRet = AudioStreamCreate(&hAudio, AUDIO_STREAM_ENCODE, &uParam);

    MS_LOG("MediaStreamCreateAudInstance():: Audio Encode Stream %lx created\n"
           "Payload %d, Packetization %d\n", 
           (DWORD)hAudio, pCapCmn->oPayload, pCap->u.xAudio.oPacketization);

    if (pStream->oChannel) {
      AudioStreamAssocChannel(hAudio, pStream->oChannel);
    }

    lRet = AudioStreamUpdEncodeAttrib(hAudio, 
                                      AUDIO_ENC_ATTRIB_SILENCE_SUPPRESS,
                                      pCap->u.xAudio.bSilenceSuppression);

    /* Set RTP Tx instance capabilities */
    RTPInstanceSetRxTx(hRtp, E_RTP_TX);
    RTPInstanceSetRemoteNetworkInfo(hRtp, 
                                    pCapCmn->dwIPAddress,
                                    pCapCmn->wPort, 
                                    pCapCmn->wCtlPort);
    lRet=RTPInstanceStart(hRtp);
    ASSERT(lRet==PROTOCOL_SUCCESS);

    MS_LOG("MediaStreamCreateAudInstance():: RTP Tx instance %lx created\n"
           "IP Address %lx, RTP %d, RTCP %d\n",
           (DWORD)hRtp, pCapCmn->dwIPAddress, pCapCmn->wPort, pCapCmn->wCtlPort);

  } else if (eTxRx == PROTOCOL_TXRX_RX) {
    ASSERT(pStream->pRx == NULL);
    pStream->pRx = pInst;

    /* Create Audio Decoder Instance */
    uParam.xDecoder.eCodecType = _MapPayloadToCodec(pCapCmn);
    uParam.xDecoder.dwPacketDuration = pCap->u.xAudio.oPacketization;
    uParam.xDecoder.dwJitterBufferDuration = DEFAULT_AUDIO_RX_JITTER;

    lRet = AudioStreamCreate(&hAudio, AUDIO_STREAM_DECODE, &uParam);
    MS_LOG("MediaStreamCreateAudInstance():: Audio Decode Stream %lx created\n"
           "Payload %d, Packetization %d\n", 
           (DWORD)hAudio, pCapCmn->oPayload, pCap->u.xAudio.oPacketization);

    if (pStream->oChannel) {
      AudioStreamAssocChannel(hAudio, pStream->oChannel);
    }

     /* Set RTP Rx instance capabilities */
    RTPInstanceSetRxTx(hRtp, E_RTP_RX);

    if (pCapCmn->eTxRx == PROTOCOL_TXRX_TXRX) {
      RTPInstanceSetLocalNetworkInfo(hRtp, 0, 0, 0);
    } else {
      RTPInstanceSetLocalNetworkInfo(hRtp, pCapCmn->dwIPAddress, 
                                     pCapCmn->wPort, pCapCmn->wCtlPort);
    }

    lRet=RTPInstanceStart(hRtp);
    ASSERT(lRet==PROTOCOL_SUCCESS);
    /* Get RTP address/port */ 
    lRet = RTPInstanceGetLocalNetworkInfo(hRtp,
                                          &pInstCapCmn->dwIPAddress,
                                          &pInstCapCmn->wPort,
                                          &pInstCapCmn->wCtlPort);
    ASSERT(lRet==PROTOCOL_SUCCESS);
    MS_LOG("MediaStreamCreateAudInstance():: RTP Rx instance %lx created\n"
           "IP Address %lx, RTP %d, RTCP %d\n",
           (DWORD)hRtp, pInstCapCmn->dwIPAddress, pInstCapCmn->wPort, pInstCapCmn->wCtlPort);
  } else {
    ASSERT(0);
  }

  ASSERT(hAudio && hRtp);
  pInst->hAudStream = hAudio;
  pInst->hRtpInst = hRtp;

  if (pStream->pRx && pStream->pTx) {
    /* Associate RTP TX & RX instances together */
    CHECK_TAG(pStream->pRx, MS_TAG_AUD);
    CHECK_TAG(pStream->pTx, MS_TAG_AUD);
    lRet = RTPInstanceSetAssoc(((MS_AUDIO*)pStream->pRx)->hRtpInst, 
                               ((MS_AUDIO*)pStream->pTx)->hRtpInst);
    ASSERT(lRet==PROTOCOL_SUCCESS);
  }

  return lRet;
}


LONG
MediaStreamDestroyAudInstance(MS_AUDIO *pInst)
{
  MS_LOG("MediaStreamDestroyAudInstance() %lx\n", (DWORD)pInst);
  if (pInst) {
    ASSERT(pInst->hAudStream && pInst->hRtpInst);
    MS_LOG("MediaStreamDestroyAudInstance() Aud %lx, RTP %lx\n",
           (DWORD)pInst->hAudStream, (DWORD)pInst->hRtpInst);
    AudioStreamDestroy(pInst->hAudStream);
    RTPInstanceDestroy(pInst->hRtpInst);

    if (pInst->xCapCmn.pcEncodeName) {
      free(pInst->xCapCmn.pcEncodeName);
    }
    free(pInst);
  }

  return PROTOCOL_SUCCESS;
}