dec_acelp.c
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:15k
源码类别:

Symbian

开发平台:

C/C++

  1. /*
  2.  *===================================================================
  3.  *  3GPP AMR Wideband Floating-point Speech Codec
  4.  *===================================================================
  5.  */
  6. #include "hlxclib/memory.h"
  7. #include "typedef.h"
  8. #include "dec_util.h"
  9. #define L_SUBFR      64    /* Subframe size              */
  10. #define PRED_ORDER   4
  11. #define MEAN_ENER    30    /* average innovation energy  */
  12. extern const Word16 D_ROM_ph_imp_low[];
  13. extern const Word16 D_ROM_ph_imp_mid[];
  14. /*
  15.  * D_ACELP_add_pulse
  16.  *
  17.  * Parameters:
  18.  *    pos         I: position of pulse
  19.  *    nb_pulse    I: number of pulses
  20.  *    track       I: track
  21.  *    code        O: fixed codebook
  22.  *
  23.  * Function:
  24.  *    Add pulses to fixed codebook
  25.  *
  26.  * Returns:
  27.  *    void
  28.  */
  29. static void D_ACELP_add_pulse(Word32 pos[], Word32 nb_pulse,
  30.                               Word32 track, Word16 code[])
  31. {
  32.    Word32 i, k;
  33.    for(k = 0; k < nb_pulse; k++)
  34.    {
  35.       /* i = ((pos[k] & (16-1))*NB_TRACK) + track; */
  36.       i = ((pos[k] & (16 - 1)) << 2) + track;
  37.       if((pos[k] & 16) == 0)
  38.       {
  39.          code[i] = (Word16)(code[i] + 512);
  40.       }
  41.       else
  42.       {
  43.          code[i] = (Word16)(code[i] - 512);
  44.       }
  45.    }
  46.    return;
  47. }
  48. /*
  49.  * D_ACELP_decode_1p_N1
  50.  *
  51.  * Parameters:
  52.  *    index    I: pulse index
  53.  *    N        I: number of bits for position
  54.  *    offset   I: offset
  55.  *    pos      O: position of the pulse
  56.  *
  57.  * Function:
  58.  *    Decode 1 pulse with N+1 bits
  59.  *
  60.  * Returns:
  61.  *    void
  62.  */
  63. static void D_ACELP_decode_1p_N1(Word32 index, Word32 N,
  64.                                  Word32 offset, Word32 pos[])
  65. {
  66.    Word32 i, pos1, mask;
  67.    mask = ((1 << N) - 1);
  68.    /*
  69.     * Decode 1 pulse with N+1 bits
  70.     */
  71.    pos1 = ((index & mask) + offset);
  72.    i = ((index >> N) & 1);
  73.    if(i == 1)
  74.    {
  75.       pos1 += 16;
  76.    }
  77.    pos[0] = pos1;
  78.    return;
  79. }
  80. /*
  81.  * D_ACELP_decode_2p_2N1
  82.  *
  83.  * Parameters:
  84.  *    index    I: pulse index
  85.  *    N        I: number of bits for position
  86.  *    offset   I: offset
  87.  *    pos      O: position of the pulse
  88.  *
  89.  * Function:
  90.  *    Decode 2 pulses with 2*N+1 bits
  91.  *
  92.  * Returns:
  93.  *    void
  94.  */
  95. static void D_ACELP_decode_2p_2N1(Word32 index, Word32 N,
  96.                                   Word32 offset, Word32 pos[])
  97. {
  98.    Word32 i, pos1, pos2;
  99.    Word32 mask;
  100.    mask = ((1 << N) - 1);
  101.    /*
  102.     * Decode 2 pulses with 2*N+1 bits
  103.     */
  104.    pos1 = (((index >> N) & mask) + offset);
  105.    i = (index >> (2 * N)) & 1;
  106.    pos2 = ((index & mask) + offset);
  107.    if((pos2 - pos1) < 0)
  108.    {
  109.       if(i == 1)
  110.       {
  111.          pos1 += 16;
  112.       }
  113.       else
  114.       {
  115.          pos2 += 16;
  116.       }
  117.    }
  118.    else
  119.    {
  120.       if(i == 1)
  121.       {
  122.          pos1 += 16;
  123.          pos2 += 16;
  124.       }
  125.    }
  126.    pos[0] = pos1;
  127.    pos[1] = pos2;
  128.    return;
  129. }
  130. /*
  131.  * D_ACELP_decode_3p_3N1
  132.  *
  133.  * Parameters:
  134.  *    index    I: pulse index
  135.  *    N        I: number of bits for position
  136.  *    offset   I: offset
  137.  *    pos      O: position of the pulse
  138.  *
  139.  * Function:
  140.  *    Decode 3 pulses with 3*N+1 bits
  141.  *
  142.  * Returns:
  143.  *    void
  144.  */
  145. static void D_ACELP_decode_3p_3N1(Word32 index, Word32 N,
  146.                                   Word32 offset, Word32 pos[])
  147. {
  148.    Word32 j, mask, idx;
  149.    /*
  150.     * Decode 3 pulses with 3*N+1 bits
  151.     */
  152.    mask = ((1 << ((2 * N) - 1)) - 1);
  153.    idx = index & mask;
  154.    j = offset;
  155.    if(((index >> ((2 * N) - 1)) & 1) == 1)
  156.    {
  157.       j += (1 << (N - 1));
  158.    }
  159.    D_ACELP_decode_2p_2N1(idx, N - 1, j, pos);
  160.    mask = ((1 << (N + 1)) - 1);
  161.    idx = (index >> (2 * N)) & mask;
  162.    D_ACELP_decode_1p_N1(idx, N, offset, pos + 2);
  163.    return;
  164. }
  165. /*
  166.  * D_ACELP_decode_4p_4N1
  167.  *
  168.  * Parameters:
  169.  *    index    I: pulse index
  170.  *    N        I: number of bits for position
  171.  *    offset   I: offset
  172.  *    pos      O: position of the pulse
  173.  *
  174.  * Function:
  175.  *    Decode 4 pulses with 4*N+1 bits
  176.  *
  177.  * Returns:
  178.  *    void
  179.  */
  180. static void D_ACELP_decode_4p_4N1(Word32 index, Word32 N,
  181.                                   Word32 offset, Word32 pos[])
  182. {
  183.    Word32 j, mask, idx;
  184.    /*
  185.     * Decode 4 pulses with 4*N+1 bits
  186.     */
  187.    mask = ((1 << ((2 * N) - 1)) - 1);
  188.    idx = index & mask;
  189.    j = offset;
  190.    if(((index >> ((2 * N) - 1)) & 1) == 1)
  191.    {
  192.       j += (1 << (N - 1));
  193.    }
  194.    D_ACELP_decode_2p_2N1(idx, N - 1, j, pos);
  195.    mask = ((1 << ((2 * N) + 1)) - 1);
  196.    idx = (index >> (2 * N)) & mask;
  197.    D_ACELP_decode_2p_2N1(idx, N, offset, pos + 2);
  198.    return;
  199. }
  200. /*
  201.  * D_ACELP_decode_4p_4N
  202.  *
  203.  * Parameters:
  204.  *    index    I: pulse index
  205.  *    N        I: number of bits for position
  206.  *    offset   I: offset
  207.  *    pos      O: position of the pulse
  208.  *
  209.  * Function:
  210.  *    Decode 4 pulses with 4*N bits
  211.  *
  212.  * Returns:
  213.  *    void
  214.  */
  215. static void D_ACELP_decode_4p_4N(Word32 index, Word32 N,
  216.                                  Word32 offset, Word32 pos[])
  217. {
  218.    Word32 j, n_1;
  219.    /*
  220.     * Decode 4 pulses with 4*N bits
  221.     */
  222.    n_1 = N - 1;
  223.    j = offset + (1 << n_1);
  224.    switch((index >> ((4 * N) - 2)) & 3)
  225.    {
  226.    case 0:
  227.       if(((index >> ((4 * n_1) + 1)) & 1) == 0)
  228.       {
  229.          D_ACELP_decode_4p_4N1(index, n_1, offset, pos);
  230.       }
  231.       else
  232.       {
  233.          D_ACELP_decode_4p_4N1(index, n_1, j, pos);
  234.       }
  235.       break;
  236.    case 1:
  237.       D_ACELP_decode_1p_N1((index >> ((3 * n_1) + 1)), n_1, offset, pos);
  238.       D_ACELP_decode_3p_3N1(index, n_1, j, pos + 1);
  239.       break;
  240.    case 2:
  241.       D_ACELP_decode_2p_2N1((index >> ((2 * n_1) + 1)), n_1, offset, pos);
  242.       D_ACELP_decode_2p_2N1(index, n_1, j, pos + 2);
  243.       break;
  244.    case 3:
  245.       D_ACELP_decode_3p_3N1((index >> (n_1 + 1)), n_1, offset, pos);
  246.       D_ACELP_decode_1p_N1(index, n_1, j, pos + 3);
  247.       break;
  248.    }
  249.    return;
  250. }
  251. /*
  252.  * D_ACELP_decode_5p_5N
  253.  *
  254.  * Parameters:
  255.  *    index    I: pulse index
  256.  *    N        I: number of bits for position
  257.  *    offset   I: offset
  258.  *    pos      O: position of the pulse
  259.  *
  260.  * Function:
  261.  *    Decode 5 pulses with 5*N bits
  262.  *
  263.  * Returns:
  264.  *    void
  265.  */
  266. static void D_ACELP_decode_5p_5N(Word32 index, Word32 N,
  267.                                  Word32 offset, Word32 pos[])
  268. {
  269.    Word32 j, n_1;
  270.    Word32 idx;
  271.    /*
  272.     * Decode 5 pulses with 5*N bits
  273.     */
  274.    n_1 = N - 1;
  275.    j = offset + (1 << n_1);
  276.    idx = (index >> ((2 * N) + 1));
  277.    if(((index >> ((5 * N) - 1)) & 1) == 0)
  278.    {
  279.       D_ACELP_decode_3p_3N1(idx, n_1, offset, pos);
  280.       D_ACELP_decode_2p_2N1(index, N, offset, pos + 3);
  281.    }
  282.    else
  283.    {
  284.       D_ACELP_decode_3p_3N1(idx, n_1, j, pos);
  285.       D_ACELP_decode_2p_2N1(index, N, offset, pos + 3);
  286.    }
  287.    return;
  288. }
  289. /*
  290.  * D_ACELP_decode_6p_6N_2
  291.  *
  292.  * Parameters:
  293.  *    index    I: pulse index
  294.  *    N        I: number of bits for position
  295.  *    offset   I: offset
  296.  *    pos      O: position of the pulse
  297.  *
  298.  * Function:
  299.  *    Decode 6 pulses with 6*N-2 bits
  300.  *
  301.  * Returns:
  302.  *    void
  303.  */
  304. static void D_ACELP_decode_6p_6N_2(Word32 index, Word32 N,
  305.                                    Word32 offset, Word32 pos[])
  306. {
  307.    Word32 j, n_1, offsetA, offsetB;
  308.    n_1 = N - 1;
  309.    j = offset + (1 << n_1);
  310.    offsetA = offsetB = j;
  311.    if(((index >> ((6 * N) - 5)) & 1) == 0)
  312.    {
  313.       offsetA = offset;
  314.    }
  315.    else
  316.    {
  317.       offsetB = offset;
  318.    }
  319.    switch((index >> ((6 * N) - 4)) & 3)
  320.    {
  321.       case 0:
  322.          D_ACELP_decode_5p_5N(index >> N, n_1, offsetA, pos);
  323.          D_ACELP_decode_1p_N1(index, n_1, offsetA, pos + 5);
  324.          break;
  325.       case 1:
  326.          D_ACELP_decode_5p_5N(index >> N, n_1, offsetA, pos);
  327.          D_ACELP_decode_1p_N1(index, n_1, offsetB, pos + 5);
  328.          break;
  329.       case 2:
  330.          D_ACELP_decode_4p_4N(index >> ((2 * n_1) + 1), n_1, offsetA, pos);
  331.          D_ACELP_decode_2p_2N1(index, n_1, offsetB, pos + 4);
  332.          break;
  333.       case 3:
  334.          D_ACELP_decode_3p_3N1(index >> ((3 * n_1) + 1), n_1, offset, pos);
  335.          D_ACELP_decode_3p_3N1(index, n_1, j, pos + 3);
  336.          break;
  337.    }
  338.    return;
  339. }
  340. /*
  341.  * D_ACELP_decode_2t
  342.  *
  343.  * Parameters:
  344.  *    index          I: 12 bits index
  345.  *    code           O: (Q9) algebraic (fixed) codebook excitation
  346.  *
  347.  * Function:
  348.  *    12 bits algebraic codebook decoder.
  349.  *    2 tracks x 32 positions per track = 64 samples.
  350.  *
  351.  *    12 bits --> 2 pulses in a frame of 64 samples.
  352.  *
  353.  *    All pulses can have two (2) possible amplitudes: +1 or -1.
  354.  *    Each pulse can have 32 possible positions.
  355.  *
  356.  *    codevector length    64
  357.  *    number of track      2
  358.  *    number of position   32
  359.  *
  360.  * Returns:
  361.  *    void
  362.  */
  363. void D_ACELP_decode_2t(Word16 index, Word16 code[])
  364. {
  365.    Word32 i0, i1;
  366.    memset(code, 0, 64 * sizeof(Word16));
  367.    /* decode the positions and signs of pulses and build the codeword */
  368.    i0 = (index >> 5) & 0x0000003E;
  369.    i1 = ((index & 0x0000001F) << 1) + 1;
  370.    if(((index >> 6) & 32) == 0)
  371.    {
  372.       code[i0] = 512;
  373.    }
  374.    else
  375.    {
  376.       code[i0] = -512;
  377.    }
  378.    if((index & 32) == 0)
  379.    {
  380.       code[i1] = 512;
  381.    }
  382.    else
  383.    {
  384.       code[i1] = -512;
  385.    }
  386.    return;
  387. }
  388. /*
  389.  * D_ACELP_decode_4t
  390.  *
  391.  * Parameters:
  392.  *    index          I: index
  393.  *    mode           I: speech mode
  394.  *    code           I: (Q9) algebraic (fixed) codebook excitation
  395.  *
  396.  * Function:
  397.  *    20, 36, 44, 52, 64, 72, 88 bits algebraic codebook.
  398.  *    4 tracks x 16 positions per track = 64 samples.
  399.  *
  400.  *    20 bits 5+5+5+5 --> 4 pulses in a frame of 64 samples.
  401.  *    36 bits 9+9+9+9 --> 8 pulses in a frame of 64 samples.
  402.  *    44 bits 13+9+13+9 --> 10 pulses in a frame of 64 samples.
  403.  *    52 bits 13+13+13+13 --> 12 pulses in a frame of 64 samples.
  404.  *    64 bits 2+2+2+2+14+14+14+14 --> 16 pulses in a frame of 64 samples.
  405.  *    72 bits 10+2+10+2+10+14+10+14 --> 18 pulses in a frame of 64 samples.
  406.  *    88 bits 11+11+11+11+11+11+11+11 --> 24 pulses in a frame of 64 samples.
  407.  *
  408.  *    All pulses can have two (2) possible amplitudes: +1 or -1.
  409.  *    Each pulse can sixteen (16) possible positions.
  410.  *
  411.  *    codevector length    64
  412.  *    number of track      4
  413.  *    number of position   16
  414.  *
  415.  * Returns:
  416.  *    void
  417.  */
  418. void D_ACELP_decode_4t(Word16 index[], Word16 nbbits, Word16 code[])
  419. {
  420.    Word32 k, L_index, pos[6];
  421.    memset(code, 0, 64 * sizeof(Word16));
  422.    /* decode the positions and signs of pulses and build the codeword */
  423.    if(nbbits == 20)
  424.    {
  425.       for(k = 0; k < 4; k++)
  426.       {
  427.          L_index = index[k];
  428.          D_ACELP_decode_1p_N1(L_index, 4, 0, pos);
  429.          D_ACELP_add_pulse(pos, 1, k, code);
  430.       }
  431.    }
  432.    else if(nbbits == 36)
  433.    {
  434.       for(k = 0; k < 4; k++)
  435.       {
  436.          L_index = index[k];
  437.          D_ACELP_decode_2p_2N1(L_index, 4, 0, pos);
  438.          D_ACELP_add_pulse(pos, 2, k, code);
  439.       }
  440.    }
  441.    else if(nbbits == 44)
  442.    {
  443.       for(k = 0; k < 4 - 2; k++)
  444.       {
  445.          L_index = index[k];
  446.          D_ACELP_decode_3p_3N1(L_index, 4, 0, pos);
  447.          D_ACELP_add_pulse(pos, 3, k, code);
  448.       }
  449.       for(k = 2; k < 4; k++)
  450.       {
  451.          L_index = index[k];
  452.          D_ACELP_decode_2p_2N1(L_index, 4, 0, pos);
  453.          D_ACELP_add_pulse(pos, 2, k, code);
  454.       }
  455.    }
  456.    else if(nbbits == 52)
  457.    {
  458.       for(k = 0; k < 4; k++)
  459.       {
  460.          L_index = index[k];
  461.          D_ACELP_decode_3p_3N1(L_index, 4, 0, pos);
  462.          D_ACELP_add_pulse(pos, 3, k, code);
  463.       }
  464.    }
  465.    else if(nbbits == 64)
  466.    {
  467.       for(k = 0; k < 4; k++)
  468.       {
  469.          L_index = ((index[k] << 14) + index[k + 4]);
  470.          D_ACELP_decode_4p_4N(L_index, 4, 0, pos);
  471.          D_ACELP_add_pulse(pos, 4, k, code);
  472.       }
  473.    }
  474.    else if(nbbits == 72)
  475.    {
  476.       for(k = 0; k < 4 - 2; k++)
  477.       {
  478.          L_index = ((index[k] << 10) + index[k + 4]);
  479.          D_ACELP_decode_5p_5N(L_index, 4, 0, pos);
  480.          D_ACELP_add_pulse(pos, 5, k, code);
  481.       }
  482.       for(k = 2; k < 4; k++)
  483.       {
  484.          L_index = ((index[k] << 14) + index[k + 4]);
  485.          D_ACELP_decode_4p_4N(L_index, 4, 0, pos);
  486.          D_ACELP_add_pulse(pos, 4, k, code);
  487.       }
  488.    }
  489.    else if(nbbits == 88)
  490.    {
  491.       for(k = 0; k < 4; k++)
  492.       {
  493.          L_index = ((index[k] << 11) + index[k + 4]);
  494.          D_ACELP_decode_6p_6N_2(L_index, 4, 0, pos);
  495.          D_ACELP_add_pulse(pos, 6, k, code);
  496.       }
  497.    }
  498.    return;
  499. }
  500. /*
  501.  * D_ACELP_phase_dispersion
  502.  *
  503.  * Parameters:
  504.  *    gain_code         I: (Q0) gain of code
  505.  *    gain_pit          I: (Q14) gain of pitch
  506.  *    code            I/O: code vector
  507.  *    mode              I: level, 0=hi, 1=lo, 2=off
  508.  *    disp_mem        I/O: static memory (size = 8)
  509.  *
  510.  * Function:
  511.  *    An adaptive anti-sparseness post-processing procedure is
  512.  *    applied to the fixed codebook vector in order to
  513.  *    reduce perceptual artifacts arising from the sparseness
  514.  *    of the algebraic fixed codebook vectors with only
  515.  *    a few non-zero samples per subframe.
  516.  *
  517.  * Returns:
  518.  *    void
  519.  */
  520. void D_ACELP_phase_dispersion(Word16 gain_code, Word16 gain_pit, Word16 code[],
  521.                               Word16 mode, Word16 disp_mem[])
  522. {
  523.    Word32 code2[2 * L_SUBFR] = {0};
  524.    Word32 i, j, state;
  525.    Word16 *prev_gain_pit, *prev_gain_code, *prev_state;
  526.    prev_state = disp_mem;
  527.    prev_gain_code = disp_mem + 1;
  528.    prev_gain_pit = disp_mem + 2;
  529.    if(gain_pit < 9830)   /* 0.6 in Q14 */
  530.    {
  531.       state = 0;
  532.    }
  533.    else if(gain_pit < 14746)   /* 0.9 in Q14 */
  534.    {
  535.       state = 1;
  536.    }
  537.    else
  538.    {
  539.       state = 2;
  540.    }
  541.    for(i = 5; i > 0; i--)
  542.    {
  543.       prev_gain_pit[i] = prev_gain_pit[i - 1];
  544.    }
  545.    prev_gain_pit[0] = gain_pit;
  546.    if((gain_code - *prev_gain_code) > (*prev_gain_code << 1))
  547.    {
  548.       /* onset */
  549.       if(state < 2)
  550.       {
  551.          state = state + 1;
  552.       }
  553.    }
  554.    else
  555.    {
  556.       j = 0;
  557.       for(i = 0; i < 6; i++)
  558.       {
  559.          if(prev_gain_pit[i] < 9830)   /* 0.6 in Q14 */
  560.             j = (j + 1);
  561.       }
  562.       if(j > 2)
  563.       {
  564.          state = 0;
  565.       }
  566.       if((state - *prev_state) > 1)
  567.       {
  568.          state = state - 1;
  569.       }
  570.    }
  571.    *prev_gain_code = gain_code;
  572.    *prev_state = (Word16)state;
  573.    /* circular convolution */
  574.    state = state + mode;   /* level of dispersion */
  575.    if(state == 0)
  576.    {
  577.       for(i = 0; i < L_SUBFR; i++)
  578.       {
  579.          if(code[i] != 0)
  580.          {
  581.             for(j = 0; j < L_SUBFR; j++)
  582.             {
  583.                code2[i + j] = code2[i + j] +
  584.                   (((code[i] * D_ROM_ph_imp_low[j]) + 0x4000) >> 15);
  585.             }
  586.          }
  587.       }
  588.    }
  589.    else if(state == 1)
  590.    {
  591.       for(i = 0; i < L_SUBFR; i++)
  592.       {
  593.          if(code[i] != 0)
  594.          {
  595.             for(j = 0; j < L_SUBFR; j++)
  596.             {
  597.                code2[i + j] = code2[i + j] +
  598.                   (((code[i] * D_ROM_ph_imp_mid[j]) + 0x4000) >> 15);
  599.             }
  600.          }
  601.       }
  602.    }
  603.    if(state < 2)
  604.    {
  605.       for(i = 0; i < L_SUBFR; i++)
  606.       {
  607.          code[i] = (Word16)(code2[i] + code2[i + L_SUBFR]);
  608.       }
  609.    }
  610.    return;
  611. }