Home | History | Annotate | Download | only in drc_src
      1 /******************************************************************************
      2  *
      3  * Copyright (C) 2018 The Android Open Source Project
      4  *
      5  * Licensed under the Apache License, Version 2.0 (the "License");
      6  * you may not use this file except in compliance with the License.
      7  * You may obtain a copy of the License at:
      8  *
      9  * http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  * Unless required by applicable law or agreed to in writing, software
     12  * distributed under the License is distributed on an "AS IS" BASIS,
     13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  * See the License for the specific language governing permissions and
     15  * limitations under the License.
     16  *
     17  *****************************************************************************
     18  * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
     19 */
     20 #include <stdio.h>
     21 #include <string.h>
     22 #include <math.h>
     23 #include "impd_type_def.h"
     24 #include "impd_drc_bitbuffer.h"
     25 #include "impd_drc_extr_delta_coded_info.h"
     26 #include "impd_drc_common.h"
     27 #include "impd_drc_struct.h"
     28 #include "impd_drc_parser.h"
     29 #include "impd_drc_filter_bank.h"
     30 #include "impd_drc_rom.h"
     31 
     32 WORD32 impd_parse_loud_eq_instructions(
     33     ia_bit_buf_struct* it_bit_buff,
     34     ia_loud_eq_instructions_struct* loud_eq_instructions);
     35 
     36 WORD32 impd_parse_eq_coefficients(ia_bit_buf_struct* it_bit_buff,
     37                                   ia_eq_coeff_struct* str_eq_coeff);
     38 
     39 WORD32 impd_parse_eq_instructions(
     40     ia_bit_buf_struct* it_bit_buff, ia_drc_config* drc_config,
     41     ia_eq_instructions_struct* str_eq_instructions);
     42 WORD32 impd_dec_initial_gain(ia_bit_buf_struct* it_bit_buff,
     43                              const WORD32 gain_coding_profile,
     44                              FLOAT32* initial_gain) {
     45   WORD32 sign, magn, bit_2_extract;
     46   switch (gain_coding_profile) {
     47     case GAIN_CODING_PROFILE_REGULAR:
     48       sign = impd_read_bits_buf(it_bit_buff, 1);
     49       if (it_bit_buff->error) return it_bit_buff->error;
     50       magn = impd_read_bits_buf(it_bit_buff, 8);
     51       if (it_bit_buff->error) return it_bit_buff->error;
     52       *initial_gain = magn * 0.125f;
     53       if (sign) *initial_gain = -*initial_gain;
     54       break;
     55     case GAIN_CODING_PROFILE_FADING:
     56     case GAIN_CODING_PROFILE_CLIPPING:
     57       bit_2_extract =
     58           (gain_coding_profile == GAIN_CODING_PROFILE_FADING) ? 10 : 8;
     59       sign = impd_read_bits_buf(it_bit_buff, 1);
     60       if (it_bit_buff->error) return it_bit_buff->error;
     61       if (sign == 0)
     62         *initial_gain = 0.0f;
     63       else {
     64         magn = impd_read_bits_buf(it_bit_buff, bit_2_extract);
     65         if (it_bit_buff->error) return it_bit_buff->error;
     66         *initial_gain = -(magn + 1) * 0.125f;
     67       }
     68       break;
     69 
     70     case GAIN_CODING_PROFILE_CONSTANT:
     71       break;
     72     default:
     73       return (UNEXPECTED_ERROR);
     74   }
     75   return (0);
     76 }
     77 
     78 WORD32 impd_dec_gains(ia_bit_buf_struct* it_bit_buff, WORD32 no_nodes,
     79                       WORD32 gain_coding_profile, ia_node_struct* str_node) {
     80   WORD32 err = 0, k, e, m;
     81   WORD32 bit;
     82   WORD32 num_bits_read;
     83   WORD32 code;
     84   WORD32 code_found;
     85   FLOAT32 drc_gain_delta = 0;
     86   const ia_delta_gain_code_table_struct* ptr_delta_gain_code_table;
     87   WORD32 no_delta_gain_entries;
     88 
     89   err = impd_dec_initial_gain(it_bit_buff, gain_coding_profile,
     90                               &(str_node[0].loc_db_gain));
     91   if (err) return (err);
     92 
     93   impd_get_delta_gain_code_tbl(gain_coding_profile, &ptr_delta_gain_code_table,
     94                                &no_delta_gain_entries);
     95   for (k = 1; k < no_nodes; k++) {
     96     num_bits_read = 0;
     97     code = 0;
     98     code_found = 0;
     99     e = 0;
    100     while ((e < no_delta_gain_entries) && (!code_found)) {
    101       for (m = 0; m < ptr_delta_gain_code_table[e].size - num_bits_read; m++) {
    102         bit = impd_read_bits_buf(it_bit_buff, 1);
    103         if (it_bit_buff->error) return it_bit_buff->error;
    104         code = (code << 1) + bit;
    105         num_bits_read++;
    106       }
    107       while (num_bits_read == ptr_delta_gain_code_table[e].size) {
    108         if (code == ptr_delta_gain_code_table[e].code) {
    109           drc_gain_delta = ptr_delta_gain_code_table[e].value;
    110           code_found = 1;
    111           break;
    112         }
    113         e++;
    114       }
    115     }
    116     if (code_found == 0) {
    117       return (UNEXPECTED_ERROR);
    118     }
    119     str_node[k].loc_db_gain = str_node[k - 1].loc_db_gain + drc_gain_delta;
    120   }
    121   return (0);
    122 }
    123 
    124 WORD32 impd_dec_slopes(ia_bit_buf_struct* it_bit_buff, WORD32* no_nodes,
    125                        WORD32 gain_interpolation_type,
    126                        ia_node_struct* str_node) {
    127   WORD32 k, e, m, bit;
    128   WORD32 code;
    129   WORD32 code_found;
    130   FLOAT32 slope_value = 0;
    131   bool end_marker = 0;
    132   WORD32 num_bits_read;
    133   const ia_slope_code_table_struct* ptr_slope_code_table;
    134   WORD32 no_slope_code_entries;
    135 
    136   ptr_slope_code_table = &(slope_code_tbl_entries_by_size[0]);
    137   no_slope_code_entries = NUM_SLOPE_TBL_ENTRIES;
    138 
    139   k = 0;
    140   while (end_marker != 1) {
    141     k++;
    142     end_marker = impd_read_bits_buf(it_bit_buff, 1);
    143     if (it_bit_buff->error) return it_bit_buff->error;
    144   }
    145   *no_nodes = k;
    146 
    147   if (gain_interpolation_type == GAIN_INTERPOLATION_TYPE_SPLINE) {
    148     for (k = 0; k < *no_nodes; k++) {
    149       num_bits_read = 0;
    150       code = 0;
    151       code_found = 0;
    152       e = 0;
    153       while ((e < no_slope_code_entries) && (!code_found)) {
    154         for (m = 0; m < ptr_slope_code_table[e].size - num_bits_read; m++) {
    155           bit = impd_read_bits_buf(it_bit_buff, 1);
    156           if (it_bit_buff->error) return it_bit_buff->error;
    157           code = (code << 1) + bit;
    158           num_bits_read++;
    159         }
    160         while (num_bits_read == ptr_slope_code_table[e].size) {
    161           if (code == ptr_slope_code_table[e].code) {
    162             slope_value = ptr_slope_code_table[e].value;
    163             code_found = 1;
    164             break;
    165           }
    166           e++;
    167         }
    168       }
    169       str_node[k].slope = slope_value;
    170     }
    171   } else {
    172     for (k = 0; k < *no_nodes; k++) {
    173       str_node[k].slope = 0.0f;
    174     }
    175   }
    176   return (0);
    177 }
    178 
    179 WORD32 impd_dec_times(ia_bit_buf_struct* it_bit_buff,
    180                       ia_tables_struct* str_tables, WORD32 num_nodes,
    181                       WORD32 delta_tmin, WORD32 drc_frame_size,
    182                       WORD32 full_frame, WORD32 time_offset,
    183                       ia_node_struct* str_node) {
    184   WORD32 k, e, m;
    185   WORD32 bit;
    186   WORD32 num_bits_read;
    187   WORD32 code;
    188   WORD32 code_found = 0;
    189   WORD32 time_delta = 0;
    190   WORD32 time_offs = time_offset;
    191   ia_delta_time_code_table_entry_struct* delta_time_code_table =
    192       str_tables->delta_time_code_table;
    193   bool frame_end_flag;
    194   WORD32 node_time_tmp;
    195   bool node_res_flag;
    196   WORD32 exit_cnt;
    197   if (full_frame == 0) {
    198     frame_end_flag = impd_read_bits_buf(it_bit_buff, 1);
    199     if (it_bit_buff->error) return it_bit_buff->error;
    200   } else {
    201     frame_end_flag = 1;
    202   }
    203 
    204   if (frame_end_flag == 1) {
    205     node_res_flag = 0;
    206     for (k = 0; k < num_nodes - 1; k++) {
    207       num_bits_read = 0;
    208       code = 0;
    209       code_found = 0;
    210       exit_cnt = 0;
    211       e = 1;
    212       while ((e < N_DELTA_TIME_CODE_TABLE_ENTRIES_MAX) && (!code_found)) {
    213         exit_cnt++;
    214         if (exit_cnt > 100000) {
    215           return -1;
    216         }
    217         for (m = 0; m < delta_time_code_table[e].size - num_bits_read; m++) {
    218           bit = impd_read_bits_buf(it_bit_buff, 1);
    219           if (it_bit_buff->error) return it_bit_buff->error;
    220           code = (code << 1) + bit;
    221           num_bits_read++;
    222         }
    223         while (num_bits_read == delta_time_code_table[e].size) {
    224           if (code == delta_time_code_table[e].code) {
    225             time_delta = delta_time_code_table[e].value;
    226             code_found = 1;
    227             break;
    228           }
    229           e++;
    230         }
    231       }
    232       node_time_tmp = time_offs + time_delta * delta_tmin;
    233       if (node_time_tmp > drc_frame_size + time_offset) {
    234         if (node_res_flag == 0) {
    235           str_node[k].time = drc_frame_size + time_offset;
    236           node_res_flag = 1;
    237         }
    238         str_node[k + 1].time = node_time_tmp;
    239       } else {
    240         str_node[k].time = node_time_tmp;
    241       }
    242       time_offs = node_time_tmp;
    243     }
    244     if (node_res_flag == 0) {
    245       str_node[k].time = drc_frame_size + time_offset;
    246     }
    247   } else {
    248     for (k = 0; k < num_nodes; k++) {
    249       num_bits_read = 0;
    250       code = 0;
    251       code_found = 0;
    252       e = 1;
    253       exit_cnt = 0;
    254       while ((e < N_DELTA_TIME_CODE_TABLE_ENTRIES_MAX) && (!code_found)) {
    255         exit_cnt++;
    256         if (exit_cnt > 100000) {
    257           return (BITSTREAM_ERROR);
    258         }
    259         for (m = 0; m < delta_time_code_table[e].size - num_bits_read; m++) {
    260           bit = impd_read_bits_buf(it_bit_buff, 1);
    261           if (it_bit_buff->error) return it_bit_buff->error;
    262           code = (code << 1) + bit;
    263           num_bits_read++;
    264         }
    265         while (num_bits_read == delta_time_code_table[e].size) {
    266           if (code == delta_time_code_table[e].code) {
    267             time_delta = delta_time_code_table[e].value;
    268             code_found = 1;
    269             break;
    270           }
    271           e++;
    272         }
    273       }
    274       str_node[k].time = time_offs + time_delta * delta_tmin;
    275       time_offs = str_node[k].time;
    276     }
    277   }
    278   return (0);
    279 }
    280 
    281 WORD32 impd_drc_uni_gain_read(ia_bit_buf_struct* it_bit_buff,
    282                               ia_drc_bits_dec_struct* pstr_drc_uni_bs_dec,
    283                               ia_drc_config* drc_config,
    284                               ia_drc_gain_struct* pstr_uni_drc_gain) {
    285   WORD32 err = 0;
    286   WORD32 seq;
    287   static WORD32 pkt_loss_frame_cnt = 0;
    288   ia_spline_nodes_struct* str_spline_nodes = {0};
    289 
    290   {
    291     WORD32 gain_sequence_count =
    292         drc_config->str_p_loc_drc_coefficients_uni_drc[0].gain_sequence_count;
    293 
    294     for (seq = 0; seq < gain_sequence_count; seq++) {
    295       WORD32 index = drc_config->str_p_loc_drc_coefficients_uni_drc[0]
    296                          .gain_set_params_index_for_gain_sequence[seq];
    297       ia_gain_set_params_struct* gain_set_params =
    298           &(drc_config->str_p_loc_drc_coefficients_uni_drc
    299                 ->gain_set_params[index]);
    300       if (gain_set_params->gain_coding_profile ==
    301           GAIN_CODING_PROFILE_CONSTANT) {
    302         str_spline_nodes =
    303             &(pstr_uni_drc_gain->drc_gain_sequence[seq].str_spline_nodes[0]);
    304         str_spline_nodes->num_nodes = 1;
    305         str_spline_nodes->str_node[0].slope = 0.0;
    306         str_spline_nodes->str_node[0].time =
    307             (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size - 1;
    308         str_spline_nodes->str_node[0].loc_db_gain = 0.0f;
    309       } else {
    310         err = impd_parse_drc_gain_sequence(
    311             it_bit_buff, pstr_drc_uni_bs_dec, gain_set_params,
    312             &(pstr_uni_drc_gain->drc_gain_sequence[seq]));
    313         if (err) return (err);
    314       }
    315     }
    316   }
    317 
    318   if (it_bit_buff->ptr_bit_buf_base == NULL) {
    319     pkt_loss_frame_cnt++;
    320 
    321     if (pkt_loss_frame_cnt *
    322             (FLOAT32)pstr_drc_uni_bs_dec->ia_drc_params_struct.drc_frame_size /
    323             drc_config->sampling_rate >
    324         MAXPACKETLOSSTIME) {
    325       drc_config->apply_drc = 0;
    326     }
    327   } else {
    328     pstr_uni_drc_gain->uni_drc_gain_ext_flag =
    329         impd_read_bits_buf(it_bit_buff, 1);
    330     if (it_bit_buff->error) return it_bit_buff->error;
    331     if (pstr_uni_drc_gain->uni_drc_gain_ext_flag == 1) {
    332       err = impd_parse_uni_drc_gain_ext(it_bit_buff,
    333                                         &(pstr_uni_drc_gain->uni_drc_gain_ext));
    334       if (err) return (err);
    335     }
    336     pkt_loss_frame_cnt = 0;
    337     drc_config->apply_drc = 1;
    338   }
    339 
    340   return (0);
    341 }
    342 
    343 WORD32 impd_parse_uni_drc_gain_ext(
    344     ia_bit_buf_struct* it_bit_buff,
    345     ia_uni_drc_gain_ext_struct* uni_drc_gain_ext) {
    346   WORD32 i, k;
    347   WORD32 bit_size_len, ext_size_bits, bit_size, other_bit;
    348 
    349   k = 0;
    350   uni_drc_gain_ext->uni_drc_gain_ext_type[k] =
    351       impd_read_bits_buf(it_bit_buff, 4);
    352   if (it_bit_buff->error) return it_bit_buff->error;
    353   while (uni_drc_gain_ext->uni_drc_gain_ext_type[k] != UNIDRCGAINEXT_TERM) {
    354     bit_size_len = impd_read_bits_buf(it_bit_buff, 3);
    355     if (it_bit_buff->error) return it_bit_buff->error;
    356     ext_size_bits = bit_size_len + 4;
    357 
    358     bit_size = impd_read_bits_buf(it_bit_buff, ext_size_bits);
    359     if (it_bit_buff->error) return it_bit_buff->error;
    360     uni_drc_gain_ext->ext_bit_size[k] = bit_size + 1;
    361 
    362     switch (uni_drc_gain_ext->uni_drc_gain_ext_type[k]) {
    363       default:
    364         for (i = 0; i < uni_drc_gain_ext->ext_bit_size[k]; i++) {
    365           other_bit = impd_read_bits_buf(it_bit_buff, 1);
    366           if (it_bit_buff->error) return it_bit_buff->error;
    367         }
    368         break;
    369     }
    370     k++;
    371     uni_drc_gain_ext->uni_drc_gain_ext_type[k] =
    372         impd_read_bits_buf(it_bit_buff, 4);
    373     if (it_bit_buff->error) return it_bit_buff->error;
    374   }
    375 
    376   return (0);
    377 }
    378 
    379 WORD32 impd_parse_spline_nodes(ia_bit_buf_struct* it_bit_buff,
    380                                ia_drc_bits_dec_struct* pstr_drc_uni_bs_dec,
    381                                ia_gain_set_params_struct* gain_set_params,
    382                                ia_spline_nodes_struct* str_spline_nodes) {
    383   WORD32 err = 0;
    384   WORD32 time_offset;
    385   if (gain_set_params->time_alignment == 0) {
    386     time_offset = -1;
    387   } else {
    388     if (gain_set_params->time_delt_min_flag) {
    389       time_offset = -gain_set_params->time_delt_min_val +
    390                     (gain_set_params->time_delt_min_val - 1) / 2;
    391     } else {
    392       time_offset =
    393           -pstr_drc_uni_bs_dec->ia_drc_params_struct.delta_tmin_default +
    394           (pstr_drc_uni_bs_dec->ia_drc_params_struct.delta_tmin_default - 1) /
    395               2;
    396     }
    397   }
    398 
    399   if (it_bit_buff->ptr_bit_buf_base == NULL) {
    400     FLOAT32 prev_db_gain =
    401         str_spline_nodes->str_node[str_spline_nodes->num_nodes - 1].loc_db_gain;
    402     str_spline_nodes->drc_gain_coding_mode = 0;
    403 
    404     str_spline_nodes->num_nodes = 1;
    405 
    406     if (prev_db_gain < 0) {
    407       str_spline_nodes->str_node[0].loc_db_gain = prev_db_gain;
    408     } else {
    409       str_spline_nodes->str_node[0].loc_db_gain = 0.f;
    410     }
    411 
    412     str_spline_nodes->str_node[0].slope = 0.0;
    413     str_spline_nodes->str_node[0].time =
    414         (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size +
    415         time_offset;
    416   } else {
    417     str_spline_nodes->drc_gain_coding_mode = impd_read_bits_buf(it_bit_buff, 1);
    418     if (it_bit_buff->error == PROC_COMPLETE) {
    419       str_spline_nodes->drc_gain_coding_mode = 0;
    420       str_spline_nodes->str_node[0].slope = 0.0;
    421       str_spline_nodes->str_node[0].time =
    422           (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size +
    423           time_offset;
    424       str_spline_nodes->str_node[0].loc_db_gain =
    425           str_spline_nodes->str_node[str_spline_nodes->num_nodes - 1]
    426               .loc_db_gain;
    427       str_spline_nodes->num_nodes = 1;
    428     } else {
    429       if (it_bit_buff->error) return (it_bit_buff->error);
    430     }
    431     if (str_spline_nodes->drc_gain_coding_mode == 0) {
    432       str_spline_nodes->num_nodes = 1;
    433 
    434       err = impd_dec_initial_gain(it_bit_buff,
    435                                   gain_set_params->gain_coding_profile,
    436                                   &(str_spline_nodes->str_node[0].loc_db_gain));
    437       if (err) return (err);
    438 
    439       str_spline_nodes->str_node[0].slope = 0.0;
    440       str_spline_nodes->str_node[0].time =
    441           (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size +
    442           time_offset;
    443     } else {
    444       err = impd_dec_slopes(it_bit_buff, &str_spline_nodes->num_nodes,
    445                             gain_set_params->gain_interpolation_type,
    446                             str_spline_nodes->str_node);
    447       if (err) return (err);
    448       if (gain_set_params->time_delt_min_flag) {
    449         err = impd_dec_times(
    450             it_bit_buff, &gain_set_params->str_tables,
    451             str_spline_nodes->num_nodes, gain_set_params->time_delt_min_val,
    452             (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size,
    453             gain_set_params->full_frame, time_offset,
    454             str_spline_nodes->str_node);
    455         if (err) return (err);
    456         err = impd_dec_gains(it_bit_buff, str_spline_nodes->num_nodes,
    457                              gain_set_params->gain_coding_profile,
    458                              str_spline_nodes->str_node);
    459         if (err) return (err);
    460       } else {
    461         err = impd_dec_times(
    462             it_bit_buff, &pstr_drc_uni_bs_dec->tables_default,
    463             str_spline_nodes->num_nodes,
    464             (pstr_drc_uni_bs_dec->ia_drc_params_struct).delta_tmin_default,
    465             (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size,
    466             gain_set_params->full_frame, time_offset,
    467             str_spline_nodes->str_node);
    468         if (err) return (err);
    469         err = impd_dec_gains(it_bit_buff, str_spline_nodes->num_nodes,
    470                              gain_set_params->gain_coding_profile,
    471                              str_spline_nodes->str_node);
    472         if (err) return (err);
    473       }
    474     }
    475   }
    476   return (0);
    477 }
    478 
    479 WORD32 impd_parse_drc_gain_sequence(
    480     ia_bit_buf_struct* it_bit_buff, ia_drc_bits_dec_struct* pstr_drc_uni_bs_dec,
    481     ia_gain_set_params_struct* gain_set_params,
    482     ia_drc_gain_sequence_struct* drc_gain_sequence) {
    483   WORD32 err = 0, i;
    484   WORD32 prev_frame_time_buf[NODE_COUNT_MAX],
    485       cur_frame_time_buf[NODE_COUNT_MAX];
    486   WORD32 num_nodes_node_reservoir, num_nodes_cur, k, m;
    487 
    488   if (((pstr_drc_uni_bs_dec->ia_drc_params_struct).delay_mode ==
    489        DELAY_MODE_LOW_DELAY) &&
    490       (gain_set_params->full_frame == 0)) {
    491     return (PARAM_ERROR);
    492   }
    493   i = 0;
    494   {
    495     err = impd_parse_spline_nodes(it_bit_buff, pstr_drc_uni_bs_dec,
    496                                   gain_set_params,
    497                                   &(drc_gain_sequence->str_spline_nodes[i]));
    498     if (err) return (err);
    499 
    500     num_nodes_node_reservoir = 0;
    501     num_nodes_cur = 0;
    502     for (k = 0; k < drc_gain_sequence->str_spline_nodes[i].num_nodes; k++) {
    503       if (drc_gain_sequence->str_spline_nodes[i].str_node[k].time >=
    504           pstr_drc_uni_bs_dec->ia_drc_params_struct.drc_frame_size) {
    505         prev_frame_time_buf[num_nodes_node_reservoir] =
    506             drc_gain_sequence->str_spline_nodes[i].str_node[k].time;
    507         num_nodes_node_reservoir++;
    508       } else {
    509         cur_frame_time_buf[num_nodes_cur] =
    510             drc_gain_sequence->str_spline_nodes[i].str_node[k].time;
    511         num_nodes_cur++;
    512       }
    513     }
    514     for (k = 0; k < num_nodes_node_reservoir; k++) {
    515       drc_gain_sequence->str_spline_nodes[i].str_node[k].time =
    516           prev_frame_time_buf[k] -
    517           2 * pstr_drc_uni_bs_dec->ia_drc_params_struct.drc_frame_size;
    518     }
    519     for (m = 0; m < num_nodes_cur; m++, k++) {
    520       drc_gain_sequence->str_spline_nodes[i].str_node[k].time =
    521           cur_frame_time_buf[m];
    522     }
    523   }
    524   return (0);
    525 }
    526 WORD32 impd_parse_drc_ext_v1(ia_bit_buf_struct* it_bit_buff,
    527                              ia_drc_params_bs_dec_struct* ia_drc_params_struct,
    528                              ia_drc_config* drc_config,
    529                              ia_drc_config_ext* str_drc_config_ext) {
    530   WORD32 dwnmix_instructions_v1_flag;
    531   WORD32 dwnmix_instructions_v1_count;
    532   WORD32 drc_coeffs_and_instructions_uni_drc_v1_flag;
    533   WORD32 drc_coefficients_uni_drc_v1_count;
    534   WORD32 drc_instructions_uni_drc_v1_count;
    535 
    536   WORD32 i = 0, err = 0;
    537   const WORD32 version = 1;
    538 
    539   dwnmix_instructions_v1_flag = impd_read_bits_buf(it_bit_buff, 1);
    540   if (it_bit_buff->error) return it_bit_buff->error;
    541   if (dwnmix_instructions_v1_flag == 1) {
    542     dwnmix_instructions_v1_count = impd_read_bits_buf(it_bit_buff, 7);
    543     if (it_bit_buff->error) return it_bit_buff->error;
    544     for (i = 0; i < dwnmix_instructions_v1_count; i++) {
    545       err = impd_parse_dwnmix_instructions(
    546           it_bit_buff, version, ia_drc_params_struct,
    547           &drc_config->channel_layout,
    548           &drc_config
    549                ->dwnmix_instructions[i +
    550                                      drc_config->dwnmix_instructions_count]);
    551       if (err) return (err);
    552     }
    553     drc_config->dwnmix_instructions_count += dwnmix_instructions_v1_count;
    554   }
    555 
    556   drc_coeffs_and_instructions_uni_drc_v1_flag =
    557       impd_read_bits_buf(it_bit_buff, 1);
    558   if (it_bit_buff->error) return it_bit_buff->error;
    559   if (drc_coeffs_and_instructions_uni_drc_v1_flag == 1) {
    560     drc_coefficients_uni_drc_v1_count = impd_read_bits_buf(it_bit_buff, 3);
    561     if (it_bit_buff->error) return it_bit_buff->error;
    562     for (i = 0; i < drc_coefficients_uni_drc_v1_count; i++) {
    563       err = impd_drc_parse_coeff(
    564           it_bit_buff, version, ia_drc_params_struct,
    565           &drc_config->str_p_loc_drc_coefficients_uni_drc
    566                [i + drc_config->drc_coefficients_drc_count]);
    567       if (err) return (err);
    568     }
    569     drc_config->drc_coefficients_drc_count += drc_coefficients_uni_drc_v1_count;
    570 
    571     drc_instructions_uni_drc_v1_count = impd_read_bits_buf(it_bit_buff, 6);
    572     if (it_bit_buff->error) return it_bit_buff->error;
    573     for (i = 0; i < drc_instructions_uni_drc_v1_count; i++) {
    574       err = impd_parse_drc_instructions_uni_drc(
    575           it_bit_buff, version, drc_config,
    576           &drc_config->str_drc_instruction_str
    577                [i + drc_config->drc_instructions_uni_drc_count]);
    578       if (err) return (err);
    579     }
    580     drc_config->drc_instructions_uni_drc_count +=
    581         drc_instructions_uni_drc_v1_count;
    582   }
    583 
    584   str_drc_config_ext->loud_eq_instructions_flag =
    585       impd_read_bits_buf(it_bit_buff, 1);
    586   if (it_bit_buff->error) return it_bit_buff->error;
    587   if (str_drc_config_ext->loud_eq_instructions_flag == 1) {
    588     str_drc_config_ext->loud_eq_instructions_count =
    589         impd_read_bits_buf(it_bit_buff, 4);
    590     if (it_bit_buff->error) return it_bit_buff->error;
    591     for (i = 0; i < str_drc_config_ext->loud_eq_instructions_count; i++) {
    592       err = impd_parse_loud_eq_instructions(
    593           it_bit_buff, &str_drc_config_ext->loud_eq_instructions[i]);
    594       if (err) return (err);
    595     }
    596   } else {
    597     str_drc_config_ext->loud_eq_instructions_count = 0;
    598   }
    599 
    600   str_drc_config_ext->eq_flag = impd_read_bits_buf(it_bit_buff, 1);
    601   if (it_bit_buff->error) return it_bit_buff->error;
    602   if (str_drc_config_ext->eq_flag == 1) {
    603     err = impd_parse_eq_coefficients(it_bit_buff,
    604                                      &str_drc_config_ext->str_eq_coeff);
    605     if (err) return (err);
    606     str_drc_config_ext->eq_instructions_count =
    607         impd_read_bits_buf(it_bit_buff, 4);
    608     if (it_bit_buff->error) return it_bit_buff->error;
    609     for (i = 0; i < str_drc_config_ext->eq_instructions_count; i++) {
    610       err = impd_parse_eq_instructions(
    611           it_bit_buff, drc_config, &str_drc_config_ext->str_eq_instructions[i]);
    612       if (err) return (err);
    613     }
    614   }
    615   return 0;
    616 }
    617 
    618 WORD32 impd_parse_filt_block(ia_bit_buf_struct* it_bit_buff,
    619                              ia_filt_block_struct* str_filter_block,
    620                              WORD32 block_count) {
    621   //    WORD32 err = 0;
    622   WORD32 k, j, temp;
    623   ia_filt_ele_struct* str_filter_element;
    624 
    625   for (j = 0; j < block_count; j++) {
    626     str_filter_block->filter_element_count = impd_read_bits_buf(it_bit_buff, 6);
    627     if (it_bit_buff->error) return it_bit_buff->error;
    628 
    629     str_filter_element = &str_filter_block->str_filter_element[0];
    630     for (k = 0; k < str_filter_block->filter_element_count; k++) {
    631       temp = impd_read_bits_buf(it_bit_buff, 7);
    632       if (it_bit_buff->error) return it_bit_buff->error;
    633 
    634       str_filter_element->filt_ele_idx = (temp & 0x7E) >> 1;
    635       str_filter_element->filt_ele_gain_flag = temp & 1;
    636       ;
    637 
    638       if (str_filter_element->filt_ele_gain_flag) {
    639         WORD32 bs_filter_element_gain;
    640         bs_filter_element_gain = impd_read_bits_buf(it_bit_buff, 10);
    641         if (it_bit_buff->error) return it_bit_buff->error;
    642         str_filter_element->filt_ele_gain =
    643             bs_filter_element_gain * 0.125f - 96.0f;
    644       }
    645 
    646       str_filter_element++;
    647     }
    648     str_filter_block++;
    649   }
    650   return (0);
    651 }
    652 
    653 WORD32 impd_parse_unique_td_filt_ele(
    654     ia_bit_buf_struct* it_bit_buff,
    655     ia_unique_td_filt_element* unique_td_filt_ele,
    656     WORD32 td_filter_element_count) {
    657   WORD32 m, sign, j, temp;
    658   FLOAT32 tmp;
    659 
    660   for (j = 0; j < td_filter_element_count; j++) {
    661     unique_td_filt_ele->eq_filter_format = impd_read_bits_buf(it_bit_buff, 1);
    662     if (it_bit_buff->error) return it_bit_buff->error;
    663 
    664     if (unique_td_filt_ele->eq_filter_format == 0) {
    665       WORD32 bs_real_zero_radius, bs_generic_zero_radius, bs_generic_zero_angle;
    666       WORD32 bs_real_pole_radius, bs_cmplx_pole_radius, bs_cmplx_pole_angle;
    667       WORD32 bs_real_zero_radius_one_count;
    668 
    669       temp = impd_read_bits_buf(it_bit_buff, 23);
    670       if (it_bit_buff->error) return it_bit_buff->error;
    671 
    672       bs_real_zero_radius_one_count = (temp >> 20) & 7;
    673 
    674       unique_td_filt_ele->bs_real_zero_radius_one_count =
    675           2 * bs_real_zero_radius_one_count;
    676       unique_td_filt_ele->real_zero_count = (temp & 0xFC000) >> 14;
    677 
    678       unique_td_filt_ele->generic_zero_count = (temp & 0x3F00) >> 8;
    679 
    680       unique_td_filt_ele->real_pole_count = (temp & 0xF0) >> 4;
    681 
    682       unique_td_filt_ele->cmplx_pole_count = temp & 0xF;
    683 
    684       temp = impd_read_bits_buf(
    685           it_bit_buff, unique_td_filt_ele->bs_real_zero_radius_one_count);
    686       if (it_bit_buff->error) return it_bit_buff->error;
    687 
    688       for (m = unique_td_filt_ele->bs_real_zero_radius_one_count - 1; m >= 0;
    689            m--) {
    690         unique_td_filt_ele->zero_sign[m] = (temp & 1);
    691         temp = temp >> 1;
    692       }
    693 
    694       for (m = 0; m < unique_td_filt_ele->real_zero_count; m++) {
    695         temp = impd_read_bits_buf(it_bit_buff, 8);
    696         if (it_bit_buff->error) return it_bit_buff->error;
    697 
    698         bs_real_zero_radius = (temp & 0xFE) >> 1;
    699 
    700         sign = temp & 0x01;
    701 
    702         tmp = 1.0f - zero_pole_radius_tbl[bs_real_zero_radius];
    703 
    704         sign = sign << 1;
    705 
    706         unique_td_filt_ele->real_zero_radius[m] = (1 - sign) * tmp;
    707       }
    708       for (m = 0; m < unique_td_filt_ele->generic_zero_count; m++) {
    709         temp = impd_read_bits_buf(it_bit_buff, 14);
    710         if (it_bit_buff->error) return it_bit_buff->error;
    711 
    712         bs_generic_zero_radius = (temp & 0x3F80) >> 7;
    713 
    714         unique_td_filt_ele->generic_zero_radius[m] =
    715             1.0f - zero_pole_radius_tbl[bs_generic_zero_radius];
    716 
    717         bs_generic_zero_angle = (temp & 0x7F);
    718 
    719         unique_td_filt_ele->generic_zero_angle[m] =
    720             zero_pole_angle_tbl[bs_generic_zero_angle];
    721       }
    722       for (m = 0; m < unique_td_filt_ele->real_pole_count; m++) {
    723         temp = impd_read_bits_buf(it_bit_buff, 8);
    724         if (it_bit_buff->error) return it_bit_buff->error;
    725 
    726         bs_real_pole_radius = (temp & 0xFE) >> 1;
    727 
    728         sign = temp & 0x01;
    729 
    730         tmp = 1.0f - zero_pole_radius_tbl[bs_real_pole_radius];
    731 
    732         sign = sign << 1;
    733 
    734         unique_td_filt_ele->real_pole_radius[m] = (1 - sign) * tmp;
    735       }
    736       for (m = 0; m < unique_td_filt_ele->cmplx_pole_count; m++) {
    737         temp = impd_read_bits_buf(it_bit_buff, 14);
    738 
    739         if (it_bit_buff->error) return it_bit_buff->error;
    740 
    741         bs_cmplx_pole_radius = (temp & 0x3F80) >> 7;
    742 
    743         unique_td_filt_ele->complex_pole_radius[m] =
    744             1.0f - zero_pole_radius_tbl[bs_cmplx_pole_radius];
    745 
    746         bs_cmplx_pole_angle = (temp & 0x7F);
    747 
    748         unique_td_filt_ele->complex_pole_angle[m] =
    749             zero_pole_angle_tbl[bs_cmplx_pole_angle];
    750       }
    751     } else {
    752       temp = impd_read_bits_buf(it_bit_buff, 8);
    753       if (it_bit_buff->error) return it_bit_buff->error;
    754 
    755       unique_td_filt_ele->fir_filt_order = (temp & 0xFE) >> 1;
    756 
    757       unique_td_filt_ele->fir_symmetry = temp & 0x01;
    758 
    759       for (m = 0; m < unique_td_filt_ele->fir_filt_order / 2 + 1; m++) {
    760         WORD32 sign, bs_fir_coeff;
    761         FLOAT32 tmp;
    762 
    763         temp = impd_read_bits_buf(it_bit_buff, 11);
    764         if (it_bit_buff->error) return it_bit_buff->error;
    765         sign = (temp >> 10) & 0x01;
    766 
    767         bs_fir_coeff = temp & 0x03FF;
    768 
    769         tmp = (FLOAT32)pow(10.0f, -0.05f * bs_fir_coeff * 0.0625f);
    770 
    771         sign = sign << 1;
    772 
    773         unique_td_filt_ele->fir_coeff[m] = (1 - sign) * tmp;
    774       }
    775     }
    776     unique_td_filt_ele++;
    777   }
    778   return (0);
    779 }
    780 
    781 WORD32 impd_decode_eq_slope_code(ia_bit_buf_struct* it_bit_buff,
    782                                  FLOAT32* eq_slope, WORD32 num_eq_nodes) {
    783   WORD32 bits = 0;
    784   WORD32 k;
    785 
    786   for (k = 0; k < num_eq_nodes; k++) {
    787     bits = impd_read_bits_buf(it_bit_buff, 1);
    788     if (it_bit_buff->error) return it_bit_buff->error;
    789     if (bits == 0x1) {
    790       *eq_slope = 0.0f;
    791     } else {
    792       bits = impd_read_bits_buf(it_bit_buff, 4);
    793       if (it_bit_buff->error) return it_bit_buff->error;
    794       *eq_slope = eq_slope_tbl[bits];
    795     }
    796     eq_slope++;
    797   }
    798   return (0);
    799 }
    800 
    801 WORD32
    802 impd_decode_gain_initial_code(ia_bit_buf_struct* it_bit_buff,
    803                               FLOAT32* eq_gain_initial) {
    804   WORD32 bits, bits1;
    805 
    806   bits1 = impd_read_bits_buf(it_bit_buff, 2);
    807   if (it_bit_buff->error) return it_bit_buff->error;
    808 
    809   switch (bits1) {
    810     case 0x0:
    811       bits = impd_read_bits_buf(it_bit_buff, 5);
    812       if (it_bit_buff->error) return it_bit_buff->error;
    813       *eq_gain_initial = 0.5f * bits - 8.0f;
    814       break;
    815     case 0x1:
    816     case 0x2:
    817 
    818       bits = impd_read_bits_buf(it_bit_buff, 4);
    819       if (it_bit_buff->error) return it_bit_buff->error;
    820       if (bits < 8) {
    821         *eq_gain_initial = bits1 * bits - bits1 * 16.0f;
    822       } else {
    823         *eq_gain_initial = (FLOAT32)bits1 * bits;
    824       }
    825       break;
    826 
    827     case 0x3:
    828       bits = impd_read_bits_buf(it_bit_buff, 3);
    829       if (it_bit_buff->error) return it_bit_buff->error;
    830       *eq_gain_initial = 4.0f * bits - 64.0f;
    831       break;
    832 
    833     default:
    834       break;
    835   }
    836   return (0);
    837 }
    838 
    839 WORD32 impd_parse_eq_subband_gain_spline(
    840     ia_bit_buf_struct* it_bit_buff,
    841     ia_eq_subband_gain_spline_struct* str_eq_subband_gain_spline,
    842     WORD32 eq_subband_gains_count) {
    843   WORD32 err = 0, eq_nodes_cnt, j, k, bits, *eq_freq_delta;
    844   FLOAT32* peq_gain_delta;
    845 
    846   for (j = 0; j < eq_subband_gains_count; j++) {
    847     eq_nodes_cnt = impd_read_bits_buf(it_bit_buff, 5);
    848     if (it_bit_buff->error) return it_bit_buff->error;
    849 
    850     str_eq_subband_gain_spline->num_eq_nodes = eq_nodes_cnt + 2;
    851 
    852     err = impd_decode_eq_slope_code(it_bit_buff,
    853                                     &(str_eq_subband_gain_spline->eq_slope[0]),
    854                                     str_eq_subband_gain_spline->num_eq_nodes);
    855     if (err) return (err);
    856 
    857     eq_freq_delta = &(str_eq_subband_gain_spline->eq_freq_delta[1]);
    858     for (k = 1; k < str_eq_subband_gain_spline->num_eq_nodes; k++) {
    859       bits = impd_read_bits_buf(it_bit_buff, 4);
    860       if (it_bit_buff->error) return it_bit_buff->error;
    861       *eq_freq_delta = bits + 1;
    862       eq_freq_delta++;
    863     }
    864 
    865     err = impd_decode_gain_initial_code(
    866         it_bit_buff, &(str_eq_subband_gain_spline->eq_gain_initial));
    867     if (err) return (err);
    868 
    869     peq_gain_delta = &(str_eq_subband_gain_spline->eq_gain_delta[1]);
    870     for (k = 1; k < str_eq_subband_gain_spline->num_eq_nodes; k++) {
    871       bits = impd_read_bits_buf(it_bit_buff, 5);
    872       if (it_bit_buff->error) return it_bit_buff->error;
    873 
    874       *peq_gain_delta = eq_gain_delta_tbl[bits];
    875       peq_gain_delta++;
    876     }
    877     str_eq_subband_gain_spline++;
    878   }
    879   return (0);
    880 }
    881 
    882 WORD32 impd_parse_eq_subband_gain_vector(
    883     ia_bit_buf_struct* it_bit_buff, const WORD32 eq_subband_gain_count,
    884     ia_eq_subband_gain_vector* str_eq_subband_gain_vector,
    885     WORD32 eq_subband_gains_count) {
    886   WORD32 m, k, temp;
    887 
    888   for (k = 0; k < eq_subband_gains_count; k++) {
    889     for (m = 0; m < eq_subband_gain_count; m++) {
    890       WORD32 sign, bs_eq_subband_gain;
    891       temp = impd_read_bits_buf(it_bit_buff, 9);
    892       if (it_bit_buff->error) return it_bit_buff->error;
    893 
    894       sign = (temp >> 8) & 1;
    895       bs_eq_subband_gain = temp & 0x7F;
    896 
    897       sign = sign << 1;
    898       str_eq_subband_gain_vector->eq_subband_gain[m] =
    899           ((1 - sign) * bs_eq_subband_gain) * 0.125f;
    900     }
    901     str_eq_subband_gain_vector++;
    902   }
    903   return (0);
    904 }
    905 
    906 WORD32 impd_parse_eq_coefficients(ia_bit_buf_struct* it_bit_buff,
    907                                   ia_eq_coeff_struct* str_eq_coeff) {
    908   WORD32 err = 0;
    909   WORD32 eq_gain_cnt, mu, nu, temp;
    910   WORD32 subband_gain_len_tbl[7] = {0, 32, 39, 64, 71, 128, 135};
    911 
    912   str_eq_coeff->eq_delay_max_present = impd_read_bits_buf(it_bit_buff, 1);
    913   if (it_bit_buff->error) return it_bit_buff->error;
    914 
    915   if (str_eq_coeff->eq_delay_max_present) {
    916     mu = impd_read_bits_buf(it_bit_buff, 5);
    917     if (it_bit_buff->error) return it_bit_buff->error;
    918     nu = impd_read_bits_buf(it_bit_buff, 3);
    919     if (it_bit_buff->error) return it_bit_buff->error;
    920     str_eq_coeff->eq_delay_max = 16 * mu * (1 << nu);
    921   }
    922 
    923   str_eq_coeff->unique_filter_block_count = impd_read_bits_buf(it_bit_buff, 6);
    924   if (it_bit_buff->error) return it_bit_buff->error;
    925 
    926   err = impd_parse_filt_block(it_bit_buff, &(str_eq_coeff->str_filter_block[0]),
    927                               str_eq_coeff->unique_filter_block_count);
    928   if (err) return (err);
    929 
    930   str_eq_coeff->unique_td_filter_element_count =
    931       impd_read_bits_buf(it_bit_buff, 6);
    932   if (it_bit_buff->error) return it_bit_buff->error;
    933 
    934   err = impd_parse_unique_td_filt_ele(
    935       it_bit_buff, &(str_eq_coeff->unique_td_filt_ele[0]),
    936       str_eq_coeff->unique_td_filter_element_count);
    937   if (err) return (err);
    938 
    939   str_eq_coeff->unique_eq_subband_gains_count =
    940       impd_read_bits_buf(it_bit_buff, 6);
    941   if (it_bit_buff->error) return it_bit_buff->error;
    942 
    943   if (str_eq_coeff->unique_eq_subband_gains_count > 0) {
    944     temp = impd_read_bits_buf(it_bit_buff, 5);
    945     if (it_bit_buff->error) return it_bit_buff->error;
    946     str_eq_coeff->eq_subband_gain_representation = (temp >> 4) & 0x01;
    947 
    948     str_eq_coeff->eq_subband_gain_format = temp & 0x0F;
    949 
    950     if (str_eq_coeff->eq_subband_gain_format == GAINFORMAT_UNIFORM) {
    951       eq_gain_cnt = impd_read_bits_buf(it_bit_buff, 8);
    952       if (it_bit_buff->error) return it_bit_buff->error;
    953       str_eq_coeff->eq_subband_gain_count = eq_gain_cnt + 1;
    954 
    955     } else
    956       str_eq_coeff->eq_subband_gain_count =
    957           subband_gain_len_tbl[str_eq_coeff->eq_subband_gain_format];
    958 
    959     if (str_eq_coeff->eq_subband_gain_representation == 1) {
    960       err = impd_parse_eq_subband_gain_spline(
    961           it_bit_buff, &(str_eq_coeff->str_eq_subband_gain_spline[0]),
    962           str_eq_coeff->unique_eq_subband_gains_count);
    963       if (err) return (err);
    964     } else {
    965       err = impd_parse_eq_subband_gain_vector(
    966           it_bit_buff, str_eq_coeff->eq_subband_gain_count,
    967           &(str_eq_coeff->str_eq_subband_gain_vector[0]),
    968           str_eq_coeff->unique_eq_subband_gains_count);
    969       if (err) return (err);
    970     }
    971   }
    972 
    973   return (0);
    974 }
    975 
    976 WORD32 impd_parser_td_filter_cascade(
    977     ia_bit_buf_struct* it_bit_buff,
    978     ia_eq_instructions_struct* str_eq_instructions,
    979     ia_td_filter_cascade_struct* str_td_filter_cascade) {
    980   // WORD32 err=0,
    981   WORD32 i, ii, k;
    982   WORD32 eq_cascade_gain;
    983   ia_filter_block_refs_struct* str_filter_block_refs =
    984       &(str_td_filter_cascade->str_filter_block_refs[0]);
    985 
    986   for (i = 0; i < str_eq_instructions->eq_ch_group_count; i++) {
    987     str_td_filter_cascade->eq_cascade_gain_present[i] =
    988         impd_read_bits_buf(it_bit_buff, 1);
    989     if (it_bit_buff->error) return it_bit_buff->error;
    990     if (str_td_filter_cascade->eq_cascade_gain_present[i]) {
    991       eq_cascade_gain = impd_read_bits_buf(it_bit_buff, 10);
    992       if (it_bit_buff->error) return it_bit_buff->error;
    993       str_td_filter_cascade->eq_cascade_gain[i] =
    994           0.125f * eq_cascade_gain - 96.0f;
    995     } else {
    996       str_td_filter_cascade->eq_cascade_gain[i] = 0.0f;
    997     }
    998 
    999     str_filter_block_refs->filter_block_count =
   1000         impd_read_bits_buf(it_bit_buff, 4);
   1001     if (it_bit_buff->error) return it_bit_buff->error;
   1002     for (ii = 0; ii < str_filter_block_refs->filter_block_count; ii++) {
   1003       str_filter_block_refs->filter_block_index[ii] =
   1004           impd_read_bits_buf(it_bit_buff, 7);
   1005       if (it_bit_buff->error) return it_bit_buff->error;
   1006     }
   1007     str_filter_block_refs++;
   1008   }
   1009 
   1010   str_td_filter_cascade->eq_phase_alignment_present =
   1011       impd_read_bits_buf(it_bit_buff, 1);
   1012   if (it_bit_buff->error) return it_bit_buff->error;
   1013 
   1014   if (str_td_filter_cascade->eq_phase_alignment_present) {
   1015     for (i = 0; i < str_eq_instructions->eq_ch_group_count; i++) {
   1016       for (k = i + 1; k < str_eq_instructions->eq_ch_group_count; k++) {
   1017         str_td_filter_cascade->eq_phase_alignment[i][k] =
   1018             impd_read_bits_buf(it_bit_buff, 1);
   1019         if (it_bit_buff->error) return it_bit_buff->error;
   1020       }
   1021     }
   1022 
   1023   } else {
   1024     for (i = 0; i < str_eq_instructions->eq_ch_group_count; i++) {
   1025       for (k = i + 1; k < str_eq_instructions->eq_ch_group_count; k++)
   1026         str_td_filter_cascade->eq_phase_alignment[i][k] = 1;
   1027     }
   1028   }
   1029 
   1030   return (0);
   1031 }
   1032 
   1033 WORD32 impd_parse_eq_instructions(
   1034     ia_bit_buf_struct* it_bit_buff, ia_drc_config* drc_config,
   1035     ia_eq_instructions_struct* str_eq_instructions) {
   1036   WORD32 i, k, channel_count, temp;
   1037   WORD32 dmix_id_present, additional_dmix_id_present,
   1038       additional_dmix_id_cnt = 0;
   1039   WORD32 additional_drc_set_id_present, additional_drc_set_id_cnt;
   1040 
   1041   temp = impd_read_bits_buf(it_bit_buff, 11);
   1042   if (it_bit_buff->error) return it_bit_buff->error;
   1043 
   1044   str_eq_instructions->eq_set_id = (temp >> 5) & 0x3F;
   1045 
   1046   str_eq_instructions->eq_set_complexity_level = (temp >> 1) & 0x0F;
   1047 
   1048   dmix_id_present = temp & 0x01;
   1049 
   1050   if (dmix_id_present) {
   1051     temp = impd_read_bits_buf(it_bit_buff, 9);
   1052     if (it_bit_buff->error) return it_bit_buff->error;
   1053 
   1054     str_eq_instructions->downmix_id[0] = (temp >> 2) & 0x7F;
   1055 
   1056     str_eq_instructions->eq_apply_to_downmix = (temp >> 1) & 0x01;
   1057 
   1058     additional_dmix_id_present = temp & 0x01;
   1059 
   1060     if (additional_dmix_id_present) {
   1061       additional_dmix_id_cnt = impd_read_bits_buf(it_bit_buff, 7);
   1062       if (it_bit_buff->error) return it_bit_buff->error;
   1063 
   1064       for (i = 1; i < additional_dmix_id_cnt + 1; i++) {
   1065         str_eq_instructions->downmix_id[i] = impd_read_bits_buf(it_bit_buff, 7);
   1066         if (it_bit_buff->error) return it_bit_buff->error;
   1067       }
   1068     }
   1069   } else {
   1070     str_eq_instructions->downmix_id[0] = 0;
   1071   }
   1072 
   1073   str_eq_instructions->dwnmix_id_count = 1 + additional_dmix_id_cnt;
   1074 
   1075   temp = impd_read_bits_buf(it_bit_buff, 7);
   1076   if (it_bit_buff->error) return it_bit_buff->error;
   1077 
   1078   str_eq_instructions->drc_set_id[0] = (temp >> 1) & 0x3F;
   1079 
   1080   additional_drc_set_id_present = temp & 0x01;
   1081 
   1082   if (additional_drc_set_id_present) {
   1083     additional_drc_set_id_cnt = impd_read_bits_buf(it_bit_buff, 6);
   1084     if (it_bit_buff->error) return it_bit_buff->error;
   1085 
   1086     for (i = 1; i < additional_drc_set_id_cnt + 1; i++) {
   1087       str_eq_instructions->drc_set_id[i] = impd_read_bits_buf(it_bit_buff, 6);
   1088       if (it_bit_buff->error) return it_bit_buff->error;
   1089     }
   1090   } else {
   1091     additional_drc_set_id_cnt = 0;
   1092   }
   1093   str_eq_instructions->drc_set_id_count = 1 + additional_drc_set_id_cnt;
   1094 
   1095   temp = impd_read_bits_buf(it_bit_buff, 17);
   1096   if (it_bit_buff->error) return it_bit_buff->error;
   1097 
   1098   str_eq_instructions->eq_set_purpose = (temp >> 1) & 0xFFFF;
   1099 
   1100   str_eq_instructions->depends_on_eq_set_present = temp & 0x01;
   1101 
   1102   if (str_eq_instructions->depends_on_eq_set_present) {
   1103     str_eq_instructions->depends_on_eq_set = impd_read_bits_buf(it_bit_buff, 6);
   1104     if (it_bit_buff->error) return it_bit_buff->error;
   1105   } else {
   1106     str_eq_instructions->no_independent_eq_use =
   1107         impd_read_bits_buf(it_bit_buff, 1);
   1108     if (it_bit_buff->error) return it_bit_buff->error;
   1109   }
   1110 
   1111   str_eq_instructions->eq_channel_count = channel_count =
   1112       drc_config->channel_layout.base_channel_count;
   1113 
   1114   if ((dmix_id_present == 1) &&
   1115       (str_eq_instructions->eq_apply_to_downmix == 1) &&
   1116       (str_eq_instructions->downmix_id[0] != 0) &&
   1117       (str_eq_instructions->downmix_id[0] != ID_FOR_ANY_DOWNMIX) &&
   1118       (str_eq_instructions->dwnmix_id_count == 1)) {
   1119     for (i = 0; i < drc_config->dwnmix_instructions_count; i++) {
   1120       if (str_eq_instructions->downmix_id[0] ==
   1121           drc_config->dwnmix_instructions[i].downmix_id)
   1122         break;
   1123     }
   1124     if (i == drc_config->dwnmix_instructions_count) {
   1125       return UNEXPECTED_ERROR;
   1126     }
   1127 
   1128     str_eq_instructions->eq_channel_count = channel_count =
   1129         drc_config->dwnmix_instructions[i].target_channel_count;
   1130   } else if ((str_eq_instructions->downmix_id[0] == ID_FOR_ANY_DOWNMIX) ||
   1131              (str_eq_instructions->dwnmix_id_count > 1)) {
   1132     channel_count = 1;
   1133   }
   1134 
   1135   str_eq_instructions->eq_ch_group_count = 0;
   1136 
   1137   for (i = 0; i < channel_count; i++) {
   1138     WORD32 new_group = 1;
   1139     str_eq_instructions->eq_ch_group_of_channel[i] =
   1140         impd_read_bits_buf(it_bit_buff, 7);
   1141     if (it_bit_buff->error) return it_bit_buff->error;
   1142 
   1143     for (k = 0; k < i; k++) {
   1144       if (str_eq_instructions->eq_ch_group_of_channel[i] ==
   1145           str_eq_instructions->eq_ch_group_of_channel[k]) {
   1146         new_group = 0;
   1147         break;
   1148       }
   1149     }
   1150 
   1151     if (new_group == 1) {
   1152       str_eq_instructions->eq_ch_group_count += 1;
   1153     }
   1154   }
   1155 
   1156   str_eq_instructions->td_filter_cascade_present =
   1157       impd_read_bits_buf(it_bit_buff, 1);
   1158   if (it_bit_buff->error) return it_bit_buff->error;
   1159 
   1160   if (str_eq_instructions->td_filter_cascade_present) {
   1161     impd_parser_td_filter_cascade(
   1162         it_bit_buff, str_eq_instructions,
   1163         &(str_eq_instructions->str_td_filter_cascade));
   1164   }
   1165 
   1166   str_eq_instructions->subband_gains_present =
   1167       impd_read_bits_buf(it_bit_buff, 1);
   1168   if (it_bit_buff->error) return it_bit_buff->error;
   1169 
   1170   if (str_eq_instructions->subband_gains_present) {
   1171     for (i = 0; i < str_eq_instructions->eq_ch_group_count; i++) {
   1172       str_eq_instructions->subband_gains_index[i] =
   1173           impd_read_bits_buf(it_bit_buff, 6);
   1174       if (it_bit_buff->error) return it_bit_buff->error;
   1175     }
   1176   }
   1177 
   1178   str_eq_instructions->eq_transition_duration_present =
   1179       impd_read_bits_buf(it_bit_buff, 1);
   1180   if (it_bit_buff->error) return it_bit_buff->error;
   1181 
   1182   if (str_eq_instructions->eq_transition_duration_present) {
   1183     WORD32 bs_eq_transition_duration;
   1184     bs_eq_transition_duration = impd_read_bits_buf(it_bit_buff, 5);
   1185     if (it_bit_buff->error) return it_bit_buff->error;
   1186 
   1187     str_eq_instructions->eq_transition_duration = (WORD32)(
   1188         0.001f *
   1189         (FLOAT32)pow(2.0f, 2.0f + bs_eq_transition_duration * 0.0625f));
   1190   }
   1191   return (0);
   1192 }
   1193 
   1194 WORD32 impd_parse_loud_eq_instructions(
   1195     ia_bit_buf_struct* it_bit_buff,
   1196     ia_loud_eq_instructions_struct* loud_eq_instructions) {
   1197   WORD32 i, bs_loud_eq_scaling, bs_loud_eq_offset, temp;
   1198   WORD32 dmix_id_present, additional_dmix_id_present,
   1199       additional_dmix_id_cnt = 0;
   1200   WORD32 drc_set_id_present, additional_drc_set_id_present,
   1201       additional_drc_set_id_cnt = 0;
   1202   WORD32 eq_set_id_present, additional_eq_set_id_present,
   1203       additional_eq_set_id_cnt = 0;
   1204 
   1205   temp = impd_read_bits_buf(it_bit_buff, 9);
   1206   if (it_bit_buff->error) return it_bit_buff->error;
   1207   loud_eq_instructions->loud_eq_set_id = (temp >> 5) & 0x0F;
   1208 
   1209   loud_eq_instructions->drc_location = (temp >> 1) & 0x0F;
   1210 
   1211   dmix_id_present = temp & 0x01;
   1212 
   1213   if (dmix_id_present) {
   1214     temp = impd_read_bits_buf(it_bit_buff, 8);
   1215     if (it_bit_buff->error) return it_bit_buff->error;
   1216 
   1217     loud_eq_instructions->downmix_id[0] = (temp >> 1) & 0x7F;
   1218 
   1219     additional_dmix_id_present = temp & 0x01;
   1220 
   1221     if (additional_dmix_id_present) {
   1222       additional_dmix_id_cnt = impd_read_bits_buf(it_bit_buff, 7);
   1223       if (it_bit_buff->error) return it_bit_buff->error;
   1224 
   1225       for (i = 1; i < additional_dmix_id_cnt + 1; i++) {
   1226         loud_eq_instructions->downmix_id[i] =
   1227             impd_read_bits_buf(it_bit_buff, 7);
   1228         if (it_bit_buff->error) return it_bit_buff->error;
   1229       }
   1230     }
   1231   } else {
   1232     loud_eq_instructions->downmix_id[0] = 0;
   1233   }
   1234 
   1235   loud_eq_instructions->dwnmix_id_count = 1 + additional_dmix_id_cnt;
   1236 
   1237   drc_set_id_present = impd_read_bits_buf(it_bit_buff, 1);
   1238   if (it_bit_buff->error) return it_bit_buff->error;
   1239 
   1240   if (drc_set_id_present) {
   1241     temp = impd_read_bits_buf(it_bit_buff, 7);
   1242     if (it_bit_buff->error) return it_bit_buff->error;
   1243 
   1244     loud_eq_instructions->drc_set_id[0] = (temp >> 1) & 0x3F;
   1245 
   1246     additional_drc_set_id_present = temp & 0x01;
   1247 
   1248     if (additional_drc_set_id_present) {
   1249       additional_drc_set_id_cnt = impd_read_bits_buf(it_bit_buff, 6);
   1250       if (it_bit_buff->error) return it_bit_buff->error;
   1251 
   1252       for (i = 1; i < additional_drc_set_id_cnt + 1; i++) {
   1253         loud_eq_instructions->drc_set_id[i] =
   1254             impd_read_bits_buf(it_bit_buff, 6);
   1255         if (it_bit_buff->error) return it_bit_buff->error;
   1256       }
   1257     }
   1258   } else {
   1259     loud_eq_instructions->drc_set_id[0] = 0;
   1260   }
   1261 
   1262   loud_eq_instructions->drc_set_id_count = 1 + additional_drc_set_id_cnt;
   1263 
   1264   eq_set_id_present = impd_read_bits_buf(it_bit_buff, 1);
   1265 
   1266   if (it_bit_buff->error) return it_bit_buff->error;
   1267 
   1268   if (eq_set_id_present) {
   1269     temp = impd_read_bits_buf(it_bit_buff, 7);
   1270     if (it_bit_buff->error) return it_bit_buff->error;
   1271 
   1272     loud_eq_instructions->eq_set_id[0] = (temp >> 1) & 0x3F;
   1273 
   1274     additional_eq_set_id_present = temp & 0x01;
   1275 
   1276     if (additional_eq_set_id_present) {
   1277       additional_eq_set_id_cnt = impd_read_bits_buf(it_bit_buff, 6);
   1278       if (it_bit_buff->error) return it_bit_buff->error;
   1279 
   1280       for (i = 0; i < additional_eq_set_id_cnt; i++) {
   1281         loud_eq_instructions->eq_set_id[i + 1] =
   1282             impd_read_bits_buf(it_bit_buff, 6);
   1283         if (it_bit_buff->error) return it_bit_buff->error;
   1284       }
   1285     }
   1286   } else {
   1287     loud_eq_instructions->eq_set_id[0] = 0;
   1288   }
   1289   loud_eq_instructions->eq_set_id_count = 1 + additional_eq_set_id_cnt;
   1290 
   1291   temp = impd_read_bits_buf(it_bit_buff, 8);
   1292   if (it_bit_buff->error) return it_bit_buff->error;
   1293 
   1294   loud_eq_instructions->loudness_after_drc = (temp >> 7) & 0x01;
   1295 
   1296   loud_eq_instructions->loudness_after_eq = (temp >> 6) & 0x01;
   1297 
   1298   loud_eq_instructions->loud_eq_gain_sequence_count = temp & 0x3F;
   1299 
   1300   for (i = 0; i < loud_eq_instructions->loud_eq_gain_sequence_count; i++) {
   1301     temp = impd_read_bits_buf(it_bit_buff, 7);
   1302     if (it_bit_buff->error) return it_bit_buff->error;
   1303 
   1304     loud_eq_instructions->gain_seq_idx[i] = (temp >> 1) & 0x3F;
   1305 
   1306     loud_eq_instructions->drc_characteristic_format_is_cicp[i] = temp & 0x01;
   1307 
   1308     if (loud_eq_instructions->drc_characteristic_format_is_cicp[i]) {
   1309       loud_eq_instructions->drc_characteristic[i] =
   1310           impd_read_bits_buf(it_bit_buff, 7);
   1311       if (it_bit_buff->error) return it_bit_buff->error;
   1312     } else {
   1313       temp = impd_read_bits_buf(it_bit_buff, 8);
   1314       if (it_bit_buff->error) return it_bit_buff->error;
   1315 
   1316       loud_eq_instructions->drc_characteristic_left_index[i] =
   1317           (temp >> 4) & 0x0F;
   1318 
   1319       loud_eq_instructions->drc_characteristic_right_index[i] = temp & 0x0F;
   1320     }
   1321 
   1322     temp = impd_read_bits_buf(it_bit_buff, 9);
   1323     if (it_bit_buff->error) return it_bit_buff->error;
   1324 
   1325     loud_eq_instructions->frequency_range_index[i] = (temp >> 3) & 0x3F;
   1326 
   1327     bs_loud_eq_scaling = temp & 0x07;
   1328 
   1329     loud_eq_instructions->loud_eq_scaling[i] =
   1330         (FLOAT32)pow(2.0f, -0.5f * bs_loud_eq_scaling);
   1331 
   1332     bs_loud_eq_offset = impd_read_bits_buf(it_bit_buff, 5);
   1333     if (it_bit_buff->error) return it_bit_buff->error;
   1334 
   1335     loud_eq_instructions->loud_eq_offset[i] = 1.5f * bs_loud_eq_offset - 16.0f;
   1336   }
   1337   return (0);
   1338 }
   1339