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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
celp_decoder.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：48k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

celp_decoder.c：源码内容
  1. /*====================================================================*/
  2. /*         MPEG-4 Audio (ISO/IEC 14496-3) Copyright Header            */
  3. /*====================================================================*/
  4. /*
  5. This software module was originally developed by Rakesh Taori and Andy
  6. Gerrits (Philips Research Laboratories, Eindhoven, The Netherlands) in
  7. the course of development of the MPEG-4 Audio (ISO/IEC 14496-3). This
  8. software module is an implementation of a part of one or more MPEG-4
  9. Audio (ISO/IEC 14496-3) tools as specified by the MPEG-4 Audio
  10. (ISO/IEC 14496-3). ISO/IEC gives users of the MPEG-4 Audio (ISO/IEC
  11. 14496-3) FREE license to this software module or modifications thereof
  12. for use in hardware or software products claiming conformance to the
  13. MPEG-4 Audio (ISO/IEC 14496-3). Those intending to use this software
  14. module in hardware or software products are advised that its use may
  15. infringe existing patents. The original developer of this software
  16. module and his/her company, the subsequent editors and their
  17. companies, and ISO/IEC have no liability for use of this software
  18. module or modifications thereof in an implementation. Copyright is not
  19. released for non MPEG-4 Audio (ISO/IEC 14496-3) conforming products.
  20. CN1 retains full right to use the code for his/her own purpose, assign
  21. or donate the code to a third party and to inhibit third parties from
  22. using the code for non MPEG-4 Audio (ISO/IEC 14496-3) conforming
  23. products.  This copyright notice must be included in all copies or
  24. derivative works. Copyright 1996.
  25. */
  26. /*====================================================================*/
  27. /*======================================================================*/
  28. /*                                                                      */
  29. /*      SOURCE_FILE:    CELP_DECODER.C                                  */
  30. /*                                                                      */
  31. /*======================================================================*/
  32.     
  33. /*======================================================================*/
  34. /*      I N C L U D E S                                                 */
  35. /*======================================================================*/
  36. #include <stdio.h>
  37. #include <stdlib.h>
  38. #include <assert.h>
  40. #include "buffersHandle.h"       /* handler, defines, enums */
  42. #include "bitstream.h"     /* bit stream module                         */
  43. #include "phi_cons.h"           /* Philips Defined Constants            */
  44. #include "phi_priv.h" /* for PHI private data storage */
  45. #include "bitstream.h"
  46. #include "lpc_common.h"         /* Common LPC core Defined Constants    */
  47. #include "phi_gxit.h"           /* Excitation Generation Prototypes     */
  48. #include "phi_lpc.h"            /* Prototypes of LPC Subroutines        */
  49. #include "phi_post.h"           /* Post Processing Module Prototype     */
  50. #include "phi_fbit.h"           /* Frame bit allocation table           */
  51. #include "nec_abs_proto.h"      /* Prototypes for NEC Routines          */
  52. #include "pan_celp_const.h"     /* Constants for PAN Routines           */
  53. #include "celp_proto_dec.h"     /* Prototypes for CELP Routines         */
  54. #include "celp_decoder.h"       /* Prototypes for CELP Decoder Routines */
  55. #include "celp_bitstream_demux.h"/* Prototypes for CELP Decoder Routines*/
  56. #include "nec_abs_const.h"      /* Constants for NEC Routines           */
  58. int CELPdecDebugLevel = 0; /* HP 971120 */
  60. /* ---------------------------------------------------------------------*/ 
  61. /* Frame counter                                                        */
  62. /* ---------------------------------------------------------------------*/
  63. static unsigned long frame_ctr = 0;   /* Frame Counter                   */
  65. static long postfilter = 0;           /* Postfilter switch               */
  66. static float *prev_Qlsp_coefficients; /* previous quantized LSP coeff.   */
  68. static long num_enhstages;
  69. static long dec_enhstages;
  70. static long dec_bwsmode;
  71. static long num_indices;
  73. /*======================================================================*/
  74. /*    NarrowBand Data declaration                                       */
  75. /*======================================================================*/
  76. static float *buf_Qlsp_coefficients_bws; /* current quantized LSP coeff. */
  77. static float *prev_Qlsp_coefficients_bws;/* previous quantized LSP coeff. */
  79. static long frame_size_nb, frame_size_bws;
  80. static long n_subframes_bws;
  81. static long sbfrm_size_bws;
  82. static long lpc_order_bws;
  83. static long num_lpc_indices_bws;
  84. static long mp_pos_bits, mp_sgn_bits;
  85. static long enh_pos_bits, enh_sgn_bits;
  86. static long bws_pos_bits, bws_sgn_bits;
  88. /*======================================================================*/
  89. /* Type definitions                                                     */
  90. /*======================================================================*/
  92. typedef struct
  93. {
  94.   PHI_PRIV_TYPE *PHI_Priv;
  95.   /* add private data pointers here for other coding varieties */
  96. } INST_CONTEXT_LPC_DEC_TYPE;
  99. /*======================================================================*/
  100. /* Function definition: abs_coder                                       */
  101. /*======================================================================*/
  102. void celp_decoder
  103. (
  104. BsBitStream *bitStream,           /* In: Bitstream                     */
  105. float     **OutputSignal,          /* Out: Multichannel Output          */
  106. long        ExcitationMode,    /* In: Excitation Mode         */
  107. long        SampleRateMode,    /* In: SampleRate Mode */
  108. long        QuantizationMode,    /* In: Type of Quantization         */
  109. long        FineRateControl,    /* In: Fine Rate Control switch    */
  110. long        LosslessCodingMode,    /* In: Lossless Coding Mode         */
  111. long        RPE_configuration,    /* In: RPE_configuration             */
  112. long        Wideband_VQ,    /* In: Wideband VQ mode */
  113. long        MPE_Configuration,    /* In: Narrowband configuration */
  114. long        NumEnhLayers,    /* In: Number of Enhancement Layers  */
  115. long        BandwidthScalabilityMode, /* In: bandwidth switch           */
  116. long        BWS_configuration,     /* In: BWS_configuration           */
  117. long        frame_size,            /* In:  Frame size                   */
  118. long        n_subframes,           /* In:  Number of subframes          */
  119. long        sbfrm_size,            /* In:  Subframe size                */
  120. long        lpc_order,             /* In:  Order of LPC                 */
  121. long        num_lpc_indices,       /* In:  Number of LPC indices        */
  122. long        num_shape_cbks,        /* In:  Number of Shape Codebooks    */
  123. long        num_gain_cbks,         /* In:  Number of Gain Codebooks     */
  124. long        *org_frame_bit_allocation, /* In: bit num. for each index     */
  125. void        *InstanceContext    /* In: pointer to instance context */
  126. )
  127. {
  128.     /*==================================================================*/
  129.     /*      L O C A L   D A T A   D E F I N I T I O N S                 */
  130.     /*==================================================================*/
  131.     float *int_ap;                                    /*Interpolated ap */
  132.     unsigned long *shape_indices;                     /* Shape indices  */
  133.     unsigned long *gain_indices;                      /* Gain indices   */
  134.     unsigned long *indices;                           /* LPC codes*/
  135.     long sbfrm_ctr = 0;
  136.     long dum = 0;
  138.     float *int_ap_bws;                               /*Interpolated ap */
  139.     unsigned long *shape_indices_bws;                /* Shape indices  */
  140.     unsigned long *gain_indices_bws;                 /* Gain indices   */
  141.     unsigned long *indices_bws;                      /* LPC codes*/
  142.     long *bws_nb_acb_index;                          /* ACB codes      */
  144.     unsigned long interpolation_flag = 0;           /* Interpolation Flag*/
  145.     unsigned long LPC_Present = 1;
  146.     unsigned long signal_mode;
  147.     unsigned long rms_index;
  149.     PHI_PRIV_TYPE *PHI_Priv;
  151.     /* -----------------------------------------------------------------*/
  152.     /* Set up pointers to private data                                  */
  153.     /* -----------------------------------------------------------------*/
  154.     PHI_Priv = ((INST_CONTEXT_LPC_DEC_TYPE *)InstanceContext)->PHI_Priv;
  156.     /* -----------------------------------------------------------------*/
  157.     /* Create Arrays for frame processing                               */
  158.     /* -----------------------------------------------------------------*/
  159.     if
  160.     (
  161.     (( int_ap = (float *)malloc((unsigned int)(n_subframes * lpc_order) * sizeof(float))) == NULL )||
  162.     (( shape_indices = (unsigned long *)malloc((unsigned int)((num_enhstages+1)*num_shape_cbks * n_subframes) * sizeof(unsigned long))) == NULL )||
  163.     (( gain_indices = (unsigned long *)malloc((unsigned int)((num_enhstages+1)*num_gain_cbks * n_subframes) * sizeof(unsigned long))) == NULL )||
  164.     (( indices = (unsigned long *)malloc((unsigned int)num_lpc_indices * sizeof(unsigned long))) == NULL )
  165.     )
  166.     {
  167.         fprintf(stderr, "MALLOC FAILURE in abs_decoder  n");
  168.         exit(1);
  169.     }
  171.     if (BandwidthScalabilityMode == ON) {
  173.       if
  174. (
  175.  (( int_ap_bws = (float *)malloc((unsigned int)(n_subframes_bws * lpc_order_bws) * sizeof(float))) == NULL )||
  176.  (( shape_indices_bws = (unsigned long *)malloc((unsigned int)(num_shape_cbks * n_subframes_bws) * sizeof(unsigned long))) == NULL )||
  177.  (( gain_indices_bws = (unsigned long *)malloc((unsigned int)(num_gain_cbks * n_subframes_bws) * sizeof(unsigned long))) == NULL )||
  178.  (( indices_bws = (unsigned long *)malloc((unsigned int)num_lpc_indices_bws * sizeof(unsigned long))) == NULL ) ||
  179.  (( bws_nb_acb_index = (long *)malloc((unsigned int)n_subframes_bws * sizeof(long))) == NULL )
  180.  )
  181.   {
  182.     fprintf(stderr, "MALLOC FAILURE in abs_decoder  n");
  183.     exit(1);
  184.   }
  185.     }
  187.     /* CelpBaseFrame() */
  188.     /* Celp_LPC() */
  189.     /*==================================================================*/
  190.     /* CELP Lpc demux                                                   */
  191.     /*==================================================================*/
  192.    
  193.     if (FineRateControl == ON)
  194.     {
  195. /* ---------------------------------------------------------*/
  196. /* Step I: Read interpolation_flag and LPC_present flag     */
  197. /* ---------------------------------------------------------*/
  198. BsGetBit(bitStream, &interpolation_flag, 1);
  199. BsGetBit(bitStream, &LPC_Present, 1);
  201. /* ---------------------------------------------------------*/
  202. /* Step II: If LPC is present                               */
  203. /* ---------------------------------------------------------*/
  204. if (LPC_Present == YES)
  205. {
  206.     if (SampleRateMode == fs8kHz)
  207.     {
  208. Read_NarrowBand_LSP(bitStream, indices);
  209.     } 
  210.     else
  211.     {
  212. Read_Wideband_LSP(bitStream, indices);
  213.     }
  214. }
  215.     }
  216.     else
  217.     {
  218. if (SampleRateMode == fs8kHz)
  219. {
  220.     Read_NarrowBand_LSP(bitStream, indices);
  221. } 
  222. else
  223. {
  224.     Read_Wideband_LSP(bitStream, indices);
  225. }
  226.     }
  228.     /*==================================================================*/
  229.     /* CELP Excitation decoding                                         */
  230.     /*==================================================================*/
  231.     if ( ExcitationMode == RegularPulseExc )
  232.     {  /* RPE_Frame() */
  233. long subframe;
  235. /*--------------------------------------------------------------*/
  236. /* Regular Pulse Excitation                                     */ 
  237. /*--------------------------------------------------------------*/
  238. for(subframe = 0; subframe < n_subframes; subframe++)
  239. {
  240.     /* ---------------------------------------------------------*/
  241.     /* Read the Adaptive Codebook Lag                           */
  242.     /* ---------------------------------------------------------*/
  243.     BsGetBit(bitStream, &shape_indices[subframe * num_shape_cbks], 8);
  245.     /* ---------------------------------------------------------*/
  246.     /*Read the Fixed Codebook Index (function of bit-rate)      */
  247.     /* ---------------------------------------------------------*/
  249.     switch (RPE_configuration)
  250.     {
  251. case     0   :   BsGetBit(bitStream, &shape_indices[subframe * num_shape_cbks + 1], 11);
  252.                  break;
  253. case     1   :   BsGetBit(bitStream, &shape_indices[subframe * num_shape_cbks + 1], 11);
  254.                  break;
  255. case     2   :   BsGetBit(bitStream, &shape_indices[subframe * num_shape_cbks + 1], 12);
  256.                  break;
  257. case     3   :   BsGetBit(bitStream, &shape_indices[subframe * num_shape_cbks + 1], 12);
  258.                  break;
  259.     }
  261.     /* ---------------------------------------------------------*/
  262.     /*Read the Adaptive Codebook Gain                           */
  263.     /* ---------------------------------------------------------*/
  264.     BsGetBit(bitStream, &gain_indices[subframe * num_gain_cbks], 6);
  266.     /* ---------------------------------------------------------*/
  267.     /*Read the Fixed Codebook Gain (function of subframe)       */
  268.     /*Later subframes are encoded differentially w.r.t previous */
  269.     /* ---------------------------------------------------------*/
  270.     if (subframe == 0)
  271.     {
  272. BsGetBit(bitStream, &gain_indices[subframe * num_gain_cbks + 1], 5);
  273.     }
  274.     else
  275.     {
  276. BsGetBit(bitStream, &gain_indices[subframe * num_gain_cbks + 1], 3);
  277.     }
  279. }
  280.     }
  281.     
  282.     if (ExcitationMode == MultiPulseExc) { /* MPE_frame() */
  283.       /*--------------------------------------------------------------*/
  284.       /* Multi-Pulse Excitation                                       */ 
  285.       /*--------------------------------------------------------------*/
  286.       long i;
  288.       BsGetBit(bitStream, &signal_mode, NEC_BIT_MODE);
  289.       BsGetBit(bitStream, &rms_index, NEC_BIT_RMS);
  290.       if (SampleRateMode == fs8kHz) {
  291. for ( i = 0; i < n_subframes; i++ ) {
  292.   BsGetBit(bitStream,
  293.  &shape_indices[i*num_shape_cbks+0], NEC_BIT_ACB);
  294.   BsGetBit(bitStream,
  295.  &shape_indices[i*num_shape_cbks+1], mp_pos_bits);
  296.   BsGetBit(bitStream,
  297.  &shape_indices[i*num_shape_cbks+2], mp_sgn_bits);
  298.   BsGetBit(bitStream,
  299.  &gain_indices[i*num_gain_cbks+0], NEC_BIT_GAIN);
  300. }
  301.       } else {
  302. for ( i = 0; i < n_subframes; i++ ) {
  303.   BsGetBit(bitStream,
  304.  &shape_indices[i*num_shape_cbks+0], NEC_ACB_BIT_WB);
  305.   BsGetBit(bitStream,
  306.  &shape_indices[i*num_shape_cbks+1], mp_pos_bits);
  307.   BsGetBit(bitStream,
  308.  &shape_indices[i*num_shape_cbks+2], mp_sgn_bits);
  309.   BsGetBit(bitStream,
  310.  &gain_indices[i*num_gain_cbks+0], NEC_BIT_GAIN_WB);
  311. }
  312.       }
  313.     }
  314.     /* end of CelpBaseFrame() */
  316.     if (ExcitationMode == MultiPulseExc) {
  317.       long i, j;
  319.       /* CelpBRSenhFrame() */
  320.       if ( num_enhstages >= 1 ) {
  321. for ( j = 1; j <= num_enhstages; j++ ) {
  322.   for ( i = 0; i < n_subframes; i++ ) {
  323.     shape_indices[(j*n_subframes+i)*num_shape_cbks+0] = 0;
  324.     BsGetBit(bitStream,
  325.    &shape_indices[(j*n_subframes+i)*num_shape_cbks+1],
  326.    enh_pos_bits);
  327.     BsGetBit(bitStream,
  328.    &shape_indices[(j*n_subframes+i)*num_shape_cbks+2],
  329.    enh_sgn_bits);
  330.     BsGetBit(bitStream,
  331.    &gain_indices[(j*n_subframes+i)*num_gain_cbks+0],
  332.    NEC_BIT_ENH_GAIN);
  333.   }
  334. }
  335.       }
  337.       /* CelpBWSenhFrame() */
  338.       if (SampleRateMode == fs8kHz && 
  339.   FineRateControl == OFF && QuantizationMode == VectorQuantizer &&
  340.   BandwidthScalabilityMode == ON) {
  341. Read_BandScalable_LSP(bitStream, indices_bws);
  343. for ( i = 0; i < n_subframes_bws; i++ ) {
  344.   BsGetBit(bitStream,
  345.  &shape_indices_bws[i*num_shape_cbks+0],
  346.  NEC_BIT_ACB_FRQ16);
  347.   BsGetBit(bitStream,
  348.  &shape_indices_bws[i*num_shape_cbks+1], bws_pos_bits);
  349.   BsGetBit(bitStream,
  350.  &shape_indices_bws[i*num_shape_cbks+2], bws_sgn_bits);
  351.   BsGetBit(bitStream,
  352.  &gain_indices_bws[i*num_gain_cbks+0],
  353.  NEC_BIT_GAIN_FRQ16);
  354. }
  355.       }
  356.     }
  358.     /* -----------------------------------------------------------------*/
  359.     /* Decode LPC coefficients                                          */
  360.     /* -----------------------------------------------------------------*/
  361.   
  362.     if (FineRateControl == ON)
  363.     {
  364. VQ_celp_lpc_decode(indices, int_ap, lpc_order, num_lpc_indices, n_subframes,
  365.                        interpolation_flag, Wideband_VQ, PHI_Priv);
  366.     }
  367.     else
  368.     {  /*  FineRate Control OFF  */
  369. if (SampleRateMode == fs8kHz)
  370. {
  371.     long k;
  373.     if (ExcitationMode == RegularPulseExc)
  374.     {
  375.       fprintf (stderr, "Combination of RPE + 8 kHz sampling rate not supported.n");
  376.       exit (1);
  377.     }
  379.     if (ExcitationMode == MultiPulseExc)
  380.     {
  381. nb_abs_lpc_decode(indices, int_ap, lpc_order, n_subframes,
  382.   prev_Qlsp_coefficients);
  383.     }
  385.     if ( BandwidthScalabilityMode == ON)
  386.     {
  387. for ( k = 0; k < lpc_order; k++ )
  388. {
  389.     buf_Qlsp_coefficients_bws[k] = PAN_PI * prev_Qlsp_coefficients[k];
  390. }
  391. bws_lpc_decoder(indices_bws, int_ap_bws, lpc_order, lpc_order_bws,
  392. n_subframes_bws, buf_Qlsp_coefficients_bws, 
  393. prev_Qlsp_coefficients_bws );
  394.     }
  395. }
  397. if (SampleRateMode == fs16kHz)
  398. {
  399.     if (ExcitationMode == RegularPulseExc)
  400.     {
  401. VQ_celp_lpc_decode(indices, int_ap, lpc_order, num_lpc_indices, n_subframes,
  402.                    interpolation_flag, Wideband_VQ, PHI_Priv);
  403.     }
  404.     if (ExcitationMode == MultiPulseExc)
  405.     {
  406. wb_celp_lsp_decode(indices, int_ap, lpc_order, n_subframes,
  407.                    prev_Qlsp_coefficients);
  408.     }     
  409. } 
  410.     }
  412.     if (ExcitationMode==RegularPulseExc)
  413.     {
  414. /* -----------------------------------------------------------------*/
  415. /* Subframe processing                                              */
  416. /* -----------------------------------------------------------------*/
  417. for (sbfrm_ctr = 0; sbfrm_ctr < n_subframes; sbfrm_ctr++)
  418. {
  419.     long  m = sbfrm_ctr * lpc_order;
  420.     float *cbk_sig;
  421.     float *syn_speech;
  422.     float dumf;
  423.     
  424.     /* -------------------------------------------------------------*/
  425.     /* Create Arrays for subframe processing                        */
  426.     /* -------------------------------------------------------------*/
  427.     if
  428.     (
  429.     (( cbk_sig = (float *)malloc((unsigned int)sbfrm_size * sizeof(float))) == NULL )||
  430.     (( syn_speech = (float *)malloc((unsigned int)sbfrm_size * sizeof(float))) == NULL )
  431.     )
  432.     {
  433. fprintf(stderr, "MALLOC FAILURE in abs_decoder  n");
  434. exit(1);
  435.     }
  436.     
  437.     /* ------------------------------------------------------------*/
  438.     /* Excitation Generation                                       */
  439.     /* ------------------------------------------------------------*/
  440.     celp_excitation_generation(&(shape_indices[sbfrm_ctr*num_shape_cbks]),
  441.                                &(gain_indices[sbfrm_ctr*num_gain_cbks]), num_shape_cbks,
  442.        num_gain_cbks, dum, &int_ap[m], lpc_order, sbfrm_size,
  443.        n_subframes, dum, org_frame_bit_allocation, cbk_sig, &dum,
  444.        &dumf, PHI_Priv);
  445.     
  446.     /* ------------------------------------------------------------*/
  447.     /* Speech Generation                                           */
  448.     /* ------------------------------------------------------------*/
  449.     celp_lpc_synthesis_filter(cbk_sig, syn_speech, &int_ap[m], lpc_order, sbfrm_size, PHI_Priv);
  450.     
  451.     if (postfilter)
  452.     {
  453.     /* --------------------------------------------------------*/
  454.     /* Post Processing                                         */
  455.     /* --------------------------------------------------------*/
  456.     celp_postprocessing(syn_speech, &(OutputSignal[0][sbfrm_ctr*sbfrm_size]), &int_ap[m], lpc_order, sbfrm_size, dum, dumf, PHI_Priv); 
  457.     
  458.     }
  459.     else
  460.     {
  461. long k;
  462. float *psyn_speech   =  syn_speech;
  463. float *pOutputSignal =  &(OutputSignal[0][sbfrm_ctr*sbfrm_size]);
  464.     
  465. for(k=0; k < sbfrm_size; k++)
  466. {
  467.     *pOutputSignal++ = *psyn_speech++;    
  468. }
  469.     }
  470.     
  471.     /* -------------------------------------------------------------*/
  472.     /* Free   Arrays for subframe processing                        */
  473.     /* -------------------------------------------------------------*/
  474.     FREE ( syn_speech );
  475.     FREE ( cbk_sig );
  476. }    
  477.       } 
  479.     if (ExcitationMode==MultiPulseExc)
  480.     {
  481.       float *dec_sig;
  482.       float *bws_mp_sig;
  483.       long  *acb_delay;
  484.       float *adaptive_gain;
  485.       float *dec_sig_bws;
  486.       long  *bws_delay;
  487.       float *bws_adpt_gain;
  489.       float *syn_sig; /* HP 971112 */
  490.       long  kk;
  492.       if (SampleRateMode == fs8kHz) {
  493. if(
  494.    (( dec_sig   = (float *)malloc((unsigned int)frame_size_nb * sizeof(float))) == NULL )||
  495.    (( bws_mp_sig   = (float *)malloc((unsigned int)frame_size_nb * sizeof(float))) == NULL )
  496.    ) {
  497.   fprintf(stderr, "MALLOC FAILURE in abs_decoder  n");
  498.   exit(1);
  499. }
  500.       } else {
  501. if(
  502.    (( dec_sig   = (float *)malloc((unsigned int)frame_size * sizeof(float))) == NULL )||
  503.    (( bws_mp_sig   = (float *)malloc((unsigned int)frame_size * sizeof(float))) == NULL )
  504.    ) {
  505.   fprintf(stderr, "MALLOC FAILURE in abs_decoder  n");
  506.   exit(1);
  507. }
  508.       }
  509.       if((( acb_delay   = (long *)malloc(n_subframes * sizeof(long))) == NULL )||
  510.    (( adaptive_gain   = (float *)malloc(n_subframes * sizeof(float))) == NULL ) ) {
  511. fprintf(stderr, "MALLOC FAILURE in abs_decoder  n");
  512. exit(1);
  513.       }
  515.       for (sbfrm_ctr = 0; sbfrm_ctr < n_subframes; sbfrm_ctr++) {
  516. nb_abs_excitation_generation(shape_indices, gain_indices, 
  517.      num_shape_cbks, num_gain_cbks, rms_index,
  518.      int_ap+lpc_order*sbfrm_ctr, lpc_order, 
  519.      sbfrm_size, n_subframes, signal_mode, 
  520.      org_frame_bit_allocation,
  521.      dec_sig+sbfrm_size*sbfrm_ctr, 
  522.      bws_mp_sig+sbfrm_size*sbfrm_ctr, 
  523.      acb_delay+sbfrm_ctr,
  524.      adaptive_gain+sbfrm_ctr,
  525.      dec_enhstages,postfilter,
  526.      SampleRateMode);
  527.       }
  529.       if (BandwidthScalabilityMode == ON) {
  530. if(
  531.    (( dec_sig_bws   = (float *)malloc((unsigned int)frame_size_bws * sizeof(float))) == NULL )
  532.    ) {
  533.   fprintf(stderr, "MALLOC FAILURE in abs_decoder  n");
  534.   exit(1);
  535. }
  536. if((( bws_delay   = (long *)malloc(n_subframes_bws * sizeof(long))) == NULL )||
  537.    (( bws_adpt_gain   = (float *)malloc(n_subframes_bws * sizeof(float))) == NULL ) ) {
  538. fprintf(stderr, "MALLOC FAILURE in abs_decoder  n");
  539. exit(1);
  540. }
  542. for (sbfrm_ctr = 0; sbfrm_ctr < n_subframes_bws; sbfrm_ctr++) {
  543.   bws_nb_acb_index[sbfrm_ctr] = shape_indices[sbfrm_ctr*n_subframes/n_subframes_bws*num_shape_cbks];
  544. }
  546. for (sbfrm_ctr = 0; sbfrm_ctr < n_subframes_bws; sbfrm_ctr++) {
  547.   bws_excitation_generation(shape_indices_bws, gain_indices_bws, 
  548.     num_shape_cbks, num_gain_cbks, rms_index,
  549.     int_ap_bws+lpc_order_bws*sbfrm_ctr,
  550.     lpc_order_bws, 
  551.     sbfrm_size_bws, n_subframes_bws,
  552.     signal_mode, 
  553.     &org_frame_bit_allocation[num_indices-n_subframes_bws*(num_shape_cbks+num_gain_cbks)],
  554.     dec_sig_bws+sbfrm_size_bws*sbfrm_ctr, 
  555.     bws_mp_sig+sbfrm_size*n_subframes/n_subframes_bws*sbfrm_ctr,
  556.     bws_nb_acb_index,
  557.     bws_delay+sbfrm_ctr,bws_adpt_gain+sbfrm_ctr,postfilter);
  558. }
  559.       }
  561.       if ( (BandwidthScalabilityMode==ON) && (dec_bwsmode) ) {
  562.         if(( syn_sig = (float *)malloc((unsigned int)sbfrm_size_bws * sizeof(float))) == NULL ){
  563.   fprintf(stderr, "MALLOC FAILURE in abs_decoder  n");
  564.   exit(1);
  565. }
  567. for (sbfrm_ctr = 0; sbfrm_ctr < n_subframes_bws; sbfrm_ctr++) {
  568.   celp_lpc_synthesis_filter(dec_sig_bws+sbfrm_size_bws*sbfrm_ctr,
  569.     syn_sig,
  570.     int_ap_bws+lpc_order_bws*sbfrm_ctr,
  571.     lpc_order_bws, sbfrm_size_bws, PHI_Priv);
  572.   if (postfilter) {
  573.     nb_abs_postprocessing(syn_sig,
  574.   &(OutputSignal[0][sbfrm_ctr*sbfrm_size_bws]),
  575.   int_ap_bws+lpc_order_bws*sbfrm_ctr,
  576.   lpc_order_bws, sbfrm_size_bws,
  577.   bws_delay[sbfrm_ctr],
  578.   bws_adpt_gain[sbfrm_ctr]);
  579.   } else {
  580.             for(kk=0; kk < sbfrm_size_bws; kk++)
  581.       OutputSignal[0][sbfrm_ctr*sbfrm_size_bws+kk] = syn_sig[kk];
  582.   }
  583. }
  584. FREE( syn_sig );
  585.       } else {
  586.         if(( syn_sig = (float *)malloc((unsigned int)sbfrm_size * sizeof(float))) == NULL ){
  587.   fprintf(stderr, "MALLOC FAILURE in abs_decoder  n");
  588.   exit(1);
  589. }
  591. for (sbfrm_ctr = 0; sbfrm_ctr < n_subframes; sbfrm_ctr++) {
  592.   celp_lpc_synthesis_filter(dec_sig+sbfrm_size*sbfrm_ctr,
  593.     syn_sig,
  594.     int_ap+lpc_order*sbfrm_ctr,
  595.     lpc_order, sbfrm_size, PHI_Priv);
  596.   if (postfilter) {
  597.     nb_abs_postprocessing(syn_sig,
  598.   &(OutputSignal[0][sbfrm_ctr*sbfrm_size]),
  599.   int_ap+lpc_order*sbfrm_ctr,
  600.   lpc_order, sbfrm_size,
  601.   acb_delay[sbfrm_ctr],
  602.   adaptive_gain[sbfrm_ctr]);
  603.   } else {
  604.             for(kk=0; kk < sbfrm_size; kk++)
  605.       OutputSignal[0][sbfrm_ctr*sbfrm_size+kk] = syn_sig[kk];
  606.   }
  607. }
  608. FREE( syn_sig );
  609.       }
  611.      FREE ( dec_sig );
  612.       FREE ( bws_mp_sig );
  613.       FREE ( acb_delay );
  614.       FREE ( adaptive_gain );
  615.       if (BandwidthScalabilityMode == ON) {
  616. FREE ( dec_sig_bws );
  617. FREE ( bws_delay );
  618. FREE ( bws_adpt_gain );
  619.       }
  620.     }
  622.     /* -----------------------------------------------------------------*/
  623.     /* Free   Arrays for Frame processing                               */
  624.     /* -----------------------------------------------------------------*/
  625.     FREE ( int_ap );
  626.     FREE ( shape_indices );
  627.     FREE ( gain_indices );
  628.     FREE ( indices );
  629.     
  630.     if (SampleRateMode == fs8kHz) {
  631.       if ( BandwidthScalabilityMode == ON ) {
  632. FREE ( int_ap_bws );
  633. FREE ( shape_indices_bws );
  634. FREE ( gain_indices_bws );
  635. FREE ( indices_bws );
  636. FREE ( bws_nb_acb_index );
  637.       }
  638.     }
  640.     /* ----------------------------------------------------------------*/
  641.     /* Report on the current frame count                               */
  642.     /* ----------------------------------------------------------------*/
  643.     frame_ctr++;
  644.     if (frame_ctr % 10 == 0)
  645.     {
  646.       if (CELPdecDebugLevel) { /* HP 971120 */
  647.         fprintf(stderr, "Frame Counter: %ld r", frame_ctr);
  648.       }
  649.     }
  651. }
  653. /*======================================================================*/
  654. /*   Function Definition: PHI_Postfilter                                */
  655. /*======================================================================*/
  656. static void PHI_Postfilter
  657. (
  658.     const long flag                      /* In: Postfilter On/Off flag  */
  659. )
  660. {
  661.     postfilter = flag;
  662. }
  664. /*======================================================================*/
  665. /*   Function Definition:celp_initialisation_decoder                    */
  666. /*======================================================================*/
  667. void celp_initialisation_decoder
  668. (
  669. BsBitStream *hdrStream,           /* In: Bitstream                     */
  670. long     bit_rate,                  /* in: bit rate */
  671. long     complexity_level,               /* In: complexity level decoder*/
  672. long     reduced_order,                  /* In: reduced order decoder   */
  673. long     DecEnhStage,
  674. long     DecBwsMode,
  675. long     PostFilterSW,
  676. long     *frame_size,                    /* Out: frame size             */
  677. long     *n_subframes,                   /* Out: number of  subframes   */
  678. long     *sbfrm_size,                    /* Out: subframe size          */ 
  679. long     *lpc_order,                     /* Out: LP analysis order      */
  680. long     *num_lpc_indices,               /* Out: number of LPC indices  */
  681. long     *num_shape_cbks,                /* Out: number of Shape Codeb. */    
  682. long     *num_gain_cbks,                 /* Out: number of Gain Codeb.  */    
  683. long     **org_frame_bit_allocation,     /* Out: bit num. for each index*/
  684. long     * ExcitationMode,               /* Out: Excitation Mode     */
  685. long     * SampleRateMode,               /* Out: SampleRate Mode     */
  686. long     * QuantizationMode,             /* Out: Type of Quantization */
  687. long     * FineRateControl,              /* Out: Fine Rate Control switch*/
  688. long     * LosslessCodingMode,           /* Out: Lossless Coding Mode   */
  689. long     * RPE_configuration,             /* Out: Wideband configuration */
  690. long     * Wideband_VQ,               /* Out: Wideband VQ mode */
  691. long     * MPE_Configuration,             /* Out: Narrowband configuration*/
  692. long     * NumEnhLayers,              /* Out: Number of Enhancement Layers*/
  693. long     * BandwidthScalabilityMode,     /* Out: bandwidth switch     */
  694. long     * BWS_configuration,            /* Out: BWS_configuration */
  695. void  **InstanceContext,  /* Out: handle to initialised instance context */
  696. int      mp4ffFlag
  697. )
  698. {
  700.    INST_CONTEXT_LPC_DEC_TYPE *InstCtxt;
  701.    frame_ctr = 0;   /* Frame Counter                   */
  703.    postfilter = 0;           /* Postfilter switch               */
  704.    prev_Qlsp_coefficients = NULL; /* previous quantized LSP coeff.   */
  706.    buf_Qlsp_coefficients_bws = NULL; /* current quantized LSP coeff. */
  707.    prev_Qlsp_coefficients_bws = NULL;/* previous quantized LSP coeff. */
  709.     /* -----------------------------------------------------------------*/
  710.     /* Create & initialise private storage for instance context         */
  711.     /* -----------------------------------------------------------------*/
  712.     if (( InstCtxt = (INST_CONTEXT_LPC_DEC_TYPE*)malloc(sizeof(INST_CONTEXT_LPC_DEC_TYPE))) == NULL )
  713.     {
  714.       fprintf(stderr, "MALLOC FAILURE in celp_initialisation_decoder  n");
  715.       exit(1);
  716.     }
  718.     if (( InstCtxt->PHI_Priv = (PHI_PRIV_TYPE*)malloc(sizeof(PHI_PRIV_TYPE))) == NULL )
  719.     {
  720.       fprintf(stderr, "MALLOC FAILURE in celp_initialisation_decoder  n");
  721.       exit(1);
  722.     }
  723.     PHI_Init_Private_Data(InstCtxt->PHI_Priv);
  725.     *InstanceContext = InstCtxt;
  727.     /* -----------------------------------------------------------------*/
  728.     /*                                                                  */
  729.     /* -----------------------------------------------------------------*/
  730.   
  731.     postfilter = PostFilterSW;
  732.     
  733.     /* -----------------------------------------------------------------*/
  734.     /* Read bitstream header                                            */
  735.     /* -----------------------------------------------------------------*/ 
  736.     /* read from object descriptor */
  738.     if (mp4ffFlag==0) 
  739.       read_celp_bitstream_header(hdrStream, ExcitationMode, SampleRateMode, 
  740.                                QuantizationMode, FineRateControl, LosslessCodingMode,
  741.                                RPE_configuration, Wideband_VQ, MPE_Configuration,
  742.                                NumEnhLayers, BandwidthScalabilityMode, BWS_configuration);
  745.     if (*ExcitationMode == RegularPulseExc)
  746.     {
  747. if (*SampleRateMode == fs8kHz)
  748. {
  749.     fprintf (stderr, "Combination of RPE + 8 kHz sampling rate not supported.n");
  750.     exit (1);
  751. }
  752.     
  753. /* -----------------------------------------------------------------*/
  754. /*Check if a bit rate is a set of allowed bit rates                 */
  755. /* -----------------------------------------------------------------*/ 
  756. if (*RPE_configuration == 0)
  757. {
  758. *frame_size = FIFTEEN_MS;
  759. *n_subframes = 6;        
  760. }
  761. else
  762. if (*RPE_configuration == 1)
  763. {
  764. *frame_size  = TEN_MS;
  765. *n_subframes = 4;        
  766. }
  767. else
  768. if (*RPE_configuration == 2)
  769. {
  770. *frame_size  = FIFTEEN_MS;
  771. *n_subframes = 8;
  772. }
  773. else
  774. if (*RPE_configuration == 3)
  775. {
  776. *frame_size  = FIFTEEN_MS;
  777. *n_subframes = 10;
  778. }
  779. else
  780. {
  781. fprintf(stderr, "ERROR: Illegal RPE Configurationn");
  782. exit(1); 
  783. }
  785. *sbfrm_size          = (*frame_size)/(*n_subframes);
  787. *num_shape_cbks      = 2;     
  788. *num_gain_cbks       = 2;     
  790. *lpc_order       = ORDER_LPC_16;
  791. *num_lpc_indices = N_INDICES_VQ16;
  793. PHI_init_excitation_generation( Lmax, *sbfrm_size, *RPE_configuration, InstCtxt->PHI_Priv );
  794. PHI_InitLpcAnalysisDecoder(ORDER_LPC_16, ORDER_LPC_8, InstCtxt->PHI_Priv);
  795. PHI_InitPostProcessor(*lpc_order, InstCtxt->PHI_Priv );
  797. *org_frame_bit_allocation = PHI_init_bit_allocation(*SampleRateMode, *RPE_configuration,
  798.     *QuantizationMode, *LosslessCodingMode,
  799.     *FineRateControl, *num_lpc_indices,
  800.     *n_subframes, *num_shape_cbks, *num_gain_cbks); 
  801.    }
  802.  
  803.    if (*ExcitationMode == MultiPulseExc) {
  804.      if (*SampleRateMode == fs8kHz) {
  805.        int i, j;
  806.        long ctr;
  808.        num_enhstages = *NumEnhLayers;
  809.        dec_enhstages = DecEnhStage;
  810.        dec_bwsmode = DecBwsMode;
  812.        if ( *MPE_Configuration >= 0 && *MPE_Configuration < 3 ) {
  813.  frame_size_nb = NEC_FRAME40MS;
  814.  *n_subframes = NEC_NSF4;
  815.        }
  816.        if ( *MPE_Configuration >= 3 && *MPE_Configuration < 6 ) {
  817.  frame_size_nb = NEC_FRAME30MS;
  818.  *n_subframes = NEC_NSF3;
  819.        }
  820.        if ( *MPE_Configuration >= 6 && *MPE_Configuration < 13 ) {
  821.  frame_size_nb = NEC_FRAME20MS;
  822.  *n_subframes = NEC_NSF2;
  823.        }
  824.        if ( *MPE_Configuration >= 13 && *MPE_Configuration < 22 ) {
  825.  frame_size_nb = NEC_FRAME20MS;
  826.  *n_subframes = NEC_NSF4;
  827.        }
  828.        if ( *MPE_Configuration >= 22 && *MPE_Configuration < 27 ) {
  829.  frame_size_nb = NEC_FRAME10MS;
  830.  *n_subframes = NEC_NSF2;
  831.        }
  832.        if ( *MPE_Configuration == 27 ) {
  833.  frame_size_nb = NEC_FRAME30MS;
  834.  *n_subframes = NEC_NSF4;
  835.        }
  836.        if ( *MPE_Configuration > 27 ) {
  837.  fprintf(stderr,"Error: Illegal BitRate configuration.n");
  838.  exit(1); 
  839.        }
  841.        *sbfrm_size = frame_size_nb/(*n_subframes);
  842.        *lpc_order = NEC_LPC_ORDER;
  843.        *num_shape_cbks = NEC_NUM_SHAPE_CBKS;
  844.        *num_gain_cbks = NEC_NUM_GAIN_CBKS;
  845.        if (*QuantizationMode == ScalarQuantizer) {
  846.  *num_lpc_indices = 4;
  847.        } else {
  848.  *num_lpc_indices = PAN_NUM_LPC_INDICES;
  849.        }
  851.        num_indices = NEC_NUM_OTHER_INDICES + PAN_NUM_LPC_INDICES
  852.  + (num_enhstages + 1) * (*n_subframes) *
  853.    (NEC_NUM_SHAPE_CBKS+NEC_NUM_GAIN_CBKS);
  855.        switch ( *MPE_Configuration ) {
  856.        case 0:
  857.  mp_pos_bits = 14; mp_sgn_bits =  3; break;
  858.        case 1:
  859.  mp_pos_bits = 17; mp_sgn_bits =  4; break;
  860.        case 2:
  861.  mp_pos_bits = 20; mp_sgn_bits =  5; break;
  862.        case 3:
  863.  mp_pos_bits = 20; mp_sgn_bits =  5; break;
  864.        case 4:
  865.  mp_pos_bits = 22; mp_sgn_bits =  6; break;
  866.        case 5:
  867.  mp_pos_bits = 24; mp_sgn_bits =  7; break;
  868.        case 6:
  869.  mp_pos_bits = 22; mp_sgn_bits =  6; break;
  870.        case 7:
  871.  mp_pos_bits = 24; mp_sgn_bits =  7; break;
  872.        case 8:
  873.  mp_pos_bits = 26; mp_sgn_bits =  8; break;
  874.        case 9:
  875.  mp_pos_bits = 28; mp_sgn_bits =  9; break;
  876.        case 10:
  877.  mp_pos_bits = 30; mp_sgn_bits = 10; break;
  878.        case 11:
  879.  mp_pos_bits = 31; mp_sgn_bits = 11; break;
  880.        case 12:
  881.  mp_pos_bits = 32; mp_sgn_bits = 12; break;
  882.        case 13:
  883.  mp_pos_bits = 13; mp_sgn_bits =  4; break;
  884.        case 14:
  885.  mp_pos_bits = 15; mp_sgn_bits =  5; break;
  886.        case 15:
  887.  mp_pos_bits = 16; mp_sgn_bits =  6; break;
  888.        case 16:
  889.  mp_pos_bits = 17; mp_sgn_bits =  7; break;
  890.        case 17:
  891.  mp_pos_bits = 18; mp_sgn_bits =  8; break;
  892.        case 18:
  893.  mp_pos_bits = 19; mp_sgn_bits =  9; break;
  894.        case 19:
  895.  mp_pos_bits = 20; mp_sgn_bits =  10; break;
  896.        case 20:
  897.  mp_pos_bits = 20; mp_sgn_bits =  11; break;
  898.        case 21:
  899.  mp_pos_bits = 20; mp_sgn_bits =  12; break;
  900.        case 22:
  901.  mp_pos_bits = 18; mp_sgn_bits =  8; break;
  902.        case 23:
  903.  mp_pos_bits = 19; mp_sgn_bits =  9; break;
  904.        case 24:
  905.  mp_pos_bits = 20; mp_sgn_bits =  10; break;
  906.        case 25:
  907.  mp_pos_bits = 20; mp_sgn_bits =  11; break;
  908.        case 26:
  909.  mp_pos_bits = 20; mp_sgn_bits =  12; break;
  910.        case 27:
  911.  mp_pos_bits = 19; mp_sgn_bits =  6; break;
  912.        }
  914.        if ( *sbfrm_size == (NEC_FRAME20MS/NEC_NSF4) ) {
  915.  enh_pos_bits = NEC_BIT_ENH_POS40_2;
  916.  enh_sgn_bits = NEC_BIT_ENH_SGN40_2;
  917.        } else {
  918.  enh_pos_bits = NEC_BIT_ENH_POS80_4;
  919.  enh_sgn_bits = NEC_BIT_ENH_SGN80_4;
  920.        }
  922.        if (*BandwidthScalabilityMode==ON) {
  923.  frame_size_bws = frame_size_nb * 2;
  924.  n_subframes_bws = frame_size_bws/80;
  925.  sbfrm_size_bws = frame_size_bws / n_subframes_bws;
  926.  lpc_order_bws = NEC_LPC_ORDER_FRQ16;
  928.  num_lpc_indices_bws = NEC_NUM_LPC_INDICES_FRQ16 ;
  929.  num_indices += NEC_NUM_LPC_INDICES_FRQ16 
  930.    + n_subframes_bws * (NEC_NUM_SHAPE_CBKS
  931. +NEC_NUM_GAIN_CBKS);
  932.  switch ( *BWS_configuration ) {
  933.  case 0:
  934.    bws_pos_bits = 22; bws_sgn_bits = 6; break;
  935.  case 1:
  936.    bws_pos_bits = 26; bws_sgn_bits = 8; break;
  937.  case 2:
  938.    bws_pos_bits = 30; bws_sgn_bits =10; break;
  939.  case 3:
  940.    bws_pos_bits = 32; bws_sgn_bits =12; break;
  941.  }
  942.        }
  944.        if ( (*BandwidthScalabilityMode==ON) && (dec_bwsmode) ) {
  945.  *frame_size = frame_size_bws;
  946.        } else {
  947.  *frame_size = frame_size_nb;
  948.        }
  950.        if((*org_frame_bit_allocation=(long *)calloc(num_indices, 
  951.     sizeof(long)))==NULL) {
  952.  fprintf(stderr,"n memory allocation error in initialization_encodern");
  953.  exit(3);
  954.        }
  956.        ctr = 0;
  957.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP22_0;
  958.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP22_1;
  959.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP22_2;
  960.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP22_3;
  961.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP22_4;
  962.        *(*org_frame_bit_allocation+(ctr++)) =  NEC_BIT_MODE;
  963.        *(*org_frame_bit_allocation+(ctr++)) =  NEC_BIT_RMS;
  964.        for ( i = 0; i < *n_subframes; i++ ) {
  965.  *(*org_frame_bit_allocation+(ctr++)) =  NEC_BIT_ACB;
  966.  *(*org_frame_bit_allocation+(ctr++)) =  mp_pos_bits;
  967.  *(*org_frame_bit_allocation+(ctr++)) =  mp_sgn_bits;
  968.  *(*org_frame_bit_allocation+(ctr++)) =  NEC_BIT_GAIN;
  969.        }
  971.        for ( i = 0; i < num_enhstages; i++ ) {
  972.  for ( j = 0; j < *n_subframes; j++ ) {
  973.    *(*org_frame_bit_allocation+(ctr++)) =  0;
  974.    *(*org_frame_bit_allocation+(ctr++)) =  enh_pos_bits;
  975.    *(*org_frame_bit_allocation+(ctr++)) =  enh_sgn_bits;
  976.    *(*org_frame_bit_allocation+(ctr++)) =  NEC_BIT_ENH_GAIN;
  977.  }
  978.        }
  980.        if (*BandwidthScalabilityMode==ON) {
  981.  *(*org_frame_bit_allocation+(ctr++)) = NEC_BIT_LSP1620_0;
  982.  *(*org_frame_bit_allocation+(ctr++)) = NEC_BIT_LSP1620_1;
  983.  *(*org_frame_bit_allocation+(ctr++)) = NEC_BIT_LSP1620_2;
  984.  *(*org_frame_bit_allocation+(ctr++)) = NEC_BIT_LSP1620_3; 
  985.  *(*org_frame_bit_allocation+(ctr++)) = NEC_BIT_LSP1620_4; 
  986.  *(*org_frame_bit_allocation+(ctr++)) = NEC_BIT_LSP1620_5;
  987.  for ( i = 0; i < n_subframes_bws; i++ ) {
  988.    *(*org_frame_bit_allocation+(ctr++)) =  NEC_BIT_ACB_FRQ16;
  989.    *(*org_frame_bit_allocation+(ctr++)) =  bws_pos_bits;
  990.    *(*org_frame_bit_allocation+(ctr++)) =  bws_sgn_bits;
  991.    *(*org_frame_bit_allocation+(ctr++)) =  NEC_BIT_GAIN_FRQ16;
  992.  }
  993.        }
  995.        if((prev_Qlsp_coefficients=(float *)calloc(*lpc_order,
  996.   sizeof(float)))==NULL) {
  997.  fprintf(stderr,"n memory allocation error in initialization_decodern");
  998.  exit(5);
  999.        }
  1001.        for(i=0;i<(*lpc_order);i++) 
  1002.  *(prev_Qlsp_coefficients+i) = (i+1)/(float)((*lpc_order)+1);
  1004.        if (*BandwidthScalabilityMode==ON) {
  1005.  if((buf_Qlsp_coefficients_bws=(float *)calloc(*lpc_order,
  1006.       sizeof(float)))==NULL) {
  1007.    fprintf(stderr,"n memory allocation error in initialization_decodern");
  1008.    exit(5);
  1009.  }
  1011.  if((prev_Qlsp_coefficients_bws=(float *)calloc(lpc_order_bws,
  1012. sizeof(float)))==NULL) {
  1013.    fprintf(stderr,"n memory allocation error in initialization_decodern");
  1014.    exit(5);
  1015.  }
  1016.  for(i=0;i<(lpc_order_bws);i++) 
  1017.    *(prev_Qlsp_coefficients_bws+i) = PAN_PI * (i+1)
  1018.      / (float)(lpc_order_bws+1);
  1019.        }
  1021.        /* submodules for initialization */
  1022.        if ((*BandwidthScalabilityMode==ON)&&(dec_bwsmode)) {
  1023.  PHI_InitLpcAnalysisDecoder(lpc_order_bws, *lpc_order, InstCtxt->PHI_Priv);
  1024.        } else {
  1025.  PHI_InitLpcAnalysisDecoder(*lpc_order, *lpc_order, InstCtxt->PHI_Priv);
  1026.        }
  1027.        if (*LosslessCodingMode == ON) {
  1028.  *num_lpc_indices     = 10;   
  1029.        }
  1030.      }
  1032.      if (*SampleRateMode == fs16kHz) {
  1033.        int i, j;
  1034.        long ctr;
  1036.        num_enhstages = *NumEnhLayers;
  1037.        dec_enhstages = DecEnhStage;
  1039.        if ((*MPE_Configuration>=0) && (*MPE_Configuration<7)) {
  1040.  *frame_size = NEC_FRAME20MS_FRQ16;
  1041.  *n_subframes = NEC_NSF4;
  1042.        } else if((*MPE_Configuration>=8)&&(*MPE_Configuration<16)) {
  1043.  *frame_size = NEC_FRAME20MS_FRQ16;
  1044.  *n_subframes = NEC_NSF8;
  1045.        } else if((*MPE_Configuration>=16)&&(*MPE_Configuration<23)) {
  1046.  *frame_size = NEC_FRAME10MS_FRQ16;
  1047.  *n_subframes = NEC_NSF2;
  1048.        } else if((*MPE_Configuration>=24)&&(*MPE_Configuration<32)) {
  1049.  *frame_size = NEC_FRAME10MS_FRQ16;
  1050.  *n_subframes = NEC_NSF4;
  1051.        } else {
  1052.  fprintf(stderr,"Error: Illegal BitRate configuration.n");
  1053.  exit(1); 
  1054.        }
  1056.        *sbfrm_size = *frame_size/(*n_subframes);
  1057.        *lpc_order = NEC_LPC_ORDER_FRQ16;
  1058.        *num_shape_cbks = NEC_NUM_SHAPE_CBKS;
  1059.        *num_gain_cbks = NEC_NUM_GAIN_CBKS;
  1060.        *num_lpc_indices = PAN_NUM_LPC_INDICES_W;
  1061.        
  1062.        num_indices = NEC_NUM_OTHER_INDICES + PAN_NUM_LPC_INDICES_W
  1063.  + (num_enhstages + 1) * (*n_subframes) *
  1064.    (NEC_NUM_SHAPE_CBKS+NEC_NUM_GAIN_CBKS);
  1066.        switch ( *MPE_Configuration ) {
  1067.        case 0:
  1068.  mp_pos_bits = 20; mp_sgn_bits =  5; break;
  1069.        case 1:
  1070.  mp_pos_bits = 22; mp_sgn_bits =  6; break;
  1071.        case 2:
  1072.  mp_pos_bits = 24; mp_sgn_bits =  7; break;
  1073.        case 3:
  1074.  mp_pos_bits = 26; mp_sgn_bits =  8; break;
  1075.        case 4:
  1076.  mp_pos_bits = 28; mp_sgn_bits =  9; break;
  1077.        case 5:
  1078.  mp_pos_bits = 30; mp_sgn_bits =  10; break;
  1079.        case 6:
  1080.  mp_pos_bits = 31; mp_sgn_bits =  11; break;
  1081.        case 7:
  1082.  break;
  1083.        case 8:
  1084.  mp_pos_bits = 11; mp_sgn_bits =  3; break;
  1085.        case 9:
  1086.  mp_pos_bits = 13; mp_sgn_bits =  4; break;
  1087.        case 10:
  1088.  mp_pos_bits = 15; mp_sgn_bits =  5; break;
  1089.        case 11:
  1090.  mp_pos_bits = 16; mp_sgn_bits =  6; break;
  1091.        case 12:
  1092.  mp_pos_bits = 17; mp_sgn_bits =  7; break;
  1093.        case 13:
  1094.  mp_pos_bits = 18; mp_sgn_bits =  8; break;
  1095.        case 14:
  1096.  mp_pos_bits = 19; mp_sgn_bits =  9; break;
  1097.        case 15:
  1098.  mp_pos_bits = 20; mp_sgn_bits =  10; break;
  1099.        case 16:
  1100.  mp_pos_bits = 20; mp_sgn_bits =  5; break;
  1101.        case 17:
  1102.  mp_pos_bits = 22; mp_sgn_bits =  6; break;
  1103.        case 18:
  1104.  mp_pos_bits = 24; mp_sgn_bits =  7; break;
  1105.        case 19:
  1106.  mp_pos_bits = 26; mp_sgn_bits =  8; break;
  1107.        case 20:
  1108.  mp_pos_bits = 28; mp_sgn_bits =  9; break;
  1109.        case 21:
  1110.  mp_pos_bits = 30; mp_sgn_bits =  10; break;
  1111.        case 22:
  1112.  mp_pos_bits = 31; mp_sgn_bits =  11; break;
  1113.        case 23:
  1114.  break;
  1115.        case 24:
  1116.  mp_pos_bits = 11; mp_sgn_bits =  3; break;
  1117.        case 25:
  1118.  mp_pos_bits = 13; mp_sgn_bits =  4; break;
  1119.        case 26:
  1120.  mp_pos_bits = 15; mp_sgn_bits =  5; break;
  1121.        case 27:
  1122.  mp_pos_bits = 16; mp_sgn_bits =  6; break;
  1123.        case 28:
  1124.  mp_pos_bits = 17; mp_sgn_bits =  7; break;
  1125.        case 29:
  1126.  mp_pos_bits = 18; mp_sgn_bits =  8; break;
  1127.        case 30:
  1128.  mp_pos_bits = 19; mp_sgn_bits =  9; break;
  1129.        case 31:
  1130.  mp_pos_bits = 20; mp_sgn_bits =  10; break;
  1131.        }
  1133.        if ( *sbfrm_size == NEC_SBFRM_SIZE40 ) {
  1134.  enh_pos_bits = NEC_BIT_ENH_POS40_2;
  1135.  enh_sgn_bits = NEC_BIT_ENH_SGN40_2;
  1136.        } else {
  1137.  enh_pos_bits = NEC_BIT_ENH_POS80_4;
  1138.  enh_sgn_bits = NEC_BIT_ENH_SGN80_4;
  1139.        }
  1141.        if((*org_frame_bit_allocation=(long *)calloc(num_indices, 
  1142.     sizeof(long)))==NULL) {
  1143.  fprintf(stderr,"n memory allocation error in initialization_encodern");
  1144.  exit(3);
  1145.        }
  1147.        ctr = 0;
  1148.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP_WL_0;
  1149.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP_WL_1;
  1150.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP_WL_2;
  1151.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP_WL_3;
  1152.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP_WL_4;
  1153.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP_WU_0;
  1154.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP_WU_1;
  1155.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP_WU_2;
  1156.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP_WU_3;
  1157.        *(*org_frame_bit_allocation+(ctr++)) =  PAN_BIT_LSP_WU_4;
  1158.        *(*org_frame_bit_allocation+(ctr++)) =  NEC_BIT_MODE;
  1159.        *(*org_frame_bit_allocation+(ctr++)) =  NEC_BIT_RMS;
  1160.        for ( i = 0; i < *n_subframes; i++ ) {
  1161.  *(*org_frame_bit_allocation+(ctr++)) =  NEC_ACB_BIT_WB;
  1162.  *(*org_frame_bit_allocation+(ctr++)) =  mp_pos_bits;
  1163.  *(*org_frame_bit_allocation+(ctr++)) =  mp_sgn_bits;
  1164.  *(*org_frame_bit_allocation+(ctr++)) =  NEC_BIT_GAIN_WB;
  1165.        }
  1167.        for ( i = 0; i < num_enhstages; i++ ) {
  1168.  for ( j = 0; j < *n_subframes; j++ ) {
  1169.    *(*org_frame_bit_allocation+(ctr++)) =  0;
  1170.    *(*org_frame_bit_allocation+(ctr++)) =  enh_pos_bits;
  1171.    *(*org_frame_bit_allocation+(ctr++)) =  enh_sgn_bits;
  1172.    *(*org_frame_bit_allocation+(ctr++)) =  NEC_BIT_ENH_GAIN;
  1173.  }
  1174.        }
  1176.        if((prev_Qlsp_coefficients=(float *)calloc(*lpc_order,
  1177.   sizeof(float)))==NULL) {
  1178.  fprintf(stderr,"n memory allocation error in initialization_decodern");
  1179.  exit(5);
  1180.        }
  1182.        for(i=0;i<(*lpc_order);i++) 
  1183.  *(prev_Qlsp_coefficients+i) = (i+1)/(float)((*lpc_order)+1);
  1185.        /* submodules for initialization */
  1186.        PHI_InitLpcAnalysisDecoder(*lpc_order, *lpc_order, InstCtxt->PHI_Priv);
  1187.      }
  1188.    }
  1189. }
  1191. /*======================================================================*/
  1192. /*   Function Definition: celp_close_decoder                            */
  1193. /*======================================================================*/
  1194. void celp_close_decoder
  1195. (
  1196.    long ExcitationMode,
  1197.    long SampleRateMode,
  1198.    long BandwidthScalabilityMode,
  1199.    long frame_bit_allocation[],         /* In: bit num. for each index */
  1200.    void **InstanceContext               /* In/Out: handle to instance context */
  1201. )
  1202. {
  1203.   INST_CONTEXT_LPC_DEC_TYPE *InstCtxt;
  1204.   PHI_PRIV_TYPE *PHI_Priv;
  1205.   
  1206.   /* -----------------------------------------------------------------*/
  1207.   /* Set up pointers to private data                                  */
  1208.   /* -----------------------------------------------------------------*/
  1209.   PHI_Priv = ((INST_CONTEXT_LPC_DEC_TYPE *) *InstanceContext)->PHI_Priv;
  1211.   /* -----------------------------------------------------------------*/
  1212.   /*                                                                  */
  1213.   /* -----------------------------------------------------------------*/
  1214.  
  1216.   if (ExcitationMode == RegularPulseExc)
  1217.   {
  1218.    PHI_ClosePostProcessor(PHI_Priv);
  1219.      PHI_close_excitation_generation(PHI_Priv);
  1220.      PHI_FreeLpcAnalysisDecoder(PHI_Priv);
  1221.       PHI_free_bit_allocation(frame_bit_allocation);
  1222.   }
  1224.   if (ExcitationMode == MultiPulseExc)
  1225.   {
  1226.     if (prev_Qlsp_coefficients != NULL) {
  1227.       FREE(prev_Qlsp_coefficients);
  1228.       prev_Qlsp_coefficients = NULL;
  1229.     }
  1231.   PHI_FreeLpcAnalysisDecoder(PHI_Priv);
  1232. if (BandwidthScalabilityMode == ON)
  1233. {
  1234.   if (buf_Qlsp_coefficients_bws != NULL) {
  1235.     FREE(buf_Qlsp_coefficients_bws);
  1236.     buf_Qlsp_coefficients_bws = NULL;
  1237.   }
  1238.   if (prev_Qlsp_coefficients_bws != NULL) {
  1239.     FREE(prev_Qlsp_coefficients_bws);
  1240.     prev_Qlsp_coefficients_bws = NULL;
  1241.   }
  1242. }
  1243.   }
  1245.     /* -----------------------------------------------------------------*/
  1246.     /* Print Total Frames Processed                                     */
  1247.     /* -----------------------------------------------------------------*/ 
  1248.     if (CELPdecDebugLevel) { /* HP 971120 */
  1249.       fprintf(stderr,"n");
  1250.       fprintf(stderr,"Total Frames:  %ld n", frame_ctr);
  1251.     }
  1253.     /* -----------------------------------------------------------------*/
  1254.     /* Dispose of private storage for instance context                  */
  1255.     /* -----------------------------------------------------------------*/
  1256.     InstCtxt = (INST_CONTEXT_LPC_DEC_TYPE *)*InstanceContext;
  1257.     if (InstCtxt->PHI_Priv != NULL) {
  1258.       FREE(InstCtxt->PHI_Priv);
  1259.       InstCtxt->PHI_Priv = NULL;
  1260.     }
  1261.     FREE(InstCtxt);
  1262.     *InstanceContext = NULL;
  1264. }
  1266. /*======================================================================*/
  1267. /*      H I S T O R Y                                                   */
  1268. /*======================================================================*/
  1269. /* 01-09-96 R. Taori  Initial Version                                   */
  1270. /* 18-09-96 R. Taori  Brought in line with MPEG-4 Interface             */
  1271. /* 05-05-98 R. Funken Brought in line with MPEG-4 FCD: 3 complexity levels */