uscamrwb.c

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*/////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2005 Intel Corporation. All Rights Reserved.
//
//     Intel(R) Integrated Performance Primitives
//     USC - Unified Speech Codec interface library
//
// By downloading and installing USC codec, you hereby agree that the
// accompanying Materials are being provided to you under the terms and
// conditions of the End User License Agreement for the Intel(R) Integrated
// Performance Primitives product previously accepted by you. Please refer
// to the file ipplic.htm located in the root directory of your Intel(R) IPP
// product installation for more information.
//
// A speech coding standards promoted by ITU, ETSI, 3GPP and other
// organizations. Implementations of these standards, or the standard enabled
// platforms may require licenses from various entities, including
// Intel Corporation.
//
//
// Purpose: AMRWB speech codec: USC functions.
//
*/

#include "ownamrwb.h"
#include "amrwbapi.h"
#include <string.h>
#include "amrwbusc.h"

#define  AMRWB_NUM_RATES  9
#define  AMRWB_BITS_PER_SAMPLE 16

static USC_Status GetInfo(USC_Handle handle, USC_CodecInfo *pInfo);
static USC_Status NumAlloc(const USC_Option *options, int *nbanks);
static USC_Status MemAlloc(const USC_Option *options, USC_MemBank *pBanks);
static USC_Status Init(const USC_Option *options, const USC_MemBank *pBanks, USC_Handle *handle);
static USC_Status Reinit(const USC_Modes *modes, USC_Handle handle );
static USC_Status Control(const USC_Modes *modes, USC_Handle handle );
static USC_Status Encode(USC_Handle handle, USC_PCMStream *in, USC_Bitstream *out);
static USC_Status Decode(USC_Handle handle, USC_Bitstream *in, USC_PCMStream *out);
static USC_Status GetOutStreamSize(const USC_Option *options, int bitrate, int nbytesSrc, int *nbytesDst);
static USC_Status SetFrameSize(const USC_Option *options, USC_Handle handle, int frameSize);

typedef struct
{
    short updateSidCount;
    TXFrameType prevFrameType;
} SIDSyncState;

typedef struct {
    int direction;
    int trunc;
    int bitrate;
    int vad;
    int reset_flag;
    int reset_flag_old;
    int bitrate_old;
    int usedRate;
    SIDSyncState sid_state;
    int reserved0; // for future extension
    int reserved1; // for future extension
} AMRWB_Handle_Header;

static int  ownSidSyncInit(SIDSyncState *st);
static void ownSidSync(SIDSyncState *st, int valRate, TXFrameType *pTXFrameType);
static int  ownTestPCMFrameHoming(const short *pSrc);
static int  ownTestBitstreamFrameHoming(short* pPrmsvec, int valRate);

/* global usc vector table */
USCFUN USC_Fxns USC_AMRWB_Fxns={
    {
        USC_Codec,
        GetInfo,
        NumAlloc,
        MemAlloc,
        Init,
        Reinit,
        Control
    },
    Encode,
    Decode,
    GetOutStreamSize,
    SetFrameSize
};

static USC_Option  params;  /* what is supported  */
static USC_PCMType pcmType; /* codec audio source */

static __ALIGN32 CONST int BitsLenTbl[NUM_OF_MODES]={
   132, 177, 253, 285, 317, 365, 397, 461, 477, 35
};

static __ALIGN32 CONST short LostFrame[AMRWB_Frame]=
{
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

static __ALIGN32 CONST USC_Rates pTblRates_AMRWB[AMRWB_NUM_RATES]={
    {23850},
    {23050},
    {19850},
    {18250},
    {15850},
    {14250},
    {12650},
    {8850},
    {6600}
};

static void ownConvert15(int valRate, const char *pSerialvec, short* pPrmvec)
{
    short i, j, tmp;
    int valNumPrms = BitsLenTbl[valRate];
    int nbit=0;

    j = 0;
    i = 0;

    tmp = valNumPrms - 15;
    while (tmp > j)
    {
        pPrmvec[i] = amrExtractBits(&pSerialvec,&nbit,15);
        j += 15;
        i++;
    }
    tmp = valNumPrms - j;
    pPrmvec[i] = amrExtractBits(&pSerialvec,&nbit,tmp);
    pPrmvec[i] <<= (15 - tmp);

    return;
}


static USC_Status GetInfo(USC_Handle handle, USC_CodecInfo *pInfo)
{
    AMRWB_Handle_Header *amrwb_header;

    pInfo->name = "AMRWB";
    pInfo->framesize = AMRWB_Frame*sizeof(short);
    if (handle == NULL) {
        pInfo->params.modes.bitrate = 6600;
        pInfo->params.modes.truncate = 1;
        pInfo->params.direction = 0;
        pInfo->params.modes.vad = 1;
    } else {
      amrwb_header = (AMRWB_Handle_Header*)handle;
      pInfo->params.modes.bitrate = amrwb_header->bitrate;
      pInfo->params.modes.truncate = amrwb_header->trunc;
      pInfo->params.direction = amrwb_header->direction;
      pInfo->params.modes.vad = amrwb_header->vad;
    }
    pInfo->maxbitsize = BITSTREAM_SIZE;
    pInfo->pcmType.sample_frequency = 16000;
    pInfo->pcmType.bitPerSample = AMRWB_BITS_PER_SAMPLE;
    pInfo->params.modes.hpf = 0;
    pInfo->params.modes.pf = 0;
    pInfo->params.law = 0;
    pInfo->nRates = AMRWB_NUM_RATES;
    pInfo->pRateTbl = (const USC_Rates *)&pTblRates_AMRWB;

    return USC_NoError;
}

static int CheckRate_AMRWB(int rate_bps)
{
    int rate;

    switch(rate_bps) {
      case 6600:  rate = 0; break;
      case 8850:  rate = 1; break;
      case 12650: rate = 2; break;
      case 14250: rate = 3; break;
      case 15850: rate = 4; break;
      case 18250: rate = 5; break;
      case 19850: rate = 6; break;
      case 23050: rate = 7; break;
      case 23850: rate = 8; break;
      default: rate = -1; break;
    }
    return rate;
}

static int CheckIdxRate_AMRWB(int idx_rate)
{
    int rate;

    switch(idx_rate) {
      case 0: rate = 6600; break;
      case 1: rate = 8850; break;
      case 2: rate = 12650; break;
      case 3: rate = 14250; break;
      case 4: rate = 15850; break;
      case 5: rate = 18250; break;
      case 6: rate = 19850; break;
      case 7: rate = 23050; break;
      case 8: rate = 23850; break;
      default: rate = -1; break;
    }
    return rate;
}


static USC_Status NumAlloc(const USC_Option *options, int *nbanks)
{
   if(options==NULL) return USC_BadDataPointer;
   if(nbanks==NULL) return USC_BadDataPointer;

   *nbanks = 1;
   return USC_NoError;
}

static USC_Status MemAlloc(const USC_Option *options, USC_MemBank *pBanks)
{
    unsigned int nbytes;

   if(options==NULL) return USC_BadDataPointer;
   if(pBanks==NULL) return USC_BadDataPointer;
   if(options->modes.vad > 1) return USC_UnsupportedVADType;

    pBanks->pMem = NULL;
    if (options->direction == 0) /* encode only */
    {
        AMRWBEnc_Params enc_params;
        enc_params.codecType = (AMRWBCodec_Type)0;
        enc_params.mode = options->modes.vad;
        apiAMRWBEncoder_Alloc(&enc_params, &nbytes);
    }
    else if (options->direction == 1) /* decode only */
    {
        AMRWBDec_Params dec_params;
        dec_params.codecType = (AMRWBCodec_Type)0;
        dec_params.mode = options->modes.vad;
        apiAMRWBDecoder_Alloc(&dec_params, &nbytes);
    } else {
        return USC_NoOperation;
    }
    pBanks->nbytes = nbytes + sizeof(AMRWB_Handle_Header); /* include header in handle */
    return USC_NoError;
}

static USC_Status Init(const USC_Option *options, const USC_MemBank *pBanks, USC_Handle *handle)
{
    AMRWB_Handle_Header *amrwb_header;
    int bitrate_idx;

   if(options==NULL) return USC_BadDataPointer;
   if(pBanks==NULL) return USC_BadDataPointer;
   if(pBanks->pMem==NULL) return USC_NotInitialized;
   if(pBanks->nbytes<=0) return USC_NotInitialized;
   if(handle==NULL) return USC_InvalidHandler;

    *handle = (USC_Handle*)pBanks->pMem;
    amrwb_header = (AMRWB_Handle_Header*)*handle;

    bitrate_idx = CheckRate_AMRWB(options->modes.bitrate);
     if(bitrate_idx < 0) return USC_UnsupportedBitRate;
    amrwb_header->direction = options->direction;
    amrwb_header->trunc = options->modes.truncate;
    amrwb_header->vad = options->modes.vad;
     amrwb_header->bitrate = options->modes.bitrate;
     amrwb_header->bitrate_old = 0;

    if (options->direction == 0) /* encode only */
    {
        AMRWBEncoder_Obj *EncObj = (AMRWBEncoder_Obj *)((char*)*handle + sizeof(AMRWB_Handle_Header));
        apiAMRWBEncoder_Init((AMRWBEncoder_Obj*)EncObj, amrwb_header->vad);
    }
    else if (options->direction == 1) /* decode only */
    {
        AMRWBDecoder_Obj *DecObj = (AMRWBDecoder_Obj *)((char*)*handle + sizeof(AMRWB_Handle_Header));
        apiAMRWBDecoder_Init((AMRWBDecoder_Obj*)DecObj);
          amrwb_header->usedRate = 6600;
        amrwb_header->reset_flag = 0;
        amrwb_header->reset_flag_old = 1;

    } else {
        return USC_NoOperation;
    }
    return USC_NoError;
}

static USC_Status Reinit(const USC_Modes *modes, USC_Handle handle )
{
    AMRWB_Handle_Header *amrwb_header;
    int bitrate_idx;

   if(modes==NULL) return USC_BadDataPointer;
   if(handle==NULL) return USC_InvalidHandler;

    amrwb_header = (AMRWB_Handle_Header*)handle;

    bitrate_idx = CheckRate_AMRWB(modes->bitrate);
    if(bitrate_idx < 0) return USC_UnsupportedBitRate;
    amrwb_header->vad = modes->vad;
    amrwb_header->bitrate = modes->bitrate;
    amrwb_header->bitrate_old = 0;

    if (amrwb_header->direction == 0) /* encode only */
    {
        AMRWBEncoder_Obj *EncObj = (AMRWBEncoder_Obj *)((char*)handle + sizeof(AMRWB_Handle_Header));
        amrwb_header->reset_flag = 0;
        ownSidSyncInit(&amrwb_header->sid_state);
        apiAMRWBEncoder_Init((AMRWBEncoder_Obj*)EncObj, modes->vad);
    }
    else if (amrwb_header->direction == 1) /* decode only */
    {
        AMRWBDecoder_Obj *DecObj = (AMRWBDecoder_Obj *)((char*)handle + sizeof(AMRWB_Handle_Header));
        apiAMRWBDecoder_Init((AMRWBDecoder_Obj*)DecObj);
          amrwb_header->usedRate = 6600;
        amrwb_header->reset_flag = 0;
        amrwb_header->reset_flag_old = 1;
    } else {
        return USC_NoOperation;
    }
    return USC_NoError;
}

static USC_Status Control(const USC_Modes *modes, USC_Handle handle )
{
   AMRWB_Handle_Header *amrwb_header;

   if(modes==NULL) return USC_BadDataPointer;
   if(handle==NULL) return USC_InvalidHandler;

   amrwb_header = (AMRWB_Handle_Header*)handle;

   amrwb_header->trunc = modes->truncate;
   amrwb_header->vad = modes->vad;
   amrwb_header->bitrate = modes->bitrate;

   if (amrwb_header->direction == 0) { /* encode only */
      AMRWBEncoder_Obj *EncObj;
      EncObj = (AMRWBEncoder_Obj *)((char*)handle + sizeof(AMRWB_Handle_Header));
      apiAMRWBEncoder_Mode(EncObj, amrwb_header->vad);
   }

   return USC_NoError;
}

static __ALIGN32 CONST AMRWB_Rate_t usc2amrwb[9]={
    AMRWB_RATE_6600,
    AMRWB_RATE_8850,
    AMRWB_RATE_12650,
    AMRWB_RATE_14250,
    AMRWB_RATE_15850,
    AMRWB_RATE_18250,
    AMRWB_RATE_19850,
    AMRWB_RATE_23050,
    AMRWB_RATE_23850
};

static int getBitstreamSize(int rate, int frametype, int *outRate)
{
    int nbytes;
    int usedRate = rate;

    if (frametype != TX_SPEECH) {
        usedRate = AMRWB_RATE_DTX;
    }

    nbytes = ((BitsLenTbl[usedRate] + 14) / 15) * sizeof(short);
    *outRate = rate;

    return nbytes;

}

static USC_Status Encode(USC_Handle handle, USC_PCMStream *in, USC_Bitstream *out)
{
    AMRWB_Handle_Header *amrwb_header;
    int bitrate_idx;
    AMRWBEncoder_Obj *EncObj;
    unsigned short work_buf[AMRWB_Frame];
    int WrkRate, out_WrkRate;

    if(in==NULL) return USC_BadDataPointer;
    if(in->nbytes<AMRWB_Frame*sizeof(short)) return USC_NoOperation;

    amrwb_header = (AMRWB_Handle_Header*)handle;

    if(amrwb_header == NULL) return USC_InvalidHandler;
     bitrate_idx = CheckRate_AMRWB(in->bitrate);
     if(bitrate_idx < 0) return USC_UnsupportedBitRate;
     amrwb_header->bitrate = in->bitrate;

    EncObj = (AMRWBEncoder_Obj *)((char*)handle + sizeof(AMRWB_Handle_Header));

    /* check for homing frame */
    amrwb_header->reset_flag = ownTestPCMFrameHoming((short*)in->pBuffer);