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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

huffdec.c：源码内容
  1. /************************* MPEG-2 NBC Audio Decoder **************************
  2.  *                                                                           *
  3. "This software module was originally developed by
  4. AT&T, Dolby Laboratories, Fraunhofer Gesellschaft IIS and edited by
  5. Yoshiaki Oikawa (Sony Corporation),
  6. Mitsuyuki Hatanaka (Sony Corporation)
  7. in the course of development of the MPEG-2 NBC/MPEG-4 Audio standard ISO/IEC 13818-7,
  8. 14496-1,2 and 3. This software module is an implementation of a part of one or more
  9. MPEG-2 NBC/MPEG-4 Audio tools as specified by the MPEG-2 NBC/MPEG-4
  10. Audio standard. ISO/IEC  gives users of the MPEG-2 NBC/MPEG-4 Audio
  11. standards free license to this software module or modifications thereof for use in
  12. hardware or software products claiming conformance to the MPEG-2 NBC/MPEG-4
  13. Audio  standards. Those intending to use this software module in hardware or
  14. software products are advised that this use may infringe existing patents.
  15. The original developer of this software module and his/her company, the subsequent
  16. editors and their companies, and ISO/IEC have no liability for use of this software
  17. module or modifications thereof in an implementation. Copyright is not released for
  18. non MPEG-2 NBC/MPEG-4 Audio conforming products.The original developer
  19. retains full right to use the code for his/her  own purpose, assign or donate the
  20. code to a third party and to inhibit third party from using the code for non
  21. MPEG-2 NBC/MPEG-4 Audio conforming products. This copyright notice must
  22. be included in all copies or derivative works."
  23. Copyright(c)1996.
  24.  *                                                                           *
  25.  ****************************************************************************/
  26. /*
  27.  * $Id: huffdec.c,v 1.6 2002/01/09 22:25:41 wmay Exp $
  28.  */
  30. #ifdef WIN32
  31. #define WIN32_MEAN_AND_LEAN
  32. #include <windows.h>
  33. #endif
  34. #include <math.h>
  35. #include "all.h"
  36. #include "port.h"
  37. #include "bits.h"
  38. #include "util.h"
  41. // wmay - add statics
  42. static int extension_payload(faacDecHandle hDecoder, int cnt, byte *data);
  43. static int getescape(faacDecHandle hDecoder, int q);
  44. static void getgroup(faacDecHandle hDecoder, Info *info, byte *group);
  45. static int getics(faacDecHandle hDecoder, Info *info, int common_window, byte *win, byte *wshape,
  46.    byte *group, byte *max_sfb, int *lpflag, int *prstflag,
  47.    byte *cb_map, Float *coef, int *global_gain,
  48.    int *factors,
  49.    NOK_LT_PRED_STATUS *nok_ltp_status,
  50.   TNS_frame_info *tns);
  51. static int get_ics_info(faacDecHandle hDecoder, byte *win, byte *wshape,
  52. byte *group, byte *max_sfb,
  53. int *lpflag, int *prstflag,
  54. NOK_LT_PRED_STATUS *nok_ltp_status,
  55. NOK_LT_PRED_STATUS *nok_ltp_status_right,
  56. int stereo_flag);
  57. static int getmask(faacDecHandle hDecoder, Info *info, byte *group, byte max_sfb, byte *mask);
  58. static void get_sign_bits(faacDecHandle hDecoder, int *q, int n);
  59. static int huffcb(faacDecHandle hDecoder, byte *sect, int *sectbits,
  60.   int tot_sfb, int sfb_per_sbk, byte max_sfb);
  61. static int hufffac(faacDecHandle hDecoder, Info *info, byte *group, int nsect, byte *sect,
  62.    int global_gain, int *factors);
  63. static int huffspec(faacDecHandle hDecoder, Info *info, int nsect, byte *sect,
  64.     int *factors, Float *coef);
  66. void getfill(faacDecHandle hDecoder, byte *data)
  67. {
  68.     int cnt;
  70.     if ((cnt = faad_getbits(&hDecoder->ld, LEN_F_CNT)) == (1<<LEN_F_CNT)-1)
  71.         cnt +=  faad_getbits(&hDecoder->ld, LEN_F_ESC) - 1;
  73.     while (cnt > 0)
  74.         cnt -= extension_payload(hDecoder, cnt, data);
  75. }
  77. int getdata(faacDecHandle hDecoder, int *tag, int *dt_cnt, byte *data_bytes)
  78. {
  79.     int i, align_flag, cnt;
  81.     *tag = faad_getbits(&hDecoder->ld, LEN_TAG);
  82.     align_flag = faad_getbits(&hDecoder->ld, LEN_D_ALIGN);
  84.     if ((cnt = faad_getbits(&hDecoder->ld, LEN_D_CNT)) == (1<<LEN_D_CNT)-1)
  85.         cnt +=  faad_getbits(&hDecoder->ld, LEN_D_ESC);
  87.     *dt_cnt = cnt;
  89.     if (align_flag)
  90.         faad_byte_align(&hDecoder->ld);
  92.     for (i=0; i<cnt; i++)
  93.         data_bytes[i] = faad_getbits(&hDecoder->ld, LEN_BYTE);
  95.     return 0;
  96. }
  98. static int extension_payload(faacDecHandle hDecoder, int cnt, byte *data)
  99. {
  100.     int type, i;
  102.     /* fill bytes should not emulate any EX types below! */
  103.     type = faad_getbits(&hDecoder->ld, LEN_EX_TYPE);
  105.     switch(type) {
  106.     case EX_FILL_DATA:
  107.         faad_getbits(&hDecoder->ld, LEN_NIBBLE);
  108.         for (i=0; i<cnt-1; i++)
  109.             data[i] = faad_getbits(&hDecoder->ld, LEN_BYTE);
  110.         return cnt;
  111.     default:
  112.         faad_getbits(&hDecoder->ld, LEN_NIBBLE);
  113.         for (i=0; i<cnt-1; i++)
  114.             faad_getbits(&hDecoder->ld, LEN_BYTE);
  115.         return cnt;
  116.     }
  117. }
  119. /*
  120.  * read and decode the data for the next 1024 output samples
  121.  * return -1 if there was an error
  122.  */
  123. int huffdecode(faacDecHandle hDecoder, int id, MC_Info *mip, byte *win,
  124.                Wnd_Shape *wshape,
  125.                byte **cb_map, int **factors,
  126.                byte **group, byte *hasmask, byte **mask, byte *max_sfb,
  127.                int **lpflag, int **prstflag,
  128.                NOK_LT_PRED_STATUS **nok_ltp_status,
  129.                TNS_frame_info **tns, Float **coef)
  130. {
  131.     int i, tag, common_window, ch, widx, first=0, last=0;
  133.     int global_gain;  /* not used in this routine */
  134.     Info info;
  136.     tag = faad_getbits(&hDecoder->ld, LEN_TAG);
  138.     switch(id) {
  139.     case ID_SCE:
  140.         common_window = 0;
  141.         break;
  142.     case ID_CPE:
  143.         common_window = faad_get1bit(&hDecoder->ld); /* common_window */
  144.         break;
  145.     default:
  146.         /* CommonWarning("Unknown id"); */
  147.         return(-1);
  148.     }
  150.     if ((ch = chn_config(hDecoder, id, tag, common_window, mip)) < 0)
  151.         return -1;
  153.     switch(id) {
  154.     case ID_SCE:
  155.         widx = mip->ch_info[ch].widx;
  156.         first = ch;
  157.         last = ch;
  158.         hasmask[widx] = 0;
  159.         break;
  160.     case ID_CPE:
  161.         first = ch;
  162.         last = mip->ch_info[ch].paired_ch;
  163.         if (common_window) {
  164.             widx = mip->ch_info[ch].widx;
  165.             if (!get_ics_info(hDecoder, &win[widx], &wshape[widx].this_bk, group[widx],
  166.                 &max_sfb[widx], lpflag[widx], prstflag[widx],
  167.                 nok_ltp_status[widx],nok_ltp_status[mip->ch_info[ch].paired_ch], common_window))
  168.                 return -1;
  170.             hasmask[widx] = getmask(hDecoder, hDecoder->winmap[win[widx]], group[widx],
  171.                 max_sfb[widx], mask[widx]);
  172.         }
  173.         else {
  174.             hasmask[mip->ch_info[first].widx] = 0;
  175.             hasmask[mip->ch_info[last].widx] = 0;
  176.         }
  177.         break;
  178.     }
  180.     for (i=first; i<=last; i++) {
  181.         widx = mip->ch_info[i].widx;
  182.         SetMemory(coef[i], 0, LN2*sizeof(Float));
  184.         if(!getics(hDecoder, &info, common_window, &win[widx], &wshape[widx].this_bk,
  185.             group[widx], &max_sfb[widx], lpflag[widx], prstflag[widx],
  186.             cb_map[i], coef[i], &global_gain, factors[i], nok_ltp_status[widx],
  187.             tns[i]))
  188.             return -1;
  189.     }
  191.     return 0;
  192. }
  194. static int get_ics_info(faacDecHandle hDecoder, byte *win, byte *wshape, byte *group, byte *max_sfb,
  195.                  int *lpflag, int *prstflag, NOK_LT_PRED_STATUS *nok_ltp_status,
  196.                  NOK_LT_PRED_STATUS *nok_ltp_status_right, int stereo_flag)
  197. {
  198.     Info *info;
  199.     int i, j;
  201.     int max_pred_sfb = pred_max_bands(hDecoder);
  203.     faad_get1bit(&hDecoder->ld); /* reserved bit */
  204.     *win = (unsigned char)faad_getbits(&hDecoder->ld, LEN_WIN_SEQ);
  205.     *wshape = (unsigned char)faad_get1bit(&hDecoder->ld); /* window shape */
  206.     if ((info = hDecoder->winmap[*win]) == NULL)
  207.         /* CommonExit(1, "bad window code"); */
  208.         return 0;
  210.     /*
  211.      * max scale factor, scale factor grouping and prediction flags
  212.      */
  213.     prstflag[0] = 0;
  214.     if (info->islong) {
  215.         *max_sfb = (unsigned char)faad_getbits(&hDecoder->ld, LEN_MAX_SFBL);
  216.         group[0] = 1;
  218.         if (hDecoder->mc_info.object_type != AACLTP) {
  219.             if ((lpflag[0] = faad_getbits(&hDecoder->ld, LEN_PRED_PRES))) {
  220.                 if ((prstflag[0] = faad_getbits(&hDecoder->ld, LEN_PRED_RST))) {
  221.                     for(i=1; i<LEN_PRED_RSTGRP+1; i++)
  222.                         prstflag[i] = faad_getbits(&hDecoder->ld, LEN_PRED_RST);
  223.                 }
  224.                 j = ( (*max_sfb < max_pred_sfb) ?
  225.                     *max_sfb : max_pred_sfb ) + 1;
  226.                 for (i = 1; i < j; i++)
  227.                     lpflag[i] = faad_getbits(&hDecoder->ld, LEN_PRED_ENAB);
  228.                 for ( ; i < max_pred_sfb+1; i++)
  229.                     lpflag[i] = 0;
  230.             }
  231.         } else { /* AAC LTP */
  232.             if(faad_get1bit(&hDecoder->ld))
  233.             {
  234.                 nok_lt_decode(hDecoder, *max_sfb, nok_ltp_status->sbk_prediction_used,
  235.                     nok_ltp_status->sfb_prediction_used,
  236.                     &nok_ltp_status->weight,
  237.                     nok_ltp_status->delay);
  239.                 if(stereo_flag)
  240.                     nok_lt_decode(hDecoder, *max_sfb, nok_ltp_status_right->sbk_prediction_used,
  241.                         nok_ltp_status_right->sfb_prediction_used,
  242.                         &nok_ltp_status_right->weight,
  243.                         nok_ltp_status_right->delay);
  244.             } else {
  245.                 nok_ltp_status->sbk_prediction_used[0] = 0;
  246.                 if(stereo_flag)
  247.                     nok_ltp_status_right->sbk_prediction_used[0] = 0;
  248.             }
  249.         }
  250.     } else {
  251.         *max_sfb = (unsigned char)faad_getbits(&hDecoder->ld, LEN_MAX_SFBS);
  252.         getgroup(hDecoder, info, group);
  253.         lpflag[0] = 0;
  254.         nok_ltp_status->sbk_prediction_used[0] = 0;
  255.         if(stereo_flag)
  256.             nok_ltp_status_right->sbk_prediction_used[0] = 0;
  257.     }
  259.     return 1;
  260. }
  262. static void deinterleave(int inptr[], int outptr[], int ngroups,
  263.                   int nsubgroups[], int ncells[], int cellsize[])
  264. {
  265.     int i, j, k, l;
  266.     int *start_inptr, *start_subgroup_ptr, *subgroup_ptr;
  267.     int cell_inc, subgroup_inc;
  269.     start_subgroup_ptr = outptr;
  271.     for (i = 0; i < ngroups; i++)
  272.     {
  273.         cell_inc = 0;
  274.         start_inptr = inptr;
  276.         /* Compute the increment size for the subgroup pointer */
  277.         subgroup_inc = 0;
  278.         for (j = 0; j < ncells[i]; j++) {
  279.             subgroup_inc += cellsize[j];
  280.         }
  282.         /* Perform the deinterleaving across all subgroups in a group */
  283.         for (j = 0; j < ncells[i]; j++)
  284.         {
  285.             subgroup_ptr = start_subgroup_ptr;
  287.             for (k = 0; k < nsubgroups[i]; k++) {
  288.                 outptr = subgroup_ptr + cell_inc;
  289.                 for (l = 0; l < cellsize[j]; l++) {
  290.                     *outptr++ = *inptr++;
  291.                 }
  292.                 subgroup_ptr += subgroup_inc;
  293.             }
  294.             cell_inc += cellsize[j];
  295.         }
  296.         start_subgroup_ptr += (inptr - start_inptr);
  297.     }
  298. }
  300. static void calc_gsfb_table(Info *info, byte *group)
  301. {
  302.     int group_offset;
  303.     int group_idx;
  304.     int offset;
  305.     int *group_offset_p;
  306.     int sfb,len;
  308.     /* first calc the group length*/
  309.     if (info->islong){
  310.         return;
  311.     } else {
  312.         group_offset = 0;
  313.         group_idx =0;
  314.         do  {
  315.             info->group_len[group_idx] = group[group_idx]-group_offset;
  316.             group_offset=group[group_idx];
  317.             group_idx++;
  318.         } while (group_offset<8);
  320.         info->num_groups=group_idx;
  321.         group_offset_p = info->bk_sfb_top;
  322.         offset=0;
  324.         for (group_idx=0;group_idx<info->num_groups;group_idx++){
  325.             len = info->group_len[group_idx];
  326.             for (sfb=0;sfb<info->sfb_per_sbk[group_idx];sfb++){
  327.                 offset += info->sfb_width_128[sfb] * len;
  328.                 *group_offset_p++ = offset;
  329.             }
  330.         }
  331.     }
  332. }
  334. static void getgroup(faacDecHandle hDecoder, Info *info, byte *group)
  335. {
  336.     int i, j, first_short;
  338.     first_short=1;
  339.     for (i = 0; i < info->nsbk; i++) {
  340.         if (info->bins_per_sbk[i] > SN2) {
  341.             /* non-short windows are always their own group */
  342.             *group++ = i+1;
  343.         } else {
  344.             /* only short-window sequences are grouped! */
  345.             if (first_short) {
  346.                 /* first short window is always a new group */
  347.                 first_short=0;
  348.             } else {
  349.                 if((j = faad_get1bit(&hDecoder->ld)) == 0) {
  350.                     *group++ = i;
  351.                 }
  352.             }
  353.         }
  354.     }
  355.     *group = i;
  356. }
  358. /*
  359.  * read a synthesis mask
  360.  *  uses EXTENDED_MS_MASK
  361.  *  and grouped mask
  362.  */
  363. static int getmask(faacDecHandle hDecoder, Info *info, byte *group, byte max_sfb, byte *mask)
  364. {
  365.     int b, i, mp;
  367.     mp = faad_getbits(&hDecoder->ld, LEN_MASK_PRES);
  369.     /* special EXTENDED_MS_MASK cases */
  370.     if(mp == 0) { /* no ms at all */
  371.         return 0;
  372.     }
  373.     if(mp == 2) {/* MS for whole spectrum on, mask bits set to 1 */
  374.         for(b = 0; b < info->nsbk; b = *group++)
  375.             for(i = 0; i < info->sfb_per_sbk[b]; i ++)
  376.                 *mask++ = 1;
  377.             return 2;
  378.     }
  380.     /* otherwise get mask */
  381.     for(b = 0; b < info->nsbk; b = *group++){
  382.         for(i = 0; i < max_sfb; i ++) {
  383.             *mask = (byte)faad_get1bit(&hDecoder->ld);
  384.             mask++;
  385.         }
  386.         for( ; i < info->sfb_per_sbk[b]; i++){
  387.             *mask = 0;
  388.             mask++;
  389.         }
  390.     }
  391.     return 1;
  392. }
  394. static void clr_tns( Info *info, TNS_frame_info *tns_frame_info )
  395. {
  396.     int s;
  398.     tns_frame_info->n_subblocks = info->nsbk;
  399.     for (s=0; s<tns_frame_info->n_subblocks; s++)
  400.         tns_frame_info->info[s].n_filt = 0;
  401. }
  403. static int get_tns(faacDecHandle hDecoder, Info *info, TNS_frame_info *tns_frame_info)
  404. {
  405.     int f, t, top, res, res2, compress;
  406.     int short_flag, s;
  407.     int *sp, tmp, s_mask, n_mask;
  408.     TNSfilt *tns_filt;
  409.     TNSinfo *tns_info;
  410.     static int sgn_mask[] = { 0x2, 0x4, 0x8 };
  411.     static int neg_mask[] = { 0xfffc, 0xfff8, 0xfff0 };
  414.     short_flag = (!info->islong);
  415.     tns_frame_info->n_subblocks = info->nsbk;
  417.     for (s=0; s<tns_frame_info->n_subblocks; s++) {
  418.         tns_info = &tns_frame_info->info[s];
  420.         if (!(tns_info->n_filt = faad_getbits(&hDecoder->ld, short_flag ? 1 : 2)))
  421.             continue;
  423.         tns_info -> coef_res = res = faad_get1bit(&hDecoder->ld) + 3;
  424.         top = info->sfb_per_sbk[s];
  425.         tns_filt = &tns_info->filt[ 0 ];
  426.         for (f=tns_info->n_filt; f>0; f--)  {
  427.             tns_filt->stop_band = top;
  428.             top = tns_filt->start_band = top - faad_getbits(&hDecoder->ld, short_flag ? 4 : 6);
  429.             tns_filt->order = faad_getbits(&hDecoder->ld, short_flag ? 3 : 5);
  431.             if (tns_filt->order)  {
  432.                 tns_filt->direction = faad_get1bit(&hDecoder->ld);
  433.                 compress = faad_get1bit(&hDecoder->ld);
  435.                 res2 = res - compress;
  436.                 s_mask = sgn_mask[ res2 - 2 ];
  437.                 n_mask = neg_mask[ res2 - 2 ];
  439.                 sp = tns_filt->coef;
  440.                 for (t=tns_filt->order; t>0; t--)  {
  441.                     tmp = (short)faad_getbits(&hDecoder->ld, res2);
  442.                     *sp++ = (tmp & s_mask) ? (short)(tmp | n_mask) : (short)tmp;
  443.                 }
  444.             }
  445.             tns_filt++;
  446.         }
  447.     }   /* subblock loop */
  449.     return 1;
  450. }
  452. static void get_pulse_nc(faacDecHandle hDecoder, struct Pulse_Info *pulse_info)
  453. {
  454.     int i;
  456.     pulse_info->number_pulse = faad_getbits(&hDecoder->ld, LEN_NPULSE);
  457.     pulse_info->pulse_start_sfb = faad_getbits(&hDecoder->ld, LEN_PULSE_ST_SFB);
  459.     for(i = 0; i < pulse_info->number_pulse + 1; i++) {
  460.         pulse_info->pulse_offset[i] = faad_getbits(&hDecoder->ld, LEN_POFF);
  461.         pulse_info->pulse_amp[i] = faad_getbits(&hDecoder->ld, LEN_PAMP);
  462.     }
  463. }
  465. static void pulse_nc(faacDecHandle hDecoder, int *coef, struct Pulse_Info *pulse_info)
  466. {
  467.     int i, k;
  469.     k = hDecoder->only_long_info.sbk_sfb_top[0][pulse_info->pulse_start_sfb];
  471.     for(i = 0; i <= pulse_info->number_pulse; i++) {
  472.         k += pulse_info->pulse_offset[i];
  473.         if (coef[k]>0)
  474.             coef[k] += pulse_info->pulse_amp[i];
  475.         else
  476.             coef[k] -= pulse_info->pulse_amp[i];
  477.     }
  478. }
  480. static int getics(faacDecHandle hDecoder, Info *info, int common_window, byte *win, byte *wshape,
  481.            byte *group, byte *max_sfb, int *lpflag, int *prstflag,
  482.            byte *cb_map, Float *coef, int *global_gain,
  483.            int *factors,
  484.            NOK_LT_PRED_STATUS *nok_ltp_status,
  485.            TNS_frame_info *tns)
  486. {
  487.     int nsect, i, cb, top, bot, tot_sfb;
  488.     byte sect[ 2*(MAXBANDS+1) ];
  490.     memset(sect, 0, sizeof(sect));
  492.     /*
  493.     * global gain
  494.     */
  495.     *global_gain = (short)faad_getbits(&hDecoder->ld, LEN_SCL_PCM);
  497.     if (!common_window) {
  498.         if (!get_ics_info(hDecoder, win, wshape, group, max_sfb, lpflag, prstflag,
  499.             nok_ltp_status, NULL, 0))
  500.             return 0;
  501.     }
  503.     CopyMemory(info, hDecoder->winmap[*win], sizeof(Info));
  505.     /* calculate total number of sfb for this grouping */
  506.     if (*max_sfb == 0) {
  507.         tot_sfb = 0;
  508.     }
  509.     else {
  510.         i=0;
  511.         tot_sfb = info->sfb_per_sbk[0];
  512.         while (group[i++] < info->nsbk) {
  513.             tot_sfb += info->sfb_per_sbk[0];
  514.         }
  515.     }
  517.     /*
  518.     * section data
  519.     */
  520.     nsect = huffcb(hDecoder, sect, info->sectbits, tot_sfb, info->sfb_per_sbk[0], *max_sfb);
  521.     if(nsect==0 && *max_sfb>0)
  522.         return 0;
  524.         /* generate "linear" description from section info
  525.         * stored as codebook for each scalefactor band and group
  526.     */
  527.     if (nsect) {
  528.         bot = 0;
  529.         for (i=0; i<nsect; i++) {
  530.             cb = sect[2*i];
  531.             top = sect[2*i + 1];
  532.             for (; bot<top; bot++)
  533.                 *cb_map++ = cb;
  534.             bot = top;
  535.         }
  536.     }  else {
  537.         for (i=0; i<MAXBANDS; i++)
  538.             cb_map[i] = 0;
  539.     }
  541.     /* calculate band offsets
  542.     * (because of grouping and interleaving this cannot be
  543.     * a constant: store it in info.bk_sfb_top)
  544.     */
  545.     calc_gsfb_table(info, group);
  547.     /*
  548.     * scale factor data
  549.     */
  550.     if(!hufffac(hDecoder, info, group, nsect, sect, *global_gain, factors))
  551.         return 0;
  553.     /*
  554.      *  Pulse coding
  555.      */
  556.     if ((hDecoder->pulse_info.pulse_data_present = faad_get1bit(&hDecoder->ld))) { /* pulse data present */
  557.         if (info->islong) {
  558.             get_pulse_nc(hDecoder, &hDecoder->pulse_info);
  559.         } else {
  560.             /* CommonExit(1,"Pulse data not allowed for short blocks"); */
  561.             return 0;
  562.         }
  563.     }
  565.     /*
  566.     * tns data
  567.     */
  568.     if (faad_get1bit(&hDecoder->ld)) { /* tns present */
  569.         get_tns(hDecoder, info, tns);
  570.     }
  571.     else {
  572.         clr_tns(info, tns);
  573.     }
  575.     if (faad_get1bit(&hDecoder->ld)) { /* gain control present */
  576.         /* CommonExit(1, "Gain control not implemented"); */
  577.         return 0;
  578.     }
  580.     return huffspec(hDecoder, info, nsect, sect, factors, coef);
  581. }
  583. /*
  584.  * read the codebook and boundaries
  585.  */
  586. static int huffcb(faacDecHandle hDecoder, byte *sect, int *sectbits,
  587.            int tot_sfb, int sfb_per_sbk, byte max_sfb)
  588. {
  589.     int nsect, n, base, bits, len;
  591.     bits = sectbits[0];
  592.     len = (1 << bits) - 1;
  593.     nsect = 0;
  595.     for(base = 0; base < tot_sfb && nsect < tot_sfb; ) {
  596.         *sect++ = (byte)faad_getbits(&hDecoder->ld, LEN_CB);
  598.         n = faad_getbits(&hDecoder->ld, bits);
  599.         while(n == len && base < tot_sfb) {
  600.             base += len;
  601.             n = faad_getbits(&hDecoder->ld, bits);
  602.         }
  603.         base += n;
  604.         *sect++ = base;
  605.         nsect++;
  607.         /* insert a zero section for regions above max_sfb for each group */
  608.         if ((sect[-1] % sfb_per_sbk) == max_sfb) {
  609.             base += (sfb_per_sbk - max_sfb);
  610.             *sect++ = 0;
  611.             *sect++ = base;
  612.             nsect++;
  613.         }
  614.     }
  616.     if(base != tot_sfb || nsect > tot_sfb)
  617.         return 0;
  619.     return nsect;
  620. }
  622. /*
  623.  * get scale factors
  624.  */
  625. static int hufffac(faacDecHandle hDecoder, Info *info, byte *group, int nsect, byte *sect,
  626.         int global_gain, int *factors)
  627. {
  628.     Huffscl *hcw;
  629.     int i, b, bb, t, n, sfb, top, fac, is_pos;
  630.     int factor_transmitted[MAXBANDS], *fac_trans;
  631.     int noise_pcm_flag = 1;
  632.     int noise_nrg;
  634.     /* clear array for the case of max_sfb == 0 */
  635.     SetMemory(factor_transmitted, 0, MAXBANDS*sizeof(int));
  636.     SetMemory(factors, 0, MAXBANDS*sizeof(int));
  638.     sfb = 0;
  639.     fac_trans = factor_transmitted;
  640.     for(i = 0; i < nsect; i++){
  641.         top = sect[1];      /* top of section in sfb */
  642.         t = sect[0];        /* codebook for this section */
  643.         sect += 2;
  644.         for(; sfb < top; sfb++) {
  645.             fac_trans[sfb] = t;
  646.         }
  647.     }
  649.     /* scale factors are dpcm relative to global gain
  650.     * intensity positions are dpcm relative to zero
  651.     */
  652.     fac = global_gain;
  653.     is_pos = 0;
  654.     noise_nrg = global_gain - NOISE_OFFSET;
  656.     /* get scale factors */
  657.     hcw = bookscl;
  658.     bb = 0;
  659.     for(b = 0; b < info->nsbk; ){
  660.         n = info->sfb_per_sbk[b];
  661.         b = *group++;
  662.         for(i = 0; i < n; i++){
  663.             switch (fac_trans[i]) {
  664.             case ZERO_HCB:      /* zero book */
  665.                 break;
  666.             default:            /* spectral books */
  667.                 /* decode scale factor */
  668.                 t = decode_huff_cw_scl(hDecoder, hcw);
  669.                 fac += t - MIDFAC;    /* 1.5 dB */
  670.                 if(fac >= 2*TEXP || fac < 0)
  671.                     return 0;
  672.                 factors[i] = fac;
  673.                 break;
  674.             case BOOKSCL:       /* invalid books */
  675.                 return 0;
  676.             case INTENSITY_HCB:     /* intensity books */
  677.             case INTENSITY_HCB2:
  678.                 /* decode intensity position */
  679.                 t = decode_huff_cw_scl(hDecoder, hcw);
  680.                 is_pos += t - MIDFAC;
  681.                 factors[i] = is_pos;
  682.                 break;
  683.             case NOISE_HCB:     /* noise books */
  684.                 /* decode noise energy */
  685.                 if (noise_pcm_flag) {
  686.                     noise_pcm_flag = 0;
  687.                     t = faad_getbits(&hDecoder->ld, NOISE_PCM_BITS) - NOISE_PCM_OFFSET;
  688.                 } else
  689.                     t = decode_huff_cw_scl(hDecoder, hcw) - MIDFAC;
  690.                 noise_nrg += t;
  691.                 factors[i] = noise_nrg;
  692.                 break;
  693.             }
  694.         }
  696.         /* expand short block grouping */
  697.         if (!(info->islong)) {
  698.             for(bb++; bb < b; bb++) {
  699.                 for (i=0; i<n; i++) {
  700.                     factors[i+n] = factors[i];
  701.                 }
  702.                 factors += n;
  703.             }
  704.         }
  705.         fac_trans += n;
  706.         factors += n;
  707.     }
  708.     return 1;
  709. }
  711. __inline float esc_iquant(faacDecHandle hDecoder, int q)
  712. {
  713.     if (q > 0) {
  714.         if (q < MAX_IQ_TBL) {
  715.             return((float)hDecoder->iq_exp_tbl[q]);
  716.         } else {
  717.             return((float)pow(q, 4./3.));
  718.         }
  719.     } else {
  720.         q = -q;
  721.         if (q < MAX_IQ_TBL) {
  722.             return((float)(-hDecoder->iq_exp_tbl[q]));
  723.         } else {
  724.             return((float)(-pow(q, 4./3.)));
  725.         }
  726.     }
  727. }
  729. static int huffspec(faacDecHandle hDecoder, Info *info, int nsect, byte *sect,
  730.              int *factors, Float *coef)
  731. {
  732.     Hcb *hcb;
  733.     Huffman *hcw;
  734.     int i, j, k, table, step, stop, bottom, top;
  735.     int *bands, *bandp;
  736.     int *quant, *qp;
  737.     int *tmp_spec;
  738.     int *quantPtr;
  739.     int *tmp_specPtr;
  741.     quant = AllocMemory(LN2*sizeof(int));
  742.     tmp_spec = AllocMemory(LN2*sizeof(int));
  744.     quantPtr = quant;
  745.     tmp_specPtr = tmp_spec;
  747. #ifndef WIN32
  748.     SetMemory(quant, 0, LN2*sizeof(int));
  749. #endif
  751.     bands = info->bk_sfb_top;
  752.     bottom = 0;
  753.     k = 0;
  754.     bandp = bands;
  755.     for(i = nsect; i; i--) {
  756.         table = sect[0];
  757.         top = sect[1];
  758.         sect += 2;
  759.         if( (table == 0) || (table == NOISE_HCB) ||
  760.             (table == INTENSITY_HCB) || (table == INTENSITY_HCB2) ) {
  761.             bandp = bands+top;
  762.             k = bandp[-1];
  763.             bottom = top;
  764.             continue;
  765.         }
  766.         if(table < BY4BOOKS+1) {
  767.             step = 4;
  768.         } else {
  769.             step = 2;
  770.         }
  771.         hcb = &book[table];
  772.         hcw = hcb->hcw;
  773.         qp = quant+k;
  774.         for(j = bottom; j < top; j++) {
  775.             stop = *bandp++;
  776.             while(k < stop) {
  777.                 decode_huff_cw(hDecoder, hcw, qp, hcb);
  779.                 if (!hcb->signed_cb)
  780.                     get_sign_bits(hDecoder, qp, step);
  781.                 if(table == ESCBOOK){
  782.                     qp[0] = getescape(hDecoder, qp[0]);
  783.                     qp[1] = getescape(hDecoder, qp[1]);
  784.                 }
  785.                 qp += step;
  786.                 k += step;
  787.             }
  788.         }
  789.         bottom = top;
  790.     }
  792.     /* pulse coding reconstruction */
  793.     if ((info->islong) && (hDecoder->pulse_info.pulse_data_present))
  794.         pulse_nc(hDecoder, quant, &hDecoder->pulse_info);
  796.     if (!info->islong) {
  797.         deinterleave (quant,tmp_spec,
  798.             (short)info->num_groups,
  799.             info->group_len,
  800.             info->sfb_per_sbk,
  801.             info->sfb_width_128);
  803.         for (i = LN2/16 - 1; i >= 0; --i)
  804.         {
  805.             *quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
  806.             *quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
  807.             *quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
  808.             *quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
  809.             *quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
  810.             *quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
  811.             *quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
  812.             *quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
  813.         }
  814.     }
  816.     /* inverse quantization */
  817.     for (i=0; i<info->bins_per_bk; i++) {
  818.         coef[i] = esc_iquant(hDecoder, quant[i]);
  819.     }
  821.     /* rescaling */
  822.     {
  823.         int sbk, nsbk, sfb, nsfb, fac, top;
  824.         Float *fp, scale;
  826.         i = 0;
  827.         fp = coef;
  828.         nsbk = info->nsbk;
  829.         for (sbk=0; sbk<nsbk; sbk++) {
  830.             nsfb = info->sfb_per_sbk[sbk];
  831.             k=0;
  832.             for (sfb=0; sfb<nsfb; sfb++) {
  833.                 top = info->sbk_sfb_top[sbk][sfb];
  834.                 fac = factors[i++]-SF_OFFSET;
  836.                 if (fac >= 0 && fac < TEXP) {
  837.                     scale = hDecoder->exptable[fac];
  838.                 }
  839.                 else {
  840.                     if (fac == -SF_OFFSET) {
  841.                         scale = 0;
  842.                     }
  843.                     else {
  844.                         scale = (float)pow(2.0,  0.25*fac);
  845.                     }
  846.                 }
  847.                 for ( ; k<top; k++) {
  848.                     *fp++ *= scale;
  849.                 }
  850.             }
  851.         }
  852.     }
  854.     if (quant) FreeMemory(quant);
  855.     if (tmp_spec) FreeMemory(tmp_spec);
  857.     return 1;
  858. }
  861. /*
  862.  * initialize the Hcb structure and sort the Huffman
  863.  * codewords by length, shortest (most probable) first
  864.  */
  865. void hufftab(Hcb *hcb, Huffman *hcw, int dim, int signed_cb)
  866. {
  867.     hcb->dim = dim;
  868.     hcb->signed_cb = signed_cb;
  869.     hcb->hcw = hcw;
  870. }
  872. __inline void decode_huff_cw(faacDecHandle hDecoder, Huffman *h, int *qp, Hcb *hcb)
  873. {
  874.     int i, j;
  875.     unsigned long cw;
  877.     i = h->len;
  878.     cw = faad_getbits_fast(&hDecoder->ld, i);
  880.     while (cw != h->cw)
  881.     {
  882.         h++;
  883.         j = h->len-i;
  884.         if (j!=0) {
  885.             i += j;
  886.             while (j--)
  887.                 cw = (cw<<1)|faad_get1bit(&hDecoder->ld);
  888.         }
  889.     }
  891.     if(hcb->dim == 4)
  892.     {
  893.         qp[0] = h->x;
  894.         qp[1] = h->y;
  895.         qp[2] = h->v;
  896.         qp[3] = h->w;
  897.     } else {
  898.         qp[0] = h->x;
  899.         qp[1] = h->y;
  900.     }
  901. }
  903. __inline int decode_huff_cw_scl(faacDecHandle hDecoder, Huffscl *h)
  904. {
  905.     int i, j;
  906.     long cw;
  908.     i = h->len;
  909.     cw = faad_getbits_fast(&hDecoder->ld, i);
  911.     while ((unsigned long)cw != h->cw)
  912.     {
  913.         h++;
  914.         j = h->len-i;
  915.         if (j!=0) {
  916.             i += j;
  917.             while (j--)
  918.                 cw = (cw<<1)|faad_get1bit(&hDecoder->ld);
  919.         }
  920.     }
  922.     return h->scl;
  923. }
  925. /* get sign bits */
  926. static void get_sign_bits(faacDecHandle hDecoder, int *q, int n)
  927. {
  928.     int i;
  930.     for(i=0; i < n; i++)
  931.     {
  932.         if(q[i])
  933.         {
  934.             if(faad_get1bit(&hDecoder->ld) & 1)
  935.             {
  936.                 /* 1 signals negative, as in 2's complement */
  937.                 q[i] = -q[i];
  938.             }
  939.         }
  940.     }
  941. }
  943. static int getescape(faacDecHandle hDecoder, int q)
  944. {
  945.     int i, off, neg;
  947.     if(q < 0){
  948.         if(q != -16)
  949.             return q;
  950.         neg = 1;
  951.     } else{
  952.         if(q != +16)
  953.             return q;
  954.         neg = 0;
  955.     }
  957.     for(i=4;; i++){
  958.         if(faad_get1bit(&hDecoder->ld) == 0)
  959.             break;
  960.     }
  962.     if(i > 16){
  963.         off = faad_getbits(&hDecoder->ld, i-16) << 16;
  964.         off |= faad_getbits(&hDecoder->ld, 16);
  965.     } else
  966.         off = faad_getbits(&hDecoder->ld, i);
  968.     i = off + (1<<i);
  969.     if(neg)
  970.         i = -i;
  971.     return i;
  972. }