dec_if.c
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:13k
源码类别:

Symbian

开发平台:

Visual C++

  1. /*
  2.  *===================================================================
  3.  *  3GPP AMR Wideband Floating-point Speech Codec
  4.  *===================================================================
  5.  */
  6. #include "hlxclib/stdlib.h"
  7. #include "hlxclib/memory.h"
  8. #include "typedef.h"
  9. #include "dec_if.h"
  10. #include "if_rom.h"
  11. #include "dec.h"
  12. #define L_FRAME16k   320            /* Frame size at 16kHz  */
  13. #define MODE_7k       0             /* modes                */
  14. #define MODE_9k       1
  15. #define MODE_12k      2
  16. #define MODE_14k      3
  17. #define MODE_16k      4
  18. #define MODE_18k      5
  19. #define MODE_20k      6
  20. #define MODE_23k      7
  21. #define MODE_24k      8
  22. #define MRDTX        10
  23. #define NUM_OF_MODES 11
  24. #define LOST_FRAME   14
  25. #define MRNO_DATA    15
  26. #define EHF_MASK     (Word16)0x0008 /* homing frame pattern */
  27. typedef struct
  28. {
  29.    Word16 reset_flag_old;     /* previous was homing frame  */
  30.    Word16 prev_ft;            /* previous frame type        */
  31.    Word16 prev_mode;          /* previous mode              */
  32.    void *decoder_state;       /* Points decoder state       */
  33. } WB_dec_if_state;
  34. const Word16 nb_of_param_first[NUM_OF_SPMODES]=
  35. {
  36. 9,  14, 15,
  37. 15, 15, 19,
  38. 19, 19, 19
  39. };
  40. extern const Word16 mode_7k[];
  41. extern const Word16 mode_9k[];
  42. extern const Word16 mode_12k[];
  43. extern const Word16 mode_14k[];
  44. extern const Word16 mode_16k[];
  45. extern const Word16 mode_18k[];
  46. extern const Word16 mode_20k[];
  47. extern const Word16 mode_23k[];
  48. extern const Word16 mode_24k[];
  49. extern const Word16 mode_DTX[];
  50. extern const Word16 nb_of_param[];
  51. extern const Word16 dfh_M7k[];
  52. extern const Word16 dfh_M9k[];
  53. extern const Word16 dfh_M12k[];
  54. extern const Word16 dfh_M14k[];
  55. extern const Word16 dfh_M16k[];
  56. extern const Word16 dfh_M18k[];
  57. extern const Word16 dfh_M20k[];
  58. extern const Word16 dfh_M23k[];
  59. extern const Word16 dfh_M24k[];
  60. /* overall table with the parameters of the
  61.    decoder homing frames for all modes */
  62. extern const Word16* const dhf[10];
  63. /*
  64.  * Decoder_Interface_Homing_Frame_test
  65.  *
  66.  * Parameters:
  67.  *    input_frame    I: input parameters
  68.  *    mode           I: speech mode
  69.  *
  70.  * Function:
  71.  *    Check parameters for matching homing frame
  72.  *
  73.  * Returns:
  74.  *    If homing frame
  75.  */
  76. Word16 D_IF_homing_frame_test(Word16 input_frame[], Word16 mode)
  77. {
  78.    if (mode != MODE_24k)
  79.    {
  80.       /* perform test for COMPLETE parameter frame */
  81.       return (Word16)!memcmp(input_frame, dhf[mode], nb_of_param[mode] * sizeof(Word16));
  82.    }
  83.    else
  84.    {
  85.       /* discard high-band energy */
  86.       return (Word16)!(
  87.          (memcmp(input_frame, dhf[MODE_24k], 19 * sizeof(Word16))) |
  88.          (memcmp(input_frame + 20, dhf[MODE_24k] + 20, 11 * sizeof(Word16))) |
  89.          (memcmp(input_frame + 32, dhf[MODE_24k] + 32, 11 * sizeof(Word16))) |
  90.          (memcmp(input_frame + 44, dhf[MODE_24k] + 44, 11 * sizeof(Word16))) );
  91.    }
  92. }
  93. Word16 D_IF_homing_frame_test_first(Word16 input_frame[], Word16 mode)
  94. {
  95.    /* perform test for FIRST SUBFRAME of parameter frame ONLY */
  96.    return (Word16)!memcmp(input_frame, dhf[mode], nb_of_param_first[mode] * sizeof(Word16));
  97. }
  98. /*
  99.  * D_IF_conversion
  100.  *
  101.  *
  102.  * Parameters:
  103.  *    param             O: AMR parameters
  104.  *    stream            I: input bitstream
  105.  *    frame_type        O: frame type
  106.  *    speech_mode       O: speech mode in DTX
  107.  *    fqi               O: frame quality indicator
  108.  *
  109.  * Function:
  110.  *    Unpacks IF2 octet stream
  111.  *
  112.  * Returns:
  113.  *    mode              used mode
  114.  */
  115. Word16 D_IF_conversion(Word16 *param, UWord8 *stream, UWord8 *frame_type,
  116.                        Word16 *speech_mode, Word16 *fqi)
  117. {
  118.    Word32 mode;
  119.    Word32 j;
  120.    Word16 const *mask;
  121.    memset(param, 0, PRMNO_24k << 1);
  122.    mode = *stream >> 4;
  123.    /* SID indication IF2 corresponds to mode 10 */
  124.    if (mode == 9)
  125.    {
  126.       mode ++;
  127.    }
  128.    *fqi = (Word16)((*stream >> 3) & 0x1);
  129.    *stream <<= (HEADER_SIZE - 1);
  130.    switch (mode)
  131.    {
  132.    case MRDTX:
  133.       mask = mode_DTX;
  134.       for (j = HEADER_SIZE; j < T_NBBITS_SID; j++)
  135.       {
  136.          if (*stream & 0x80)
  137.          {
  138.             param[*mask] = (Word16)(param[*mask] + *(mask + 1));
  139.          }
  140.          mask += 2;
  141.          if ( j % 8 )
  142.          {
  143.             *stream <<= 1;
  144.          }
  145.          else
  146.          {
  147.             stream++;
  148.          }
  149.       }
  150.       /* get SID type bit */
  151.       *frame_type = RX_SID_FIRST;
  152.       if (*stream & 0x80)
  153.       {
  154.          *frame_type = RX_SID_UPDATE;
  155.       }
  156.       *stream <<= 1;
  157.       /* speech mode indicator */
  158.       *speech_mode = (Word16)(*stream >> 4);
  159.       break;
  160.    case MRNO_DATA:
  161.       *frame_type = RX_NO_DATA;
  162.       break;
  163.    case LOST_FRAME:
  164.       *frame_type = RX_SPEECH_LOST;
  165.       break;
  166.    case MODE_7k:
  167.       mask = mode_7k;
  168.       for (j = HEADER_SIZE; j < T_NBBITS_7k; j++)
  169.       {
  170.          if ( *stream & 0x80 )
  171.          {
  172.             param[*mask] = (Word16)(param[*mask] + *(mask + 1));
  173.          }
  174.          mask += 2;
  175.          if (j % 8)
  176.          {
  177.             *stream <<= 1;
  178.          }
  179.          else
  180.          {
  181.             stream++;
  182.          }
  183.       }
  184.       *frame_type = RX_SPEECH_GOOD;
  185.       break;
  186.    case MODE_9k:
  187.       mask = mode_9k;
  188.       for (j = HEADER_SIZE; j < T_NBBITS_9k; j++)
  189.       {
  190.          if (*stream & 0x80)
  191.          {
  192.             param[*mask] = (Word16)(param[*mask] + *(mask + 1));
  193.          }
  194.          mask += 2;
  195.          if (j % 8)
  196.          {
  197.             *stream <<= 1;
  198.          }
  199.          else
  200.          {
  201.             stream++;
  202.          }
  203.       }
  204.       *frame_type = RX_SPEECH_GOOD;
  205.       break;
  206.    case MODE_12k:
  207.       mask = mode_12k;
  208.       for (j = HEADER_SIZE; j < T_NBBITS_12k; j++)
  209.       {
  210.          if (*stream & 0x80)
  211.          {
  212.             param[*mask] = (Word16)(param[*mask] + *(mask + 1));
  213.          }
  214.          mask += 2;
  215.          if ( j % 8 )
  216.          {
  217.             *stream <<= 1;
  218.          }
  219.          else
  220.          {
  221.             stream++;
  222.          }
  223.       }
  224.       *frame_type = RX_SPEECH_GOOD;
  225.       break;
  226.    case MODE_14k:
  227.       mask = mode_14k;
  228.       for (j = HEADER_SIZE; j < T_NBBITS_14k; j++)
  229.       {
  230.          if (*stream & 0x80)
  231.          {
  232.             param[*mask] = (Word16)(param[*mask] + *(mask + 1));
  233.          }
  234.          mask += 2;
  235.          if ( j % 8 )
  236.          {
  237.             *stream <<= 1;
  238.          }
  239.          else
  240.          {
  241.             stream++;
  242.          }
  243.       }
  244.       *frame_type = RX_SPEECH_GOOD;
  245.       break;
  246.    case MODE_16k:
  247.       mask = mode_16k;
  248.       for (j = HEADER_SIZE; j < T_NBBITS_16k; j++)
  249.       {
  250.          if (*stream & 0x80)
  251.          {
  252.             param[*mask] = (Word16)(param[*mask] + *(mask + 1));
  253.          }
  254.          mask += 2;
  255.          if (j % 8)
  256.          {
  257.             *stream <<= 1;
  258.          }
  259.          else
  260.          {
  261.             stream++;
  262.          }
  263.       }
  264.       *frame_type = RX_SPEECH_GOOD;
  265.       break;
  266.    case MODE_18k:
  267.       mask = mode_18k;
  268.       for (j = HEADER_SIZE; j < T_NBBITS_18k; j++)
  269.       {
  270.          if (*stream & 0x80)
  271.          {
  272.             param[*mask] = (Word16)(param[*mask] + *(mask + 1));
  273.          }
  274.          mask += 2;
  275.          if (j % 8)
  276.          {
  277.             *stream <<= 1;
  278.          }
  279.          else
  280.          {
  281.             stream++;
  282.          }
  283.       }
  284.       *frame_type = RX_SPEECH_GOOD;
  285.       break;
  286.    case MODE_20k:
  287.       mask = mode_20k;
  288.       for (j = HEADER_SIZE; j < T_NBBITS_20k; j++)
  289.       {
  290.          if (*stream & 0x80)
  291.          {
  292.             param[*mask] = (Word16)(param[*mask] + *(mask + 1));
  293.          }
  294.          mask += 2;
  295.          if (j % 8)
  296.          {
  297.             *stream <<= 1;
  298.          }
  299.          else
  300.          {
  301.             stream++;
  302.          }
  303.       }
  304.       *frame_type = RX_SPEECH_GOOD;
  305.       break;
  306.    case MODE_23k:
  307.       mask = mode_23k;
  308.       for (j = HEADER_SIZE; j < T_NBBITS_23k; j++)
  309.       {
  310.          if (*stream & 0x80)
  311.          {
  312.             param[*mask] = (Word16)(param[*mask] + *(mask + 1));
  313.          }
  314.          mask += 2;
  315.          if (j % 8)
  316.          {
  317.             *stream <<= 1;
  318.          }
  319.          else
  320.          {
  321.             stream++;
  322.          }
  323.       }
  324.       *frame_type = RX_SPEECH_GOOD;
  325.       break;
  326.    case MODE_24k:
  327.       mask = mode_24k;
  328.       for (j = HEADER_SIZE; j < T_NBBITS_24k; j++)
  329.       {
  330.          if (*stream & 0x80)
  331.          {
  332.             param[*mask] = (Word16)(param[*mask] + *(mask + 1));
  333.          }
  334.          mask += 2;
  335.          if (j % 8)
  336.          {
  337.             *stream <<= 1;
  338.          }
  339.          else
  340.          {
  341.             stream++;
  342.          }
  343.       }
  344.       *frame_type = RX_SPEECH_GOOD;
  345.       break;
  346.    default:
  347.       *frame_type = RX_SPEECH_LOST;
  348.       *fqi = 0;
  349.       break;
  350.    }
  351.    if (*fqi == 0)
  352.    {
  353.       if (*frame_type == RX_SPEECH_GOOD)
  354.       {
  355.          *frame_type = RX_SPEECH_BAD;
  356.       }
  357.       if ((*frame_type == RX_SID_FIRST) | (*frame_type == RX_SID_UPDATE))
  358.       {
  359.          *frame_type = RX_SID_BAD;
  360.       }
  361.    }
  362.    return (Word16)mode;
  363. }
  364. /*
  365.  * D_IF_decode
  366.  *
  367.  *
  368.  * Parameters:
  369.  *    st       B: pointer to state structure
  370.  *    bits     I: bitstream form the encoder
  371.  *    synth    O: decoder output
  372.  *    lfi      I: lost frame indicator
  373.  *                _good_frame, _bad_frame, _lost_frame, _no_frame
  374.  *
  375.  * Function:
  376.  *    Decoding one frame of speech. Lost frame indicator can be used
  377.  *    to inform encoder about the problems in the received frame.
  378.  *    _good_frame:good speech or sid frame is received.
  379.  *    _bad_frame: frame with possible bit errors
  380.  *    _lost_frame:speech of sid frame is lost in transmission
  381.  *    _no_frame:  indicates non-received frames in dtx-operation
  382.  * Returns:
  383.  *
  384.  */
  385. void D_IF_decode( void *st, UWord8 *bits, Word16 *synth, Word32 lfi)
  386. {
  387.    Word32 i;
  388.    Word16 mode = 0;                 /* AMR mode                */
  389.    Word16 speech_mode = MODE_7k;    /* speech mode             */
  390.    Word16 fqi;                      /* frame quality indicator */
  391.    Word16 prm[PRMNO_24k];           /* AMR parameters          */
  392.    UWord8 frame_type;               /* frame type              */
  393.    Word16 reset_flag = 0;           /* reset flag              */
  394.    WB_dec_if_state * s;             /* pointer to structure    */
  395.    s = (WB_dec_if_state*)st;
  396.    /* bits -> param, if needed */
  397.    if ((lfi == _good_frame) | (lfi == _bad_frame))
  398.    {
  399.       /* add fqi data */
  400.       *bits = (UWord8)((Word32)*bits & ~(lfi << 3));
  401.       /*
  402.        * extract mode information and frame_type,
  403.        * octets to parameters
  404.        */
  405.       mode = D_IF_conversion( prm, bits, &frame_type, &speech_mode, &fqi);
  406.    }
  407.    else if (lfi == _no_frame)
  408.    {
  409.       frame_type = RX_NO_DATA;
  410.    }
  411.    else
  412.    {
  413.       frame_type = RX_SPEECH_LOST;
  414.    }
  415.    /*
  416.     * if no mode information
  417.     * guess one from the previous frame
  418.     */
  419.    if ((frame_type == RX_SPEECH_LOST) | (frame_type == RX_NO_DATA))
  420.    {
  421.       mode = s->prev_mode;
  422.    }
  423.    if (mode == MRDTX)
  424.    {
  425.       mode = speech_mode;
  426.    }
  427.    /* if homed: check if this frame is another homing frame */
  428.    if (s->reset_flag_old == 1)
  429.    {
  430.       /* only check until end of first subframe */
  431.       reset_flag = D_IF_homing_frame_test_first(prm, mode);
  432.    }
  433.    /* produce encoder homing frame if homed & input=decoder homing frame */
  434.    if ((reset_flag != 0) && (s->reset_flag_old != 0))
  435.    {
  436.       for (i = 0; i < L_FRAME16k; i++)
  437.       {
  438.          synth[i] = EHF_MASK;
  439.       }
  440.    }
  441.    else
  442.    {
  443.       D_MAIN_decode(mode, prm, synth, s->decoder_state, frame_type);
  444.    }
  445.    for (i = 0; i < L_FRAME16k; i++)   /* Delete the 2 LSBs (14-bit input) */
  446.    {
  447.       synth[i] = (Word16) (synth[i] & 0xfffC);
  448.    }
  449.    /* if not homed: check whether current frame is a homing frame */
  450.    if ((s->reset_flag_old == 0) & (mode < 9))
  451.    {
  452.       /* check whole frame */
  453.       reset_flag = D_IF_homing_frame_test(prm, mode);
  454.    }
  455.    /* reset decoder if current frame is a homing frame */
  456.    if (reset_flag != 0)
  457.    {
  458.       D_MAIN_reset(s->decoder_state, 1);
  459.    }
  460.    s->reset_flag_old = reset_flag;
  461.    s->prev_ft = frame_type;
  462.    s->prev_mode = mode;
  463. }
  464. /*
  465.  * D_IF_reset
  466.  *
  467.  * Parameters:
  468.  *    st                O: state struct
  469.  *
  470.  * Function:
  471.  *    Reset homing frame counter
  472.  *
  473.  * Returns:
  474.  *    void
  475.  */
  476. void D_IF_reset(WB_dec_if_state *st)
  477. {
  478.    st->reset_flag_old = 1;
  479.    st->prev_ft = RX_SPEECH_GOOD;
  480.    st->prev_mode = MODE_7k;   /* minimum bitrate */
  481. }
  482. /*
  483.  * D_IF_init
  484.  *
  485.  * Parameters:
  486.  *
  487.  * Function:
  488.  *    Allocates state memory and initializes state memory
  489.  *
  490.  * Returns:
  491.  *    pointer to encoder interface structure
  492.  */
  493. void *D_IF_init( void)
  494. {
  495.    WB_dec_if_state *s = NULL;
  496.    /* allocate memory */
  497.    if ((s = (WB_dec_if_state*) malloc(sizeof(WB_dec_if_state))) == NULL)
  498.    {
  499.       return NULL;
  500.    }
  501.    D_MAIN_init(&(s->decoder_state));
  502.    if (s->decoder_state == NULL)
  503.    {
  504.       free(s);
  505.       return NULL;
  506.    }
  507.    D_IF_reset(s);
  508.    return s;
  509. }
  510. /*
  511.  * D_IF_exit
  512.  *
  513.  * Parameters:
  514.  *    state             I: state structure
  515.  *
  516.  * Function:
  517.  *    The memory used for state memory is freed
  518.  *
  519.  * Returns:
  520.  *    Void
  521.  */
  522. void D_IF_exit(void *state)
  523. {
  524.    WB_dec_if_state *s;
  525.    s = (WB_dec_if_state *)state;
  526.    /* free memory */
  527.    D_MAIN_close(&s->decoder_state);
  528.    free(s);
  529.    state = NULL;
  530. }