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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
sbr_syntax.c
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：28k
源码类别：

多媒体编程

开发平台：

Visual C++

sbr_syntax.c：源码内容
  1. /*
  2. ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
  3. ** Copyright (C) 2003-2005 M. Bakker, Ahead Software AG, http://www.nero.com
  4. **  
  5. ** This program is free software; you can redistribute it and/or modify
  6. ** it under the terms of the GNU General Public License as published by
  7. ** the Free Software Foundation; either version 2 of the License, or
  8. ** (at your option) any later version.
  9. ** 
  10. ** This program is distributed in the hope that it will be useful,
  11. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. ** GNU General Public License for more details.
  14. ** 
  15. ** You should have received a copy of the GNU General Public License
  16. ** along with this program; if not, write to the Free Software 
  17. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. **
  19. ** Any non-GPL usage of this software or parts of this software is strictly
  20. ** forbidden.
  21. **
  22. ** Software using this code must display the following message visibly in the
  23. ** software:
  24. ** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Ahead Software, www.nero.com"
  25. ** in, for example, the about-box or help/startup screen.
  26. **
  27. ** Commercial non-GPL licensing of this software is possible.
  28. ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
  29. **
  30. ** $Id: sbr_syntax.c,v 1.3 2005/11/01 21:41:43 gabest Exp $
  31. **/
  33. #include "common.h"
  34. #include "structs.h"
  36. #ifdef SBR_DEC
  38. #include "sbr_syntax.h"
  39. #include "syntax.h"
  40. #include "sbr_huff.h"
  41. #include "sbr_fbt.h"
  42. #include "sbr_tf_grid.h"
  43. #include "sbr_e_nf.h"
  44. #include "bits.h"
  45. #ifdef PS_DEC
  46. #include "ps_dec.h"
  47. #endif
  48. #ifdef DRM_PS
  49. #include "drm_dec.h"
  50. #endif
  51. #include "analysis.h"
  53. /* static function declarations */
  54. static void sbr_header(bitfile *ld, sbr_info *sbr);
  55. static uint8_t calc_sbr_tables(sbr_info *sbr, uint8_t start_freq, uint8_t stop_freq,
  56.                                uint8_t samplerate_mode, uint8_t freq_scale,
  57.                                uint8_t alter_scale, uint8_t xover_band);
  58. static uint8_t sbr_data(bitfile *ld, sbr_info *sbr);
  59. static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
  60.                               uint8_t bs_extension_id, uint16_t num_bits_left);
  61. static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr);
  62. static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr);
  63. static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch);
  64. static void sbr_dtdf(bitfile *ld, sbr_info *sbr, uint8_t ch);
  65. static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch);
  66. static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch);
  69. static void sbr_reset(sbr_info *sbr)
  70. {
  71. #if 0
  72.     printf("%dn", sbr->bs_start_freq_prev);
  73.     printf("%dn", sbr->bs_stop_freq_prev);
  74.     printf("%dn", sbr->bs_freq_scale_prev);
  75.     printf("%dn", sbr->bs_alter_scale_prev);
  76.     printf("%dn", sbr->bs_xover_band_prev);
  77.     printf("%dnn", sbr->bs_noise_bands_prev);
  78. #endif
  80.     /* if these are different from the previous frame: Reset = 1 */
  81.     if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) ||
  82.         (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) ||
  83.         (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) ||
  84.         (sbr->bs_alter_scale != sbr->bs_alter_scale_prev) ||
  85.         (sbr->bs_xover_band != sbr->bs_xover_band_prev) ||
  86.         (sbr->bs_noise_bands != sbr->bs_noise_bands_prev))
  87.     {
  88.         sbr->Reset = 1;
  89.     } else {
  90.         sbr->Reset = 0;
  91.     }
  93.     sbr->bs_start_freq_prev = sbr->bs_start_freq;
  94.     sbr->bs_stop_freq_prev = sbr->bs_stop_freq;
  95.     sbr->bs_freq_scale_prev = sbr->bs_freq_scale;
  96.     sbr->bs_alter_scale_prev = sbr->bs_alter_scale;
  97.     sbr->bs_xover_band_prev = sbr->bs_xover_band;
  98.     sbr->bs_noise_bands_prev = sbr->bs_noise_bands;
  99. }
  101. static uint8_t calc_sbr_tables(sbr_info *sbr, uint8_t start_freq, uint8_t stop_freq,
  102.                                uint8_t samplerate_mode, uint8_t freq_scale,
  103.                                uint8_t alter_scale, uint8_t xover_band)
  104. {
  105.     uint8_t result = 0;
  106.     uint8_t k2;
  108.     /* calculate the Master Frequency Table */
  109.     sbr->k0 = qmf_start_channel(start_freq, samplerate_mode, sbr->sample_rate);
  110.     k2 = qmf_stop_channel(stop_freq, sbr->sample_rate, sbr->k0);
  112.     /* check k0 and k2 */
  113.     if (sbr->sample_rate >= 48000)
  114.     {
  115.         if ((k2 - sbr->k0) > 32)
  116.             result += 1;
  117.     } else if (sbr->sample_rate <= 32000) {
  118.         if ((k2 - sbr->k0) > 48)
  119.             result += 1;
  120.     } else { /* (sbr->sample_rate == 44100) */
  121.         if ((k2 - sbr->k0) > 45)
  122.             result += 1;
  123.     }
  125.     if (freq_scale == 0)
  126.     {
  127.         result += master_frequency_table_fs0(sbr, sbr->k0, k2, alter_scale);
  128.     } else {
  129.         result += master_frequency_table(sbr, sbr->k0, k2, freq_scale, alter_scale);
  130.     }
  131.     result += derived_frequency_table(sbr, xover_band, k2);
  133.     result = (result > 0) ? 1 : 0;
  135.     return result;
  136. }
  138. /* table 2 */
  139. uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint16_t cnt)
  140. {
  141.     uint8_t result = 0;
  142.     uint16_t num_align_bits = 0;
  143.     uint16_t num_sbr_bits = (uint16_t)faad_get_processed_bits(ld);
  145.     uint8_t saved_start_freq, saved_samplerate_mode;
  146.     uint8_t saved_stop_freq, saved_freq_scale;
  147.     uint8_t saved_alter_scale, saved_xover_band;
  149. #ifdef DRM
  150.     if (!sbr->Is_DRM_SBR)
  151. #endif
  152.     {
  153.         uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4
  154.             DEBUGVAR(1,198,"sbr_bitstream(): bs_extension_type"));
  156.         if (bs_extension_type == EXT_SBR_DATA_CRC)
  157.         {
  158.             sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10
  159.                 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits"));
  160.         }
  161.     }
  163.     /* save old header values, in case the new ones are corrupted */
  164.     saved_start_freq = sbr->bs_start_freq;
  165.     saved_samplerate_mode = sbr->bs_samplerate_mode;
  166.     saved_stop_freq = sbr->bs_stop_freq;
  167.     saved_freq_scale = sbr->bs_freq_scale;
  168.     saved_alter_scale = sbr->bs_alter_scale;
  169.     saved_xover_band = sbr->bs_xover_band;
  171.     sbr->bs_header_flag = faad_get1bit(ld
  172.         DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag"));
  174.     if (sbr->bs_header_flag)
  175.         sbr_header(ld, sbr);
  177.     /* Reset? */
  178.     sbr_reset(sbr);
  180.     /* first frame should have a header */
  181.     //if (!(sbr->frame == 0 && sbr->bs_header_flag == 0))
  182.     if (sbr->header_count != 0)
  183.     {
  184.         if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked))
  185.         {
  186.             uint8_t rt = calc_sbr_tables(sbr, sbr->bs_start_freq, sbr->bs_stop_freq,
  187.                 sbr->bs_samplerate_mode, sbr->bs_freq_scale,
  188.                 sbr->bs_alter_scale, sbr->bs_xover_band);
  190.             /* if an error occured with the new header values revert to the old ones */
  191.             if (rt > 0)
  192.             {
  193.                 calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq,
  194.                     saved_samplerate_mode, saved_freq_scale,
  195.                     saved_alter_scale, saved_xover_band);
  196.             }
  197.         }
  199.         if (result == 0)
  200.         {
  201.             result = sbr_data(ld, sbr);
  203.             /* sbr_data() returning an error means that there was an error in
  204.                envelope_time_border_vector().
  205.                In this case the old time border vector is saved and all the previous
  206.                data normally read after sbr_grid() is saved.
  207.             */
  208.             /* to be on the safe side, calculate old sbr tables in case of error */
  209.             if ((result > 0) &&
  210.                 (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)))
  211.             {
  212.                 calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq,
  213.                     saved_samplerate_mode, saved_freq_scale,
  214.                     saved_alter_scale, saved_xover_band);          
  215.             }
  217.             /* we should be able to safely set result to 0 now, */
  218.             /* but practise indicates this doesn't work well */
  219.         }
  220.     } else {
  221.         result = 1;
  222.     }     
  223.            
  224.      
  225.     num_sbr_bits = (uint16_t)faad_get_processed_bits(ld) - num_sbr_bits;
  227.     /* check if we read more bits then were available for sbr */
  228.     if (8*cnt < num_sbr_bits) {
  229.             return 1;
  230.     }
  232. #ifdef DRM
  233.     if (!sbr->Is_DRM_SBR)
  234. #endif
  235.     {       
  236.         /* -4 does not apply, bs_extension_type is re-read in this function */
  237.         num_align_bits = 8*cnt /*- 4*/ - num_sbr_bits;
  239.         while (num_align_bits > 7)
  240.         {
  241.             faad_getbits(ld, 8
  242.                 DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits"));
  243.             num_align_bits -= 8;
  244.         }
  245.         faad_getbits(ld, num_align_bits
  246.             DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits"));
  247.     }
  249.     return result;
  250. }
  252. /* table 3 */
  253. static void sbr_header(bitfile *ld, sbr_info *sbr)
  254. {
  255.     uint8_t bs_header_extra_1, bs_header_extra_2;
  257.     sbr->header_count++;
  259.     sbr->bs_amp_res = faad_get1bit(ld
  260.         DEBUGVAR(1,203,"sbr_header(): bs_amp_res"));
  262.     /* bs_start_freq and bs_stop_freq must define a fequency band that does
  263.        not exceed 48 channels */
  264.     sbr->bs_start_freq = (uint8_t)faad_getbits(ld, 4
  265.         DEBUGVAR(1,204,"sbr_header(): bs_start_freq"));
  266.     sbr->bs_stop_freq = (uint8_t)faad_getbits(ld, 4
  267.         DEBUGVAR(1,205,"sbr_header(): bs_stop_freq"));
  268.     sbr->bs_xover_band = (uint8_t)faad_getbits(ld, 3
  269.         DEBUGVAR(1,206,"sbr_header(): bs_xover_band"));
  270.     faad_getbits(ld, 2
  271.         DEBUGVAR(1,207,"sbr_header(): bs_reserved_bits_hdr"));
  272.     bs_header_extra_1 = (uint8_t)faad_get1bit(ld
  273.         DEBUGVAR(1,208,"sbr_header(): bs_header_extra_1"));
  274.     bs_header_extra_2 = (uint8_t)faad_get1bit(ld
  275.         DEBUGVAR(1,209,"sbr_header(): bs_header_extra_2"));
  277.     if (bs_header_extra_1)
  278.     {
  279.         sbr->bs_freq_scale = (uint8_t)faad_getbits(ld, 2
  280.             DEBUGVAR(1,211,"sbr_header(): bs_freq_scale"));
  281.         sbr->bs_alter_scale = (uint8_t)faad_get1bit(ld
  282.             DEBUGVAR(1,212,"sbr_header(): bs_alter_scale"));
  283.         sbr->bs_noise_bands = (uint8_t)faad_getbits(ld, 2
  284.             DEBUGVAR(1,213,"sbr_header(): bs_noise_bands"));
  285.     } else {
  286.         /* Default values */
  287.         sbr->bs_freq_scale = 2;
  288.         sbr->bs_alter_scale = 1;
  289.         sbr->bs_noise_bands = 2;
  290.     }
  292.     if (bs_header_extra_2)
  293.     {
  294.         sbr->bs_limiter_bands = (uint8_t)faad_getbits(ld, 2
  295.             DEBUGVAR(1,214,"sbr_header(): bs_limiter_bands"));
  296.         sbr->bs_limiter_gains = (uint8_t)faad_getbits(ld, 2
  297.             DEBUGVAR(1,215,"sbr_header(): bs_limiter_gains"));
  298.         sbr->bs_interpol_freq = (uint8_t)faad_get1bit(ld
  299.             DEBUGVAR(1,216,"sbr_header(): bs_interpol_freq"));
  300.         sbr->bs_smoothing_mode = (uint8_t)faad_get1bit(ld
  301.             DEBUGVAR(1,217,"sbr_header(): bs_smoothing_mode"));
  302.     } else {
  303.         /* Default values */
  304.         sbr->bs_limiter_bands = 2;
  305.         sbr->bs_limiter_gains = 2;
  306.         sbr->bs_interpol_freq = 1;
  307.         sbr->bs_smoothing_mode = 1;
  308.     }
  310. #if 0
  311.     /* print the header to screen */
  312.     printf("bs_amp_res: %dn", sbr->bs_amp_res);
  313.     printf("bs_start_freq: %dn", sbr->bs_start_freq);
  314.     printf("bs_stop_freq: %dn", sbr->bs_stop_freq);
  315.     printf("bs_xover_band: %dn", sbr->bs_xover_band);
  316.     if (bs_header_extra_1)
  317.     {
  318.         printf("bs_freq_scale: %dn", sbr->bs_freq_scale);
  319.         printf("bs_alter_scale: %dn", sbr->bs_alter_scale);
  320.         printf("bs_noise_bands: %dn", sbr->bs_noise_bands);
  321.     }
  322.     if (bs_header_extra_2)
  323.     {
  324.         printf("bs_limiter_bands: %dn", sbr->bs_limiter_bands);
  325.         printf("bs_limiter_gains: %dn", sbr->bs_limiter_gains);
  326.         printf("bs_interpol_freq: %dn", sbr->bs_interpol_freq);
  327.         printf("bs_smoothing_mode: %dn", sbr->bs_smoothing_mode);
  328.     }
  329.     printf("n");
  330. #endif
  331. }
  333. /* table 4 */
  334. static uint8_t sbr_data(bitfile *ld, sbr_info *sbr)
  335. {
  336.     uint8_t result;
  337. #if 0
  338.     sbr->bs_samplerate_mode = faad_get1bit(ld
  339.         DEBUGVAR(1,219,"sbr_data(): bs_samplerate_mode"));
  340. #endif
  342.     sbr->rate = (sbr->bs_samplerate_mode) ? 2 : 1;
  344.     switch (sbr->id_aac)
  345.     {
  346.     case ID_SCE:
  347. if ((result = sbr_single_channel_element(ld, sbr)) > 0)
  348. return result;
  349.         break;
  350.     case ID_CPE:
  351. if ((result = sbr_channel_pair_element(ld, sbr)) > 0)
  352. return result;
  353.         break;
  354.     }
  356. return 0;
  357. }
  359. /* table 5 */
  360. static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr)
  361. {
  362.     uint8_t result;
  364.     if (faad_get1bit(ld
  365.         DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra")))
  366.     {
  367.         faad_getbits(ld, 4
  368.             DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data"));
  369.     }
  371. #ifdef DRM
  372.     /* bs_coupling, from sbr_channel_pair_base_element(bs_amp_res) */
  373.     if (sbr->Is_DRM_SBR)
  374.     {
  375.         faad_get1bit(ld);
  376.     }
  377. #endif
  379.     if ((result = sbr_grid(ld, sbr, 0)) > 0)
  380.         return result;
  382.     sbr_dtdf(ld, sbr, 0);
  383.     invf_mode(ld, sbr, 0);
  384.     sbr_envelope(ld, sbr, 0);
  385.     sbr_noise(ld, sbr, 0);
  387. #ifndef FIXED_POINT
  388.     envelope_noise_dequantisation(sbr, 0);
  389. #endif
  391.     memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
  393.     sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
  394.         DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]"));
  395.     if (sbr->bs_add_harmonic_flag[0])
  396.         sinusoidal_coding(ld, sbr, 0);
  398.     sbr->bs_extended_data = faad_get1bit(ld
  399.         DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]"));
  401.     if (sbr->bs_extended_data)
  402.     {
  403.         uint16_t nr_bits_left;
  404. #if (defined(PS_DEC) || defined(DRM_PS))
  405.         uint8_t ps_ext_read = 0;
  406. #endif
  407.         uint16_t cnt = (uint16_t)faad_getbits(ld, 4
  408.             DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size"));
  409.         if (cnt == 15)
  410.         {
  411.             cnt += (uint16_t)faad_getbits(ld, 8
  412.                 DEBUGVAR(1,226,"sbr_single_channel_element(): bs_esc_count"));
  413.         }
  415.         nr_bits_left = 8 * cnt;
  416.         while (nr_bits_left > 7)
  417.         {
  418.             uint16_t tmp_nr_bits = 0;
  420.             sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
  421.                 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id"));
  422.             tmp_nr_bits += 2;
  424.             /* allow only 1 PS extension element per extension data */
  425. #if (defined(PS_DEC) || defined(DRM_PS))
  426. #if (defined(PS_DEC) && defined(DRM_PS))
  427.             if (sbr->bs_extension_id == EXTENSION_ID_PS || sbr->bs_extension_id == DRM_PARAMETRIC_STEREO)
  428. #else
  429. #ifdef PS_DEC
  430.             if (sbr->bs_extension_id == EXTENSION_ID_PS)
  431. #else
  432. #ifdef DRM_PS
  433.             if (sbr->bs_extension_id == DRM_PARAMETRIC_STEREO)
  434. #endif
  435. #endif
  436. #endif
  437.             {
  438.                 if (ps_ext_read == 0)
  439.                 {
  440.                     ps_ext_read = 1;
  441.                 } else {
  442.                     /* to be safe make it 3, will switch to "default"
  443.                      * in sbr_extension() */
  444. #ifdef DRM
  445.                     return 1;
  446. #else
  447.                     sbr->bs_extension_id = 3;
  448. #endif
  449.                 }
  450.             }
  451. #endif
  453.             tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
  455.             /* check if the data read is bigger than the number of available bits */
  456.             if (tmp_nr_bits > nr_bits_left)
  457.                 return 1;
  459.             nr_bits_left -= tmp_nr_bits;
  460.         }
  462.         /* Corrigendum */
  463.         if (nr_bits_left > 0)
  464.         {
  465.             faad_getbits(ld, nr_bits_left
  466.                 DEBUGVAR(1,280,"sbr_single_channel_element(): nr_bits_left"));
  467.         }
  468.     }
  470.     return 0;
  471. }
  473. /* table 6 */
  474. static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr)
  475. {
  476.     uint8_t n, result;
  478.     if (faad_get1bit(ld
  479.         DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra")))
  480.     {
  481.         faad_getbits(ld, 4
  482.             DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
  483.         faad_getbits(ld, 4
  484.             DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
  485.     }
  487.     sbr->bs_coupling = faad_get1bit(ld
  488.         DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_coupling"));
  490.     if (sbr->bs_coupling)
  491.     {
  492.         if ((result = sbr_grid(ld, sbr, 0)) > 0)
  493.             return result;
  495.         /* need to copy some data from left to right */
  496.         sbr->bs_frame_class[1] = sbr->bs_frame_class[0];
  497.         sbr->L_E[1] = sbr->L_E[0];
  498.         sbr->L_Q[1] = sbr->L_Q[0];
  499.         sbr->bs_pointer[1] = sbr->bs_pointer[0];
  501.         for (n = 0; n <= sbr->L_E[0]; n++)
  502.         {
  503.             sbr->t_E[1][n] = sbr->t_E[0][n];
  504.             sbr->f[1][n] = sbr->f[0][n];
  505.         }
  506.         for (n = 0; n <= sbr->L_Q[0]; n++)
  507.             sbr->t_Q[1][n] = sbr->t_Q[0][n];
  509.         sbr_dtdf(ld, sbr, 0);
  510.         sbr_dtdf(ld, sbr, 1);
  511.         invf_mode(ld, sbr, 0);
  513.         /* more copying */
  514.         for (n = 0; n < sbr->N_Q; n++)
  515.             sbr->bs_invf_mode[1][n] = sbr->bs_invf_mode[0][n];
  517.         sbr_envelope(ld, sbr, 0);
  518.         sbr_noise(ld, sbr, 0);
  519.         sbr_envelope(ld, sbr, 1);
  520.         sbr_noise(ld, sbr, 1);
  522.         memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
  523.         memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
  525.         sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
  526.             DEBUGVAR(1,231,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
  527.         if (sbr->bs_add_harmonic_flag[0])
  528.             sinusoidal_coding(ld, sbr, 0);
  530.         sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
  531.             DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
  532.         if (sbr->bs_add_harmonic_flag[1])
  533.             sinusoidal_coding(ld, sbr, 1);
  534.     } else {
  535.         uint8_t saved_t_E[6] = {0}, saved_t_Q[3] = {0};
  536.         uint8_t saved_L_E = sbr->L_E[0];
  537.         uint8_t saved_L_Q = sbr->L_Q[0];
  538.         uint8_t saved_frame_class = sbr->bs_frame_class[0];
  540.         for (n = 0; n < saved_L_E; n++)
  541.             saved_t_E[n] = sbr->t_E[0][n];
  542.         for (n = 0; n < saved_L_Q; n++)
  543.             saved_t_Q[n] = sbr->t_Q[0][n];
  545.         if ((result = sbr_grid(ld, sbr, 0)) > 0)
  546.             return result;
  547.         if ((result = sbr_grid(ld, sbr, 1)) > 0)
  548.         {
  549.             /* restore first channel data as well */
  550.             sbr->bs_frame_class[0] = saved_frame_class;
  551.             sbr->L_E[0] = saved_L_E;
  552.             sbr->L_Q[0] = saved_L_Q;
  553.             for (n = 0; n < 6; n++)
  554.                 sbr->t_E[0][n] = saved_t_E[n];
  555.             for (n = 0; n < 3; n++)
  556.                 sbr->t_Q[0][n] = saved_t_Q[n];
  558.             return result;
  559.         }
  560.         sbr_dtdf(ld, sbr, 0);
  561.         sbr_dtdf(ld, sbr, 1);
  562.         invf_mode(ld, sbr, 0);
  563.         invf_mode(ld, sbr, 1);
  564.         sbr_envelope(ld, sbr, 0);
  565.         sbr_envelope(ld, sbr, 1);
  566.         sbr_noise(ld, sbr, 0);
  567.         sbr_noise(ld, sbr, 1);
  569.         memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
  570.         memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
  572.         sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
  573.             DEBUGVAR(1,239,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
  574.         if (sbr->bs_add_harmonic_flag[0])
  575.             sinusoidal_coding(ld, sbr, 0);
  577.         sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
  578.             DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
  579.         if (sbr->bs_add_harmonic_flag[1])
  580.             sinusoidal_coding(ld, sbr, 1);
  581.     }
  582. #ifndef FIXED_POINT
  583.     envelope_noise_dequantisation(sbr, 0);
  584.     envelope_noise_dequantisation(sbr, 1);
  586.     if (sbr->bs_coupling)
  587.         unmap_envelope_noise(sbr);
  588. #endif
  590.     sbr->bs_extended_data = faad_get1bit(ld
  591.         DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]"));
  592.     if (sbr->bs_extended_data)
  593.     {
  594.         uint16_t nr_bits_left;
  595.         uint16_t cnt = (uint16_t)faad_getbits(ld, 4
  596.             DEBUGVAR(1,234,"sbr_channel_pair_element(): bs_extension_size"));
  597.         if (cnt == 15)
  598.         {
  599.             cnt += (uint16_t)faad_getbits(ld, 8
  600.                 DEBUGVAR(1,235,"sbr_channel_pair_element(): bs_esc_count"));
  601.         }
  603.         nr_bits_left = 8 * cnt;
  604.         while (nr_bits_left > 7)
  605.         {
  606.             uint16_t tmp_nr_bits = 0;
  608.             sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
  609.                 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id"));
  610.             tmp_nr_bits += 2;
  611.             tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
  613.             /* check if the data read is bigger than the number of available bits */
  614.             if (tmp_nr_bits > nr_bits_left)
  615.                 return 1;
  617.             nr_bits_left -= tmp_nr_bits;
  618.         }
  620.         /* Corrigendum */
  621.         if (nr_bits_left > 0)
  622.         {
  623.             faad_getbits(ld, nr_bits_left
  624.                 DEBUGVAR(1,280,"sbr_channel_pair_element(): nr_bits_left"));
  625.         }
  626.     }
  628.     return 0;
  629. }
  631. /* integer log[2](x): input range [0,10) */
  632. static int8_t sbr_log2(const int8_t val)
  633. {
  634.     int8_t log2tab[] = { 0, 0, 1, 2, 2, 3, 3, 3, 3, 4 };
  635.     if (val < 10 && val >= 0)
  636.         return log2tab[val];
  637.     else
  638.         return 0;
  639. }
  642. /* table 7 */
  643. static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch)
  644. {
  645.     uint8_t i, env, rel, result;
  646.     uint8_t bs_abs_bord, bs_abs_bord_1;
  647.     uint8_t bs_num_env = 0;
  648.     uint8_t saved_L_E = sbr->L_E[ch];
  649.     uint8_t saved_L_Q = sbr->L_Q[ch];
  650.     uint8_t saved_frame_class = sbr->bs_frame_class[ch];
  652.     sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2
  653.         DEBUGVAR(1,248,"sbr_grid(): bs_frame_class"));
  655.     switch (sbr->bs_frame_class[ch])
  656.     {
  657.     case FIXFIX:
  658.         i = (uint8_t)faad_getbits(ld, 2
  659.             DEBUGVAR(1,249,"sbr_grid(): bs_num_env_raw"));
  661.         bs_num_env = min(1 << i, 5);
  663.         i = (uint8_t)faad_get1bit(ld
  664.             DEBUGVAR(1,250,"sbr_grid(): bs_freq_res_flag"));
  665.         for (env = 0; env < bs_num_env; env++)
  666.             sbr->f[ch][env] = i;
  668.         sbr->abs_bord_lead[ch] = 0;
  669.         sbr->abs_bord_trail[ch] = sbr->numTimeSlots;
  670.         sbr->n_rel_lead[ch] = bs_num_env - 1;
  671.         sbr->n_rel_trail[ch] = 0;
  672.         break;
  674.     case FIXVAR:
  675.         bs_abs_bord = (uint8_t)faad_getbits(ld, 2
  676.             DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots;
  677.         bs_num_env = (uint8_t)faad_getbits(ld, 2
  678.             DEBUGVAR(1,252,"sbr_grid(): bs_num_env")) + 1;
  680.         for (rel = 0; rel < bs_num_env-1; rel++)
  681.         {
  682.             sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
  683.                 DEBUGVAR(1,253,"sbr_grid(): bs_rel_bord")) + 2;
  684.         }
  685.         i = sbr_log2(bs_num_env + 1);
  686.         sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
  687.             DEBUGVAR(1,254,"sbr_grid(): bs_pointer"));
  689.         for (env = 0; env < bs_num_env; env++)
  690.         {
  691.             sbr->f[ch][bs_num_env - env - 1] = (uint8_t)faad_get1bit(ld
  692.                 DEBUGVAR(1,255,"sbr_grid(): bs_freq_res"));
  693.         }
  695.         sbr->abs_bord_lead[ch] = 0;
  696.         sbr->abs_bord_trail[ch] = bs_abs_bord;
  697.         sbr->n_rel_lead[ch] = 0;
  698.         sbr->n_rel_trail[ch] = bs_num_env - 1;
  699.         break;
  701.     case VARFIX:
  702.         bs_abs_bord = (uint8_t)faad_getbits(ld, 2
  703.             DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord"));
  704.         bs_num_env = (uint8_t)faad_getbits(ld, 2
  705.             DEBUGVAR(1,257,"sbr_grid(): bs_num_env")) + 1;
  707.         for (rel = 0; rel < bs_num_env-1; rel++)
  708.         {
  709.             sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
  710.                 DEBUGVAR(1,258,"sbr_grid(): bs_rel_bord")) + 2;
  711.         }
  712.         i = sbr_log2(bs_num_env + 1);
  713.         sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
  714.             DEBUGVAR(1,259,"sbr_grid(): bs_pointer"));
  716.         for (env = 0; env < bs_num_env; env++)
  717.         {
  718.             sbr->f[ch][env] = (uint8_t)faad_get1bit(ld
  719.                 DEBUGVAR(1,260,"sbr_grid(): bs_freq_res"));
  720.         }
  722.         sbr->abs_bord_lead[ch] = bs_abs_bord;
  723.         sbr->abs_bord_trail[ch] = sbr->numTimeSlots;
  724.         sbr->n_rel_lead[ch] = bs_num_env - 1;
  725.         sbr->n_rel_trail[ch] = 0;
  726.         break;
  728.     case VARVAR:
  729.         bs_abs_bord = (uint8_t)faad_getbits(ld, 2
  730.             DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0"));
  731.         bs_abs_bord_1 = (uint8_t)faad_getbits(ld, 2
  732.             DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots;
  733.         sbr->bs_num_rel_0[ch] = (uint8_t)faad_getbits(ld, 2
  734.             DEBUGVAR(1,263,"sbr_grid(): bs_num_rel_0"));
  735.         sbr->bs_num_rel_1[ch] = (uint8_t)faad_getbits(ld, 2
  736.             DEBUGVAR(1,264,"sbr_grid(): bs_num_rel_1"));
  738.         bs_num_env = min(5, sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 1);
  740.         for (rel = 0; rel < sbr->bs_num_rel_0[ch]; rel++)
  741.         {
  742.             sbr->bs_rel_bord_0[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
  743.                 DEBUGVAR(1,265,"sbr_grid(): bs_rel_bord")) + 2;
  744.         }
  745.         for(rel = 0; rel < sbr->bs_num_rel_1[ch]; rel++)
  746.         {
  747.             sbr->bs_rel_bord_1[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
  748.                 DEBUGVAR(1,266,"sbr_grid(): bs_rel_bord")) + 2;
  749.         }
  750.         i = sbr_log2(sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 2);
  751.         sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
  752.             DEBUGVAR(1,267,"sbr_grid(): bs_pointer"));
  754.         for (env = 0; env < bs_num_env; env++)
  755.         {
  756.             sbr->f[ch][env] = (uint8_t)faad_get1bit(ld
  757.                 DEBUGVAR(1,268,"sbr_grid(): bs_freq_res"));
  758.         }
  760.         sbr->abs_bord_lead[ch] = bs_abs_bord;
  761.         sbr->abs_bord_trail[ch] = bs_abs_bord_1;
  762.         sbr->n_rel_lead[ch] = sbr->bs_num_rel_0[ch];
  763.         sbr->n_rel_trail[ch] = sbr->bs_num_rel_1[ch];
  764.         break;
  765.     }
  767.     if (sbr->bs_frame_class[ch] == VARVAR)
  768.         sbr->L_E[ch] = min(bs_num_env, 5);
  769.     else
  770.         sbr->L_E[ch] = min(bs_num_env, 4);
  772.     if (sbr->L_E[ch] <= 0)
  773.         return 1;
  775.     if (sbr->L_E[ch] > 1)
  776.         sbr->L_Q[ch] = 2;
  777.     else
  778.         sbr->L_Q[ch] = 1;
  780.     /* TODO: this code can probably be integrated into the code above! */
  781.     if ((result = envelope_time_border_vector(sbr, ch)) > 0)
  782.     {
  783.         sbr->bs_frame_class[ch] = saved_frame_class;
  784.         sbr->L_E[ch] = saved_L_E;
  785.         sbr->L_Q[ch] = saved_L_Q;
  786.         return result;
  787.     }
  788.     noise_floor_time_border_vector(sbr, ch);
  790. #if 0
  791.     for (env = 0; env < bs_num_env; env++)
  792.     {
  793.         printf("freq_res[ch:%d][env:%d]: %dn", ch, env, sbr->f[ch][env]);
  794.     }
  795. #endif
  797.     return 0;
  798. }
  800. /* table 8 */
  801. static void sbr_dtdf(bitfile *ld, sbr_info *sbr, uint8_t ch)
  802. {
  803.     uint8_t i;
  805.     for (i = 0; i < sbr->L_E[ch]; i++)
  806.     {
  807.         sbr->bs_df_env[ch][i] = faad_get1bit(ld
  808.             DEBUGVAR(1,269,"sbr_dtdf(): bs_df_env"));
  809.     }
  811.     for (i = 0; i < sbr->L_Q[ch]; i++)
  812.     {
  813.         sbr->bs_df_noise[ch][i] = faad_get1bit(ld
  814.             DEBUGVAR(1,270,"sbr_dtdf(): bs_df_noise"));
  815.     }
  816. }
  818. /* table 9 */
  819. static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch)
  820. {
  821.     uint8_t n;
  823.     for (n = 0; n < sbr->N_Q; n++)
  824.     {
  825.         sbr->bs_invf_mode[ch][n] = (uint8_t)faad_getbits(ld, 2
  826.             DEBUGVAR(1,271,"invf_mode(): bs_invf_mode"));
  827.     }
  828. }
  830. static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
  831.                               uint8_t bs_extension_id, uint16_t num_bits_left)
  832. {
  833. #ifdef PS_DEC
  834.     uint8_t header;
  835.     uint16_t ret;
  836. #endif
  838.     switch (bs_extension_id)
  839.     {
  840. #ifdef PS_DEC
  841.     case EXTENSION_ID_PS:
  842.         if (!sbr->ps)
  843.         {
  844.             sbr->ps = ps_init(get_sr_index(sbr->sample_rate));
  845.         }
  846.         ret = ps_data(sbr->ps, ld, &header);
  848.         /* enable PS if and only if: a header has been decoded */
  849.         if (sbr->ps_used == 0 && header == 1)
  850.         {
  851.             sbr->ps_used = 1;
  852.         }
  854.         return ret;
  855. #endif
  856. #ifdef DRM_PS
  857.     case DRM_PARAMETRIC_STEREO:
  858.         sbr->ps_used = 1;
  859.         if (!sbr->drm_ps)
  860.         {
  861.             sbr->drm_ps = drm_ps_init();
  862.         }
  863.         return drm_ps_data(sbr->drm_ps, ld);
  864. #endif
  865.     default:
  866.         sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6
  867.             DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data"));
  868.         return 6;
  869.     }
  870. }
  872. /* table 12 */
  873. static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch)
  874. {
  875.     uint8_t n;
  877.     for (n = 0; n < sbr->N_high; n++)
  878.     {
  879.         sbr->bs_add_harmonic[ch][n] = faad_get1bit(ld
  880.             DEBUGVAR(1,278,"sinusoidal_coding(): bs_add_harmonic"));
  881.     }
  882. }
  885. #endif /* SBR_DEC */