开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
interf_dec.c
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：15k
源码类别：

Symbian

开发平台：

Visual C++

interf_dec.c：源码内容
  1. /*
  2.  * ===================================================================
  3.  *  TS 26.104
  4.  *  R99   V3.4.0 2002-02
  5.  *  REL-4 V4.3.0 2002-02
  6.  *  3GPP AMR Floating-point Speech Codec
  7.  * ===================================================================
  8.  *
  9.  */
  11. /*
  12.  * interf_dec.c
  13.  *
  14.  *
  15.  * Project:
  16.  *     AMR Floating-Point Codec
  17.  *
  18.  * Contains:
  19.  *    This module provides means to conversion from 3GPP or ETSI
  20.  *    bitstream to AMR parameters
  21.  */
  23. /*
  24.  * include files
  25.  */
  26. #include "hlxclib/stdlib.h"
  27. #include "hlxclib/stdio.h"
  28. #include "hlxclib/memory.h"
  29. #include "typedef.h"
  30. #include "sp_dec.h"
  31. #include "interf_rom.h"
  32. #include "rom_dec.h"
  33. #include "interf_dec.h"
  35. /*
  36.  * definition of constants
  37.  */
  38. #define EHF_MASK 0x0008 /* encoder homing frame pattern */
  39. typedef
  41. struct
  42. {
  43.    int reset_flag_old;   /* previous was homing frame */
  46.    enum RXFrameType prev_ft;   /* previous frame type */
  47.    enum Mode prev_mode;   /* previous mode */
  48.    void *decoder_State;   /* Points decoder state */
  51. }dec_interface_State;
  53. #ifdef ETSI
  56. /*
  57.  * Bin2Int
  58.  *
  59.  *
  60.  * Parameters:
  61.  *    no_of_bits        I: number of bits associated with value
  62.  *    bits              O: address where bits are written
  63.  *
  64.  * Function:
  65.  *    Read nuber of bits from the array and convert to integer.
  66.  *
  67.  * Returns:
  68.  *    value
  69.  */
  70. static Word16 Bin2Int( Word16 no_of_bits, Word16 *bitstream )
  71. {
  72.    Word32 value, i, bit;
  75.    value = 0;
  77.    for ( i = 0; i < no_of_bits; i++ ) {
  78.       value = value << 1;
  79.       bit = *bitstream++;
  81.       if ( bit == 0x1 )
  82.          value = value + 1;
  83.    }
  84.    return( Word16 )( value );
  85. }
  88. /*
  89.  * Bits2Prm
  90.  *
  91.  *
  92.  * Parameters:
  93.  *    mode              I: AMR mode
  94.  *    bits              I: serial bits
  95.  *    param             O: AMR parameters
  96.  *
  97.  * Function:
  98.  *    Retrieves the vector of encoder parameters from
  99.  *    the received serial bits in a frame.
  100.  *
  101.  * Returns:
  102.  *    void
  103.  */
  104. static void Bits2Prm( enum Mode mode, Word16 bits[], Word16 prm[] )
  105. {
  106.    Word32 i;
  109.    switch ( mode ) {
  110.       case MR122:
  111.          for ( i = 0; i < PRMNO_MR122; i++ ) {
  112.             prm[i] = Bin2Int( bitno_MR122[i], bits );
  113.             bits += bitno_MR122[i];
  114.          }
  115.          break;
  117.       case MR102:
  118.          for ( i = 0; i < PRMNO_MR102; i++ ) {
  119.             prm[i] = Bin2Int( bitno_MR102[i], bits );
  120.             bits += bitno_MR102[i];
  121.          }
  122.          break;
  124.       case MR795:
  125.          for ( i = 0; i < PRMNO_MR795; i++ ) {
  126.             prm[i] = Bin2Int( bitno_MR795[i], bits );
  127.             bits += bitno_MR795[i];
  128.          }
  129.          break;
  131.       case MR74:
  132.          for ( i = 0; i < PRMNO_MR74; i++ ) {
  133.             prm[i] = Bin2Int( bitno_MR74[i], bits );
  134.             bits += bitno_MR74[i];
  135.          }
  136.          break;
  138.       case MR67:
  139.          for ( i = 0; i < PRMNO_MR67; i++ ) {
  140.             prm[i] = Bin2Int( bitno_MR67[i], bits );
  141.             bits += bitno_MR67[i];
  142.          }
  143.          break;
  145.       case MR59:
  146.          for ( i = 0; i < PRMNO_MR59; i++ ) {
  147.             prm[i] = Bin2Int( bitno_MR59[i], bits );
  148.             bits += bitno_MR59[i];
  149.          }
  150.          break;
  152.       case MR515:
  153.          for ( i = 0; i < PRMNO_MR515; i++ ) {
  154.             prm[i] = Bin2Int( bitno_MR515[i], bits );
  155.             bits += bitno_MR515[i];
  156.          }
  157.          break;
  159.       case MR475:
  160.          for ( i = 0; i < PRMNO_MR475; i++ ) {
  161.             prm[i] = Bin2Int( bitno_MR475[i], bits );
  162.             bits += bitno_MR475[i];
  163.          }
  164.          break;
  166.       case MRDTX:
  167.          for ( i = 0; i < PRMNO_MRDTX; i++ ) {
  168.             prm[i] = Bin2Int( bitno_MRDTX[i], bits );
  169.             bits += bitno_MRDTX[i];
  170.          }
  171.          break;
  172.    }
  173.    return;
  174. }
  176. #else
  179. /*
  180.  * Decoder3GPP
  181.  *
  182.  *
  183.  * Parameters:
  184.  *    param             O: AMR parameters
  185.  *    stream            I: input bitstream
  186.  *    frame_type        O: frame type
  187.  *    speech_mode       O: speech mode in DTX
  188.  *
  189.  * Function:
  190.  *    Resets state memory
  191.  *
  192.  * Returns:
  193.  *    mode              used mode
  194.  */
  195. enum Mode Decoder3GPP( Word16 *param, UWord8 *stream, enum RXFrameType
  196.                       *frame_type, enum Mode *speech_mode )
  197. {
  198.    enum Mode mode;
  199.    Word32 j;
  200.    Word16 *mask;
  203.    memset( param, 0, PRMNO_MR122 <<1 );
  204.    mode = (enum Mode) (0xF & *stream);
  205.    *stream >>= 4;
  207.    if ( mode == MRDTX ) {
  208.       mask = (Word16*) order_MRDTX;
  210.       for ( j = 5; j < 40; j++ ) {
  211.          if ( *stream & 0x1 )
  212.             param[ * mask] = ( short )( param[ * mask] + *( mask + 1 ) );
  213.          mask += 2;
  215.          if ( j % 8 )
  216.             *stream >>= 1;
  217.          else
  218.             stream++;
  219.       }
  221.       /* get SID type bit */
  223.       *frame_type = RX_SID_FIRST;
  224.       if (*stream)
  225.          *frame_type = RX_SID_UPDATE;
  227.       /* since there is update, use it */
  228.       /* *frame_type = RX_SID_UPDATE; */
  229.       stream++;
  231.       /* speech mode indicator */
  232.       *speech_mode = (enum Mode) *stream;
  233.    }
  234.    else if ( mode == 15 ) {
  235.       *frame_type = RX_NO_DATA;
  236.    }
  237.    else if ( mode == MR475 ) {
  238.       mask = (Word16*) order_MR475;
  240.       for ( j = 5; j < 100; j++ ) {
  241.          if ( *stream & 0x1 )
  242.             param[ * mask] = ( short )( param[ * mask] + *( mask + 1 ) );
  243.          mask += 2;
  245.          if ( j % 8 )
  246.             *stream >>= 1;
  247.          else
  248.             stream++;
  249.       }
  250.       *frame_type = RX_SPEECH_GOOD;
  251.    }
  252.    else if ( mode == MR515 ) {
  253.       mask = (Word16*) order_MR515;
  255.       for ( j = 5; j < 108; j++ ) {
  256.          if ( *stream & 0x1 )
  257.             param[ * mask] = ( short )( param[ * mask] + *( mask + 1 ) );
  258.          mask += 2;
  260.          if ( j % 8 )
  261.             *stream >>= 1;
  262.          else
  263.             stream++;
  264.       }
  265.       *frame_type = RX_SPEECH_GOOD;
  266.    }
  267.    else if ( mode == MR59 ) {
  268.       mask = (Word16*) order_MR59;
  270.       for ( j = 5; j < 123; j++ ) {
  271.          if ( *stream & 0x1 )
  272.             param[ * mask] = ( short )( param[ * mask] + *( mask + 1 ) );
  273.          mask += 2;
  275.          if ( j % 8 )
  276.             *stream >>= 1;
  277.          else
  278.             stream++;
  279.       }
  280.       *frame_type = RX_SPEECH_GOOD;
  281.    }
  282.    else if ( mode == MR67 ) {
  283.       mask = (Word16*) order_MR67;
  285.       for ( j = 5; j < 139; j++ ) {
  286.          if ( *stream & 0x1 )
  287.             param[ * mask] = ( short )( param[ * mask] + *( mask + 1 ) );
  288.          mask += 2;
  290.          if ( j % 8 )
  291.             *stream >>= 1;
  292.          else
  293.             stream++;
  294.       }
  295.       *frame_type = RX_SPEECH_GOOD;
  296.    }
  297.    else if ( mode == MR74 ) {
  298.       mask = (Word16*) order_MR74;
  300.       for ( j = 5; j < 153; j++ ) {
  301.          if ( *stream & 0x1 )
  302.             param[ * mask] = ( short )( param[ * mask] + *( mask + 1 ) );
  303.          mask += 2;
  305.          if ( j % 8 )
  306.             *stream >>= 1;
  307.          else
  308.             stream++;
  309.       }
  310.       *frame_type = RX_SPEECH_GOOD;
  311.    }
  312.    else if ( mode == MR795 ) {
  313.       mask = (Word16*) order_MR795;
  315.       for ( j = 5; j < 164; j++ ) {
  316.          if ( *stream & 0x1 )
  317.             param[ * mask] = ( short )( param[ * mask] + *( mask + 1 ) );
  318.          mask += 2;
  320.          if ( j % 8 )
  321.             *stream >>= 1;
  322.          else
  323.             stream++;
  324.       }
  325.       *frame_type = RX_SPEECH_GOOD;
  326.    }
  327.    else if ( mode == MR102 ) {
  328.       mask = (Word16*) order_MR102;
  330.       for ( j = 5; j < 209; j++ ) {
  331.          if ( *stream & 0x1 )
  332.             param[ * mask] = ( short )( param[ * mask] + *( mask + 1 ) );
  333.          mask += 2;
  335.          if ( j % 8 )
  336.             *stream >>= 1;
  337.          else
  338.             stream++;
  339.       }
  340.       *frame_type = RX_SPEECH_GOOD;
  341.    }
  342.    else if ( mode == MR122 ) {
  343.       mask = (Word16*) order_MR122;
  345.       for ( j = 5; j < 249; j++ ) {
  346.          if ( *stream & 0x1 )
  347.             param[ * mask] = ( short )( param[ * mask] + *( mask + 1 ) );
  348.          mask += 2;
  350.          if ( j % 8 )
  351.             *stream >>= 1;
  352.          else
  353.             stream++;
  354.       }
  355.       *frame_type = RX_SPEECH_GOOD;
  356.    }
  357.    else
  358.       *frame_type = RX_SPEECH_BAD;
  359.    return mode;
  360. }
  361. #endif
  364. /*
  365.  * Decoder_Interface_reset
  366.  *
  367.  *
  368.  * Parameters:
  369.  *    st                O: state struct
  370.  *
  371.  * Function:
  372.  *    Reset homing frame counter
  373.  *
  374.  * Returns:
  375.  *    void
  376.  */
  377. void Decoder_Interface_reset( dec_interface_State *st )
  378. {
  379.    st->reset_flag_old = 1;
  380.    st->prev_ft = RX_SPEECH_GOOD;
  381.    st->prev_mode = MR475;   /* minimum bitrate */
  382. }
  385. /*
  386.  * Decoder_Interface_init
  387.  *
  388.  *
  389.  * Parameters:
  390.  *    void
  391.  *
  392.  * Function:
  393.  *    Allocates state memory and initializes state memory
  394.  *
  395.  * Returns:
  396.  *    success           : pointer to structure
  397.  *    failure           : NULL
  398.  */
  399. void * Decoder_Interface_init( void )
  400. {
  401.    dec_interface_State * s;
  403.    /* allocate memory */
  404.    if ( ( s = ( dec_interface_State * ) malloc( sizeof( dec_interface_State ) ) ) ==
  405.          NULL ) {
  406.       fprintf( stderr, "Decoder_Interface_init: "
  407.             "can not malloc state structuren" );
  408.       return NULL;
  409.    }
  410.    s->decoder_State = Speech_Decode_Frame_init( );
  412.    if ( s->decoder_State == NULL ) {
  413.       free( s );
  414.       return NULL;
  415.    }
  416.    Decoder_Interface_reset( s );
  417.    return s;
  418. }
  421. /*
  422.  * Decoder_Interface_exit
  423.  *
  424.  *
  425.  * Parameters:
  426.  *    state                I: state structure
  427.  *
  428.  * Function:
  429.  *    The memory used for state memory is freed
  430.  *
  431.  * Returns:
  432.  *    Void
  433.  */
  434. void Decoder_Interface_exit( void *state )
  435. {
  436.    dec_interface_State * s;
  437.    s = ( dec_interface_State * )state;
  439.    /* free memory */
  440.    Speech_Decode_Frame_exit( (void**) s->decoder_State );
  441.    free( s );
  442.    s = NULL;
  443.    state = NULL;
  444. }
  447. /*
  448.  * Decoder_Interface_Decode
  449.  *
  450.  *
  451.  * Parameters:
  452.  *    st                B: state structure
  453.  *    bits              I: bit stream
  454.  *    synth             O: synthesized speech
  455.  *    bfi               I: bad frame indicator
  456.  *
  457.  * Function:
  458.  *    Decode bit stream to synthesized speech
  459.  *
  460.  * Returns:
  461.  *    Void
  462.  */
  463. void Decoder_Interface_Decode( void *st,
  465. #ifndef ETSI
  466.       UWord8 *bits,
  468. #else
  469.       Word16 *bits,
  470. #endif
  472.       Word16 *synth, int bfi)
  473. {
  474.    enum Mode mode;   /* AMR mode */
  476. #ifndef ETSI
  477.    enum Mode speech_mode = MR475;   /* speech mode */
  478. #endif
  480.    Word16 prm[PRMNO_MR122];   /* AMR parameters */
  482.    enum RXFrameType frame_type;   /* frame type */
  483.    dec_interface_State * s;   /* pointer to structure */
  485.    const Word16 *homing;   /* pointer to homing frame */
  486.    Word16 homingSize;   /* frame size for homing frame */
  487.    Word32 i;   /* counter */
  488.    Word32 resetFlag = 1;   /* homing frame */
  491.    s = ( dec_interface_State * )st;
  493. #ifndef ETSI
  495.    /*
  496.     * extract mode information and frametype,
  497.     * octets to parameters
  498.     */
  499.    mode = Decoder3GPP( prm, bits, &frame_type, &speech_mode );
  501.    /*
  502.     * if no mode information
  503.     * guess one from the previous frame
  504.     */
  505.    if ( frame_type == RX_SPEECH_BAD ) {
  506.       if ( s->prev_ft > 3 ) {
  507.          frame_type = RX_SID_BAD;
  508.          mode = MRDTX;
  509.       }
  510.       else {
  511.          mode = s->prev_mode;
  512.       }
  513.    }
  514.    else if ( frame_type == RX_NO_DATA ) {
  515.       mode = s->prev_mode;
  516.    }
  518.    if ( bfi == 1 ) {
  519.       if ( mode < 8 ) {
  520.          frame_type = RX_SPEECH_BAD;
  521.       }
  522.       else if ( mode != 15 ) {
  523.          frame_type = RX_SID_BAD;
  524.       }
  525.    }
  527. #else
  528.    bfi = 0;
  529.    frame_type = bits[0];
  531.    switch ( frame_type ) {
  532.       case 0:
  533.          frame_type = RX_SPEECH_GOOD;
  534.          mode = bits[245];
  535.          Bits2Prm( mode, &bits[1], prm );
  536.          break;
  538.       case 1:
  539.          frame_type = RX_SID_FIRST;
  540.          mode = s->prev_mode;
  541.          break;
  543.       case 2:
  544.          frame_type = RX_SID_UPDATE;
  545.          mode = s->prev_mode;
  546.          Bits2Prm( MRDTX, &bits[1], prm );
  547.          break;
  549.       case 3:
  550.          frame_type = RX_NO_DATA;
  551.          mode = s->prev_mode;
  552.          break;
  553.    }
  555. #endif
  557.    /* test for homing frame */
  558.    if ( s->reset_flag_old == 1 ) {
  559.       switch ( mode ) {
  560.          case MR122:
  561.             homing = dhf_MR122;
  562.             homingSize = 18;
  563.             break;
  565.          case MR102:
  566.             homing = dhf_MR102;
  567.             homingSize = 12;
  568.             break;
  570.          case MR795:
  571.             homing = dhf_MR795;
  572.             homingSize = 8;
  573.             break;
  575.          case MR74:
  576.             homing = dhf_MR74;
  577.             homingSize = 7;
  578.             break;
  580.          case MR67:
  581.             homing = dhf_MR67;
  582.             homingSize = 7;
  583.             break;
  585.          case MR59:
  586.             homing = dhf_MR59;
  587.             homingSize = 7;
  588.             break;
  590.          case MR515:
  591.             homing = dhf_MR515;
  592.             homingSize = 7;
  593.             break;
  595.          case MR475:
  596.             homing = dhf_MR475;
  597.             homingSize = 7;
  598.             break;
  600.          default:
  601.             homing = NULL;
  602.             homingSize = 0;
  603.             break;
  604.       }
  606.       for ( i = 0; i < homingSize; i++ ) {
  607.          resetFlag = prm[i] ^ homing[i];
  609.          if ( resetFlag )
  610.             break;
  611.       }
  612.    }
  614.    if ( ( resetFlag == 0 ) && ( s->reset_flag_old != 0 ) ) {
  615.       for ( i = 0; i < 160; i++ ) {
  616.          synth[i] = EHF_MASK;
  617.       }
  618.    }
  619.    else
  620.       Speech_Decode_Frame( s->decoder_State, mode, prm, frame_type, synth );
  622.    if ( s->reset_flag_old == 0 ) {
  623.       /* check whole frame */
  624.       switch ( mode ) {
  625.          case MR122:
  626.             homing = dhf_MR122;
  627.             homingSize = PRMNO_MR122;
  628.             break;
  630.          case MR102:
  631.             homing = dhf_MR102;
  632.             homingSize = PRMNO_MR102;
  633.             break;
  635.          case MR795:
  636.             homing = dhf_MR795;
  637.             homingSize = PRMNO_MR795;
  638.             break;
  640.          case MR74:
  641.             homing = dhf_MR74;
  642.             homingSize = PRMNO_MR74;
  643.             break;
  645.          case MR67:
  646.             homing = dhf_MR67;
  647.             homingSize = PRMNO_MR67;
  648.             break;
  650.          case MR59:
  651.             homing = dhf_MR59;
  652.             homingSize = PRMNO_MR59;
  653.             break;
  655.          case MR515:
  656.             homing = dhf_MR515;
  657.             homingSize = PRMNO_MR515;
  658.             break;
  660.          case MR475:
  661.             homing = dhf_MR475;
  662.             homingSize = PRMNO_MR475;
  663.             break;
  665.          default:
  666.             homing = NULL;
  667.             homingSize = 0;
  668.       }
  670.       for ( i = 0; i < homingSize; i++ ) {
  671.          resetFlag = prm[i] ^ homing[i];
  673.          if ( resetFlag )
  674.             break;
  675.       }
  676.    }
  678.    /* reset decoder if current frame is a homing frame */
  679.    if ( resetFlag == 0 ) {
  680.       Speech_Decode_Frame_reset( (void**) s->decoder_State );
  681.    }
  682.    s->reset_flag_old = !resetFlag;
  683.    s->prev_ft = frame_type;
  684.    s->prev_mode = mode;
  685. }