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 <stdlib.h>
22#include <math.h>
23#include <assert.h>
24#include <string.h>
25
26#include "impd_type_def.h"
27#include "impd_drc_bitbuffer.h"
28#include "impd_drc_extr_delta_coded_info.h"
29#include "impd_drc_common.h"
30#include "impd_drc_struct.h"
31#include "impd_drc_parser.h"
32
33WORD32 impd_read_bits_buf(ia_bit_buf_struct* it_bit_buff, WORD no_of_bits) {
34  UWORD32 ret_val;
35  UWORD8* ptr_read_next = it_bit_buff->ptr_read_next;
36  WORD bit_pos = it_bit_buff->bit_pos;
37  it_bit_buff->error = 0;
38
39  if (it_bit_buff->cnt_bits <= 0) {
40    it_bit_buff->error = 1;
41    return -1;
42  }
43
44  if (no_of_bits == 0) {
45    return 0;
46  }
47
48  it_bit_buff->cnt_bits -= no_of_bits;
49  ret_val = (UWORD32)*ptr_read_next;
50
51  bit_pos -= no_of_bits;
52  while (bit_pos < 0) {
53    bit_pos += 8;
54    ptr_read_next++;
55
56    if (ptr_read_next > it_bit_buff->ptr_bit_buf_end) {
57      ptr_read_next = it_bit_buff->ptr_bit_buf_base;
58    }
59
60    ret_val <<= 8;
61
62    ret_val |= (UWORD32)*ptr_read_next;
63  }
64
65  ret_val = ret_val << ((31 - no_of_bits) - bit_pos) >> (32 - no_of_bits);
66  it_bit_buff->ptr_read_next = ptr_read_next;
67  it_bit_buff->bit_pos = (WORD16)bit_pos;
68  return ret_val;
69}
70
71ia_bit_buf_struct* impd_create_bit_buf(ia_bit_buf_struct* it_bit_buff,
72                                       UWORD8* ptr_bit_buf_base,
73                                       WORD32 bit_buf_size) {
74  it_bit_buff->ptr_bit_buf_base = ptr_bit_buf_base;
75  it_bit_buff->ptr_bit_buf_end = ptr_bit_buf_base + bit_buf_size - 1;
76
77  it_bit_buff->ptr_read_next = ptr_bit_buf_base;
78  it_bit_buff->bit_pos = 7;
79
80  it_bit_buff->cnt_bits = 0;
81  it_bit_buff->size = bit_buf_size << 3;
82
83  return it_bit_buff;
84}
85
86ia_bit_buf_struct* impd_create_init_bit_buf(ia_bit_buf_struct* it_bit_buff,
87                                            UWORD8* ptr_bit_buf_base,
88                                            WORD32 bit_buf_size) {
89  impd_create_bit_buf(it_bit_buff, ptr_bit_buf_base, bit_buf_size);
90  it_bit_buff->cnt_bits = (bit_buf_size << 3);
91  return (it_bit_buff);
92}
93
94WORD32 impd_init_drc_bitstream_dec(ia_drc_bits_dec_struct* p_drc_bs_dec_struct,
95                                   WORD32 sample_rate, WORD32 frame_size,
96                                   WORD32 delay_mode,
97                                   WORD32 lfe_channel_map_count,
98                                   WORD32* lfe_channel_map) {
99  WORD32 i, err_code = 0;
100
101  ia_drc_params_bs_dec_struct* ia_drc_params_struct =
102      &p_drc_bs_dec_struct->ia_drc_params_struct;
103  ia_drc_params_struct->drc_frame_size = frame_size;
104  ia_drc_params_struct->delta_tmin_default = impd_get_delta_tmin(sample_rate);
105  ia_drc_params_struct->num_gain_values_max_default =
106      ia_drc_params_struct->drc_frame_size /
107      ia_drc_params_struct->delta_tmin_default;
108  ia_drc_params_struct->delay_mode = delay_mode;
109
110  if ((frame_size < 1) || (frame_size > AUDIO_CODEC_FRAME_SIZE_MAX) ||
111      (ia_drc_params_struct->drc_frame_size < 0.001f * sample_rate)) {
112    return -1;
113  }
114  if (sample_rate < 1000) {
115    return -1;
116  }
117
118  if (ia_drc_params_struct->delta_tmin_default >
119      ia_drc_params_struct->drc_frame_size) {
120    return -1;
121  }
122
123  if (lfe_channel_map_count >= 0) {
124    if ((lfe_channel_map == NULL) ||
125        (lfe_channel_map_count > MAX_CHANNEL_COUNT)) {
126      return (-1);
127    }
128
129    ia_drc_params_struct->lfe_channel_map_count = lfe_channel_map_count;
130
131    for (i = 0; i < lfe_channel_map_count; i++) {
132      ia_drc_params_struct->lfe_channel_map[i] = lfe_channel_map[i];
133    }
134  } else {
135    ia_drc_params_struct->lfe_channel_map_count = -1;
136
137    for (i = 0; i < MAX_CHANNEL_COUNT; i++) {
138      ia_drc_params_struct->lfe_channel_map[i] = 0;
139    }
140  }
141
142  err_code = impd_init_tbls(ia_drc_params_struct->num_gain_values_max_default,
143                            &p_drc_bs_dec_struct->tables_default);
144
145  return err_code;
146}
147
148WORD32 impd_process_drc_bitstream_dec(
149    ia_drc_bits_dec_struct* p_drc_bs_dec_struct, ia_bit_buf_struct* it_bit_buff,
150    ia_drc_config* pstr_drc_config,
151    ia_drc_loudness_info_set_struct* pstr_loudness_info,
152    UWORD8* bitstream_config, WORD32 num_bytes, WORD32 num_bits_offset,
153    WORD32* num_bits_read) {
154  WORD32 err_code = 0;
155
156  WORD32 loudness_info_set_present, drc_config_present, dummy;
157
158  if (bitstream_config == NULL) {
159    *num_bits_read = 0;
160  } else {
161    it_bit_buff =
162        impd_create_init_bit_buf(it_bit_buff, bitstream_config, num_bytes);
163
164    dummy = impd_read_bits_buf(it_bit_buff, num_bits_offset);
165    if (it_bit_buff->error) return it_bit_buff->error;
166
167    loudness_info_set_present = impd_read_bits_buf(it_bit_buff, 1);
168    if (it_bit_buff->error) return it_bit_buff->error;
169
170    if (loudness_info_set_present) {
171      drc_config_present = impd_read_bits_buf(it_bit_buff, 1);
172      if (it_bit_buff->error) return it_bit_buff->error;
173
174      if (drc_config_present) {
175        err_code = impd_parse_drc_config(
176            it_bit_buff, &p_drc_bs_dec_struct->ia_drc_params_struct,
177            pstr_drc_config);
178
179        if (err_code) return (err_code);
180      }
181
182      err_code = impd_parse_loudness_info_set(it_bit_buff, pstr_loudness_info);
183
184      if (err_code) return (err_code);
185    }
186
187    *num_bits_read = it_bit_buff->size - it_bit_buff->cnt_bits;
188  }
189
190  return err_code;
191}
192
193WORD32 impd_process_drc_bitstream_dec_config(
194    ia_drc_bits_dec_struct* p_drc_bs_dec_struct, ia_bit_buf_struct* it_bit_buff,
195    ia_drc_config* pstr_drc_config, UWORD8* bitstream_config,
196    WORD32 num_bytes) {
197  WORD32 err_code = 0;
198
199  it_bit_buff =
200      impd_create_init_bit_buf(it_bit_buff, bitstream_config, num_bytes);
201
202  err_code = impd_parse_drc_config(
203      it_bit_buff, &p_drc_bs_dec_struct->ia_drc_params_struct, pstr_drc_config);
204  if (err_code) return (err_code);
205
206  return err_code;
207}
208
209WORD32 impd_process_drc_bitstream_dec_gain(
210    ia_drc_bits_dec_struct* p_drc_bs_dec_struct, ia_bit_buf_struct* it_bit_buff,
211    ia_drc_config* pstr_drc_config, ia_drc_gain_struct* pstr_drc_gain,
212    UWORD8* bitstream_gain, WORD32 num_bytes, WORD32 num_bits_offset,
213    WORD32* num_bits_read) {
214  WORD32 err_code = 0;
215
216  WORD32 dummy;
217
218  it_bit_buff =
219      impd_create_init_bit_buf(it_bit_buff, bitstream_gain, num_bytes);
220
221  dummy = impd_read_bits_buf(it_bit_buff, num_bits_offset);
222  if (it_bit_buff->error) return it_bit_buff->error;
223
224  err_code = impd_drc_uni_gain_read(it_bit_buff, p_drc_bs_dec_struct,
225                                    pstr_drc_config, pstr_drc_gain);
226
227  if (err_code > PROC_COMPLETE) return (err_code);
228
229  *num_bits_read = (it_bit_buff->size) - it_bit_buff->cnt_bits;
230
231  if (err_code == PROC_COMPLETE) {
232    return err_code;
233  }
234
235  return 0;
236}
237
238WORD32 impd_process_drc_bitstream_dec_loudness_info_set(
239    ia_bit_buf_struct* it_bit_buff,
240    ia_drc_loudness_info_set_struct* pstr_loudness_info,
241    UWORD8* bit_stream_loudness, WORD32 num_bytes_loudness) {
242  WORD32 err_code = 0;
243
244  it_bit_buff = impd_create_init_bit_buf(it_bit_buff, bit_stream_loudness,
245                                         num_bytes_loudness);
246
247  err_code = impd_parse_loudness_info_set(it_bit_buff, pstr_loudness_info);
248  if (err_code) return (err_code);
249
250  return 0;
251}
252