enc_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 <stdlib.h>
  7. #include "hlxclib/memory.h"
  8. #include "typedef.h"
  9. #include "enc_if.h"
  10. #include "if_rom.h"
  11. #include "enc.h"
  12. #define L_FRAME16k   320            /* Frame size at 16kHz     */
  13. #define EHF_MASK     (Word32)0x0008 /* homing frame pattern    */
  14. #define MODE_7k      0
  15. #define MODE_9k      1
  16. #define MODE_12k     2
  17. #define MODE_14k     3
  18. #define MODE_16k     4
  19. #define MODE_18k     5
  20. #define MODE_20k     6
  21. #define MODE_23k     7
  22. #define MODE_24k     8
  23. #define MRDTX        10
  24. #define MRNO_DATA    15
  25. /* number of bits */
  26. #define HEADER_SIZE  6     /* real size + 1  */
  27. #define T_NBBITS_7k  (NBBITS_7k + HEADER_SIZE)
  28. #define T_NBBITS_9k  (NBBITS_9k + HEADER_SIZE)
  29. #define T_NBBITS_12k (NBBITS_12k + HEADER_SIZE)
  30. #define T_NBBITS_14k (NBBITS_14k + HEADER_SIZE)
  31. #define T_NBBITS_16k (NBBITS_16k + HEADER_SIZE)
  32. #define T_NBBITS_18k (NBBITS_18k + HEADER_SIZE)
  33. #define T_NBBITS_20k (NBBITS_20k + HEADER_SIZE)
  34. #define T_NBBITS_23k (NBBITS_23k + HEADER_SIZE)
  35. #define T_NBBITS_24k (NBBITS_24k + HEADER_SIZE)
  36. #define T_NBBITS_SID (NBBITS_SID + HEADER_SIZE)
  37. typedef struct
  38. {
  39.    Word16 sid_update_counter;   /* Number of frames since last SID */
  40.    Word16 sid_handover_debt;    /* Number of extra SID_UPD frames to schedule */
  41.    Word16 prev_ft;              /* Type of the previous frame */
  42.    void *encoder_state;         /* Points encoder state structure */
  43. } WB_enc_if_state;
  44. extern const Word16 mode_7k[];
  45. extern const Word16 mode_9k[];
  46. extern const Word16 mode_12k[];
  47. extern const Word16 mode_14k[];
  48. extern const Word16 mode_16k[];
  49. extern const Word16 mode_18k[];
  50. extern const Word16 mode_20k[];
  51. extern const Word16 mode_23k[];
  52. extern const Word16 mode_24k[];
  53. extern const Word16 mode_DTX[];
  54. extern const UWord8 block_size[];
  55. extern const Word16 nb_of_param[];
  56. extern const Word16 dfh_M7k[];
  57. extern const Word16 dfh_M9k[];
  58. extern const Word16 dfh_M12k[];
  59. extern const Word16 dfh_M14k[];
  60. extern const Word16 dfh_M16k[];
  61. extern const Word16 dfh_M18k[];
  62. extern const Word16 dfh_M20k[];
  63. extern const Word16 dfh_M23k[];
  64. extern const Word16 dfh_M24k[];
  65. /* overall table with the parameters of the
  66.    decoder homing frames for all modes */
  67. const Word16 *dhf[10];
  68. /*
  69.  * E_IF_homing_frame_test
  70.  *
  71.  *
  72.  * Parameters:
  73.  *    input_frame I: input speech frame
  74.  *
  75.  * Function:
  76.  *    Check 320 input samples for matching EHF_MASK
  77.  *
  78.  * Returns:
  79.  *    If homing frame
  80.  */
  81. Word16 E_IF_homing_frame_test(Word16 input_frame[])
  82. {
  83.    Word32 i, j = 0;
  84.    for (i = 0; i < L_FRAME16k; i++)
  85.    {
  86.       j = input_frame[i] ^ EHF_MASK;
  87.       if (j)
  88.       {
  89.          break;
  90.       }
  91.    }
  92.    return (Word16) (!j);
  93. }
  94. /*
  95.  * E_IF_homing_coding
  96.  *
  97.  *
  98.  * Parameters:
  99.  *    parms  I/O: pointer to parameter vector
  100.  *    mode     I: speech mode
  101.  *
  102.  * Function:
  103.  *    Copy decoder homing frame from memory to parameter vector
  104.  *
  105.  * Returns:
  106.  *    void
  107.  */
  108. void E_IF_homing_coding(Word16 *parms, Word16 mode)
  109. {
  110.    memcpy(parms, dhf[mode], nb_of_param[mode] * sizeof(Word16));
  111. }
  112. /*
  113.  * E_IF_if2_conversion
  114.  *
  115.  *
  116.  * Parameters:
  117.  *  mode        I: Mode
  118.  *  param       I: encoder output
  119.  *  stream      O: packed octets (TS26.201)
  120.  *  frame_type  I: TX frame type
  121.  *  dtx         I: speech mode for mode MRDTX
  122.  *
  123.  * Function:
  124.  *  Packing one frame of encoded parameters to AMR-WB IF2
  125.  *
  126.  * Returns:
  127.  *    number of octets
  128.  */
  129. static int E_IF_if2_conversion(Word16 mode, Word16 *param, UWord8 *stream,
  130.                                Word16 frame_type, Word16 speech_mode)
  131. {
  132.    Word32 j = 0;
  133.    Word16 const *mask;
  134.    memset(stream, 0, block_size[mode]);
  135.    switch(mode)
  136.    {
  137.    case MRNO_DATA:
  138.       *stream = 0xF8;
  139.       j = 8;
  140.       break;
  141.    case MODE_7k:
  142.       mask = mode_7k;
  143.       *stream = 0x2;    /* frame_type = 0, fqi = 1  */
  144.       for (j = HEADER_SIZE; j < T_NBBITS_7k; j++)
  145.       {
  146.          if (param[*mask] & *(mask + 1))
  147.          {
  148.             *stream += 0x1;
  149.          }
  150.          mask += 2;
  151.          if (j % 8)
  152.          {
  153.             *stream <<= 1;
  154.          }
  155.          else
  156.          {
  157.             stream++;
  158.          }
  159.       }
  160.       while (j % 8)
  161.       {
  162.          *stream <<= 1;
  163.          j++;
  164.       }
  165.       break;
  166.    case MODE_9k:
  167.       mask = mode_9k;
  168.       *stream = 0x6;    /* frame_type = 1, fqi = 1  */
  169.       for (j = HEADER_SIZE; j < T_NBBITS_9k; j++)
  170.       {
  171.          if (param[*mask] & *(mask + 1))
  172.          {
  173.             *stream += 0x1;
  174.          }
  175.          mask += 2;
  176.          if (j % 8)
  177.          {
  178.             *stream <<= 1;
  179.          }
  180.          else
  181.          {
  182.             stream++;
  183.          }
  184.       }
  185.       while (j % 8)
  186.       {
  187.          *stream <<= 1;
  188.          j++;
  189.       }
  190.       break;
  191.    case MODE_12k:
  192.       mask = mode_12k;
  193.       *stream = 0xA;    /* frame_type = 2, fqi = 1  */
  194.       for (j = HEADER_SIZE; j < T_NBBITS_12k; j++)
  195.       {
  196.          if (param[*mask] & *(mask + 1))
  197.          {
  198.             *stream += 0x1;
  199.          }
  200.          mask += 2;
  201.          if (j % 8)
  202.          {
  203.             *stream <<= 1;
  204.          }
  205.          else
  206.          {
  207.             stream++;
  208.          }
  209.       }
  210.       while (j % 8)
  211.       {
  212.          *stream <<= 1;
  213.          j++;
  214.       }
  215.       break;
  216.    case MODE_14k:
  217.       mask = mode_14k;
  218.       *stream = 0xE;    /* frame_type = 3, fqi = 1  */
  219.       for ( j = HEADER_SIZE; j < T_NBBITS_14k; j++ )
  220.       {
  221.          if (param[*mask] & *(mask + 1))
  222.          {
  223.             *stream += 0x1;
  224.          }
  225.          mask += 2;
  226.          if (j % 8)
  227.          {
  228.             *stream <<= 1;
  229.          }
  230.          else
  231.          {
  232.             stream++;
  233.          }
  234.       }
  235.       while (j % 8)
  236.       {
  237.          *stream <<= 1;
  238.          j++;
  239.       }
  240.       break;
  241.    case MODE_16k:
  242.       mask = mode_16k;
  243.       *stream = 0x12;    /* frame_type = 4, fqi = 1  */
  244.       for (j = HEADER_SIZE; j < T_NBBITS_16k; j++)
  245.       {
  246.          if (param[*mask] & *(mask + 1))
  247.          {
  248.             *stream += 0x1;
  249.          }
  250.          mask += 2;
  251.          if (j % 8)
  252.          {
  253.             *stream <<= 1;
  254.          }
  255.          else
  256.          {
  257.             stream++;
  258.          }
  259.       }
  260.       while (j % 8)
  261.       {
  262.          *stream <<= 1;
  263.          j++;
  264.       }
  265.       break;
  266.    case MODE_18k:
  267.       mask = mode_18k;
  268.       *stream = 0x16;    /* frame_type = 5, fqi = 1  */
  269.       for (j = HEADER_SIZE; j < T_NBBITS_18k; j++)
  270.       {
  271.          if (param[*mask] & *(mask + 1))
  272.          {
  273.             *stream += 0x1;
  274.          }
  275.          mask += 2;
  276.          if (j % 8)
  277.          {
  278.             *stream <<= 1;
  279.          }
  280.          else
  281.          {
  282.             stream++;
  283.          }
  284.       }
  285.       while (j % 8)
  286.       {
  287.          *stream <<= 1;
  288.          j++;
  289.       }
  290.       break;
  291.    case MODE_20k:
  292.       mask = mode_20k;
  293.       *stream = 0x1A;    /* frame_type = 6, fqi = 1  */
  294.       for (j = HEADER_SIZE; j < T_NBBITS_20k; j++)
  295.       {
  296.          if (param[*mask] & *( mask + 1))
  297.          {
  298.             *stream += 0x1;
  299.          }
  300.          mask += 2;
  301.          if (j % 8)
  302.          {
  303.             *stream <<= 1;
  304.          }
  305.          else
  306.          {
  307.             stream++;
  308.          }
  309.       }
  310.       while (j % 8)
  311.       {
  312.          *stream <<= 1;
  313.          j++;
  314.       }
  315.       break;
  316.    case MODE_23k:
  317.       mask = mode_23k;
  318.       *stream = 0x1E;    /* frame_type = 7, fqi = 1  */
  319.       for (j = HEADER_SIZE; j < T_NBBITS_23k; j++)
  320.       {
  321.          if (param[*mask] & *( mask + 1))
  322.          {
  323.             *stream += 0x1;
  324.          }
  325.          mask += 2;
  326.          if (j % 8)
  327.          {
  328.             *stream <<= 1;
  329.          }
  330.          else
  331.          {
  332.             stream++;
  333.          }
  334.       }
  335.       while (j % 8)
  336.       {
  337.          *stream <<= 1;
  338.          j++;
  339.       }
  340.       break;
  341.    case MODE_24k:
  342.       mask = mode_24k;
  343.       *stream = 0x22;    /* frame_type = 8, fqi = 1  */
  344.       for (j = HEADER_SIZE; j < T_NBBITS_24k; j++)
  345.       {
  346.          if (param[*mask] & *( mask + 1))
  347.          {
  348.             *stream += 0x1;
  349.          }
  350.          mask += 2;
  351.          if (j % 8)
  352.          {
  353.             *stream <<= 1;
  354.          }
  355.          else
  356.          {
  357.             stream++;
  358.          }
  359.       }
  360.       while (j % 8)
  361.       {
  362.          *stream <<= 1;
  363.          j++;
  364.       }
  365.       break;
  366.    case MRDTX:
  367.       mask = mode_DTX;
  368.       *stream = 0x26;    /* frame_type = 9, fqi = 1  */
  369.       for ( j = HEADER_SIZE; j < T_NBBITS_SID; j++ )
  370.       {
  371.          if (param[*mask] & *(mask + 1))
  372.          {
  373.             *stream += 0x1;
  374.          }
  375.          mask += 2;
  376.          if (j % 8)
  377.          {
  378.             *stream <<= 1;
  379.          }
  380.          else
  381.          {
  382.             stream++;
  383.          }
  384.       }
  385.       /* sid type */
  386.       if (frame_type == TX_SID_UPDATE)
  387.       {
  388.          /* sid update */
  389.          *stream += 0x1;
  390.       }
  391.       /* speech mode indicator */
  392.       *stream <<= 4;
  393.       *stream = (UWord8)(*stream + speech_mode);
  394.       /* bit stuffing */
  395.       *stream <<= 3;
  396.       j = 48;
  397.       break;
  398.    default:
  399.       break;
  400.    }
  401.    return j/8;
  402. }
  403. /*
  404.  * E_IF_sid_sync_reset
  405.  *
  406.  * Parameters:
  407.  *    st                O: state structure
  408.  *
  409.  * Function:
  410.  *    Initializes state memory
  411.  *
  412.  * Returns:
  413.  *    void
  414.  */
  415. static void E_IF_sid_sync_reset(WB_enc_if_state *st)
  416. {
  417.    st->sid_update_counter = 3;
  418.    st->sid_handover_debt = 0;
  419.    st->prev_ft = TX_SPEECH;
  420. }
  421. /*
  422.  * E_IF_encode
  423.  *
  424.  *
  425.  * Parameters:
  426.  *    st                I: pointer to state structure
  427.  *    mode              I: Speech Mode
  428.  *    speech            I: Input speech
  429.  *    serial            O: Output octet structure IF2 or 16-bit serial stream
  430.  *    dtx               I: use DTX
  431.  *
  432.  * Function:
  433.  *    Encoding and packing one frame of speech
  434.  *
  435.  * Returns:
  436.  *    number of octets
  437.  */
  438. int E_IF_encode(void *st, Word16 req_mode, Word16 *speech, UWord8 *serial,
  439.                 Word16 dtx)
  440. {
  441.    Word16 prms[NB_PARM_MAX];
  442.    Word32 i;
  443.    Word16 frame_type, mode, reset_flag;
  444.    WB_enc_if_state *s;
  445.    s = (WB_enc_if_state *)st;
  446.    mode = req_mode;
  447.    /* check for homing frame */
  448.    reset_flag = E_IF_homing_frame_test(speech);
  449.    if (!reset_flag)
  450.    {
  451.       for (i = 0; i < L_FRAME16k; i++)   /* Delete the 2 LSBs (14-bit input) */
  452.       {
  453.          speech[i] = (Word16) (speech[i] & 0xfffC);
  454.       }
  455.       E_MAIN_encode(&mode, speech, prms, s->encoder_state, dtx);
  456.       if (mode == MRDTX)
  457.       {
  458.          s->sid_update_counter--;
  459.          if (s->prev_ft == TX_SPEECH)
  460.          {
  461.             frame_type = TX_SID_FIRST;
  462.             s->sid_update_counter = 3;
  463.          }
  464.          else
  465.          {
  466.             if ((s->sid_handover_debt > 0) && (s->sid_update_counter > 2))
  467.             {
  468.                /*
  469.                 * ensure extra updates are
  470.                 * properly delayed after a possible SID_FIRST
  471.                 */
  472.                frame_type = TX_SID_UPDATE;
  473.                s->sid_handover_debt--;
  474.             }
  475.             else
  476.             {
  477.                if (s->sid_update_counter == 0)
  478.                {
  479.                   frame_type = TX_SID_UPDATE;
  480.                   s->sid_update_counter = 8;
  481.                }
  482.                else
  483.                {
  484.                   frame_type = TX_NO_DATA;
  485.                   mode = MRNO_DATA;
  486.                }
  487.             }
  488.          }
  489.       }
  490.       else
  491.       {
  492.          s->sid_update_counter = 8;
  493.          frame_type = TX_SPEECH;
  494.       }
  495.       s->prev_ft = frame_type;
  496.    }
  497.    /* perform homing if homing frame was detected at encoder input */
  498.    else
  499.    {
  500.       E_MAIN_reset(s->encoder_state, 1);
  501.       E_IF_sid_sync_reset(s);
  502.       E_IF_homing_coding(prms, mode);
  503.       frame_type = TX_SPEECH;
  504.    }
  505.    return E_IF_if2_conversion(mode, prms, serial, frame_type, req_mode);
  506. }
  507. /*
  508.  * E_IF_init
  509.  *
  510.  * Parameters:
  511.  *    none
  512.  *
  513.  * Function:
  514.  *    Allocates state memory and initializes state memory
  515.  *
  516.  * Returns:
  517.  *    pointer to encoder interface structure
  518.  */
  519. void *E_IF_init(void)
  520. {
  521.    WB_enc_if_state * s;
  522.    /* allocate memory */
  523.    if ((s = (WB_enc_if_state *)malloc(sizeof(WB_enc_if_state))) == NULL)
  524.    {
  525.       return NULL;
  526.    }
  527.    E_MAIN_init(&(s->encoder_state));
  528.    if (s->encoder_state == NULL)
  529.    {
  530.       free(s);
  531.       return NULL;
  532.    }
  533.    E_IF_sid_sync_reset(s);
  534.    return s;
  535. }
  536. /*
  537.  * E_IF_exit
  538.  *
  539.  * Parameters:
  540.  *    state             I: state structure
  541.  *
  542.  * Function:
  543.  *    The memory used for state memory is freed
  544.  *
  545.  * Returns:
  546.  *    Void
  547.  */
  548. void E_IF_exit(void *state)
  549. {
  550.    WB_enc_if_state *s;
  551.    s = (WB_enc_if_state *)state;
  552.    /* free memory */
  553.    E_MAIN_close(&s->encoder_state);
  554.    free(s);
  555.    state = NULL;
  556. }