/src/libldac/src/bitalloc_ldac.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright (C) 2003 - 2016 Sony Corporation |
3 | | * |
4 | | * Licensed under the Apache License, Version 2.0 (the "License"); |
5 | | * you may not use this file except in compliance with the License. |
6 | | * You may obtain a copy of the License at |
7 | | * |
8 | | * http://www.apache.org/licenses/LICENSE-2.0 |
9 | | * |
10 | | * Unless required by applicable law or agreed to in writing, software |
11 | | * distributed under the License is distributed on an "AS IS" BASIS, |
12 | | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
13 | | * See the License for the specific language governing permissions and |
14 | | * limitations under the License. |
15 | | */ |
16 | | |
17 | | #include "ldac.h" |
18 | | |
19 | | |
20 | | |
21 | | /*************************************************************************************************** |
22 | | Subfunction: Calculate Bits for Audio Block |
23 | | ***************************************************************************************************/ |
24 | | static int encode_audio_block_a_ldac( |
25 | | AB *p_ab, |
26 | | int hqu) |
27 | 651 | { |
28 | 651 | AC *p_ac; |
29 | 651 | int ich, iqu; |
30 | 651 | int nchs = p_ab->blk_nchs; |
31 | 651 | int tmp, nbits = 0; |
32 | 651 | int idsp, idwl1, idwl2; |
33 | 651 | int grad_mode = p_ab->grad_mode; |
34 | 651 | int grad_qu_l = p_ab->grad_qu_l; |
35 | 651 | int grad_qu_h = p_ab->grad_qu_h; |
36 | 651 | int grad_os_l = p_ab->grad_os_l; |
37 | 651 | int grad_os_h = p_ab->grad_os_h; |
38 | 651 | int *p_grad = p_ab->a_grad; |
39 | 651 | int *p_idsf, *p_addwl, *p_idwl1, *p_idwl2; |
40 | 651 | const unsigned char *p_t; |
41 | | |
42 | | /* Calculate Gradient Curve */ |
43 | 651 | tmp = grad_qu_h - grad_qu_l; |
44 | | |
45 | 21.4k | for (iqu = 0; iqu < grad_qu_h; iqu++) { |
46 | 20.8k | p_grad[iqu] = -grad_os_l; |
47 | 20.8k | } |
48 | 651 | for (iqu = grad_qu_h; iqu < hqu; iqu++) { |
49 | 0 | p_grad[iqu] = -grad_os_h; |
50 | 0 | } |
51 | | |
52 | 651 | if (tmp > 0) { |
53 | 651 | p_t = gaa_resamp_grad_ldac[tmp-1]; |
54 | | |
55 | 651 | tmp = grad_os_h - grad_os_l; |
56 | 651 | if (tmp > 0) { |
57 | 651 | tmp = tmp-1; |
58 | 10.4k | for (iqu = grad_qu_l; iqu < grad_qu_h; iqu++) { |
59 | 9.78k | p_grad[iqu] -= ((*p_t++ * tmp) >> 8) + 1; |
60 | 9.78k | } |
61 | 651 | } |
62 | 0 | else if (tmp < 0) { |
63 | 0 | tmp = -tmp-1; |
64 | 0 | for (iqu = grad_qu_l; iqu < grad_qu_h; iqu++) { |
65 | 0 | p_grad[iqu] += ((*p_t++ * tmp) >> 8) + 1; |
66 | 0 | } |
67 | 0 | } |
68 | 651 | } |
69 | | |
70 | | /* Calculate Bits */ |
71 | 1.30k | for (ich = 0; ich < nchs; ich++) { |
72 | 651 | p_ac = p_ab->ap_ac[ich]; |
73 | 651 | p_idsf = p_ac->a_idsf; |
74 | 651 | p_addwl = p_ac->a_addwl; |
75 | 651 | p_idwl1 = p_ac->a_idwl1; |
76 | 651 | p_idwl2 = p_ac->a_idwl2; |
77 | | |
78 | 651 | if (grad_mode == LDAC_MODE_0) { |
79 | 17.5k | for (iqu = 0; iqu < hqu; iqu++) { |
80 | 16.9k | idwl1 = p_idsf[iqu] + p_grad[iqu]; |
81 | 16.9k | if (idwl1 < LDAC_MINIDWL1) { |
82 | 294 | idwl1 = LDAC_MINIDWL1; |
83 | 294 | } |
84 | 16.9k | idwl2 = 0; |
85 | 16.9k | if (idwl1 > LDAC_MAXIDWL1) { |
86 | 840 | idwl2 = idwl1 - LDAC_MAXIDWL1; |
87 | 840 | if (idwl2 > LDAC_MAXIDWL2) { |
88 | 0 | idwl2 = LDAC_MAXIDWL2; |
89 | 0 | } |
90 | 840 | idwl1 = LDAC_MAXIDWL1; |
91 | 840 | } |
92 | 16.9k | p_idwl1[iqu] = idwl1; |
93 | 16.9k | p_idwl2[iqu] = idwl2; |
94 | 16.9k | idsp = ga_idsp_ldac[iqu]; |
95 | 16.9k | nbits += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu]; |
96 | 16.9k | } |
97 | 651 | } |
98 | 0 | else if (grad_mode == LDAC_MODE_1) { |
99 | 0 | for (iqu = 0; iqu < hqu; iqu++) { |
100 | 0 | idwl1 = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu]; |
101 | 0 | if (idwl1 > 0) { |
102 | 0 | idwl1 = idwl1 >> 1; |
103 | 0 | } |
104 | 0 | if (idwl1 < LDAC_MINIDWL1) { |
105 | 0 | idwl1 = LDAC_MINIDWL1; |
106 | 0 | } |
107 | 0 | idwl2 = 0; |
108 | 0 | if (idwl1 > LDAC_MAXIDWL1) { |
109 | 0 | idwl2 = idwl1 - LDAC_MAXIDWL1; |
110 | 0 | if (idwl2 > LDAC_MAXIDWL2) { |
111 | 0 | idwl2 = LDAC_MAXIDWL2; |
112 | 0 | } |
113 | 0 | idwl1 = LDAC_MAXIDWL1; |
114 | 0 | } |
115 | 0 | p_idwl1[iqu] = idwl1; |
116 | 0 | p_idwl2[iqu] = idwl2; |
117 | 0 | idsp = ga_idsp_ldac[iqu]; |
118 | 0 | nbits += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu]; |
119 | 0 | } |
120 | 0 | } |
121 | 0 | else if (grad_mode == LDAC_MODE_2) { |
122 | 0 | for (iqu = 0; iqu < hqu; iqu++) { |
123 | 0 | idwl1 = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu]; |
124 | 0 | if (idwl1 > 0) { |
125 | 0 | idwl1 = (idwl1*3) >> 3; |
126 | 0 | } |
127 | 0 | if (idwl1 < LDAC_MINIDWL1) { |
128 | 0 | idwl1 = LDAC_MINIDWL1; |
129 | 0 | } |
130 | 0 | idwl2 = 0; |
131 | 0 | if (idwl1 > LDAC_MAXIDWL1) { |
132 | 0 | idwl2 = idwl1 - LDAC_MAXIDWL1; |
133 | 0 | if (idwl2 > LDAC_MAXIDWL2) { |
134 | 0 | idwl2 = LDAC_MAXIDWL2; |
135 | 0 | } |
136 | 0 | idwl1 = LDAC_MAXIDWL1; |
137 | 0 | } |
138 | 0 | p_idwl1[iqu] = idwl1; |
139 | 0 | p_idwl2[iqu] = idwl2; |
140 | 0 | idsp = ga_idsp_ldac[iqu]; |
141 | 0 | nbits += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu]; |
142 | 0 | } |
143 | 0 | } |
144 | 0 | else if (grad_mode == LDAC_MODE_3) { |
145 | 0 | for (iqu = 0; iqu < hqu; iqu++) { |
146 | 0 | idwl1 = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu]; |
147 | 0 | if (idwl1 > 0) { |
148 | 0 | idwl1 = idwl1 >> 2; |
149 | 0 | } |
150 | 0 | if (idwl1 < LDAC_MINIDWL1) { |
151 | 0 | idwl1 = LDAC_MINIDWL1; |
152 | 0 | } |
153 | 0 | idwl2 = 0; |
154 | 0 | if (idwl1 > LDAC_MAXIDWL1) { |
155 | 0 | idwl2 = idwl1 - LDAC_MAXIDWL1; |
156 | 0 | if (idwl2 > LDAC_MAXIDWL2) { |
157 | 0 | idwl2 = LDAC_MAXIDWL2; |
158 | 0 | } |
159 | 0 | idwl1 = LDAC_MAXIDWL1; |
160 | 0 | } |
161 | 0 | p_idwl1[iqu] = idwl1; |
162 | 0 | p_idwl2[iqu] = idwl2; |
163 | 0 | idsp = ga_idsp_ldac[iqu]; |
164 | 0 | nbits += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu]; |
165 | 0 | } |
166 | 0 | } |
167 | 651 | } |
168 | | |
169 | 651 | return nbits; |
170 | 651 | } |
171 | | |
172 | | /*************************************************************************************************** |
173 | | Subfunction: Calculate Bits for Audio Block |
174 | | ***************************************************************************************************/ |
175 | | static int encode_audio_block_b_ldac( |
176 | | AB *p_ab, |
177 | | int nadjqus) |
178 | 168 | { |
179 | 168 | AC *p_ac; |
180 | 168 | int ich, iqu; |
181 | 168 | int nchs = p_ab->blk_nchs; |
182 | 168 | int nqus = min_ldac(LDAC_MAXNADJQUS, p_ab->nqus); |
183 | 168 | int nbits = 0; |
184 | 168 | int idsp, idwl1, idwl2; |
185 | 168 | int *p_idwl1, *p_idwl2, *p_tmp; |
186 | | |
187 | | /* Calculate Bits */ |
188 | 336 | for (ich = 0; ich < nchs; ich++) { |
189 | 168 | p_ac = p_ab->ap_ac[ich]; |
190 | 168 | p_idwl1 = p_ac->a_idwl1; |
191 | 168 | p_idwl2 = p_ac->a_idwl2; |
192 | 168 | p_tmp = p_ac->a_tmp; |
193 | | |
194 | 4.53k | for (iqu = 0; iqu < nqus; iqu++) { |
195 | 4.36k | idwl1 = p_tmp[iqu]; |
196 | 4.36k | if (iqu < nadjqus) { |
197 | 1.28k | idwl1++; |
198 | 1.28k | } |
199 | 4.36k | idwl2 = 0; |
200 | 4.36k | if (idwl1 > LDAC_MAXIDWL1) { |
201 | 0 | idwl2 = idwl1 - LDAC_MAXIDWL1; |
202 | 0 | if (idwl2 > LDAC_MAXIDWL2) { |
203 | 0 | idwl2 = LDAC_MAXIDWL2; |
204 | 0 | } |
205 | 0 | idwl1 = LDAC_MAXIDWL1; |
206 | 0 | } |
207 | 4.36k | p_idwl1[iqu] = idwl1; |
208 | 4.36k | p_idwl2[iqu] = idwl2; |
209 | 4.36k | idsp = ga_idsp_ldac[iqu]; |
210 | 4.36k | nbits += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu]; |
211 | 4.36k | } |
212 | 168 | } |
213 | | |
214 | 168 | return nbits; |
215 | 168 | } |
216 | | |
217 | | /*************************************************************************************************** |
218 | | Subfunction: Decrease Lower Offset of Gradient Curve |
219 | | ***************************************************************************************************/ |
220 | | static int decrease_offset_low_ldac( |
221 | | AB *p_ab, |
222 | | int limit, |
223 | | int *p_nbits_spec) |
224 | 84 | { |
225 | 84 | int ncalls = 0; |
226 | 84 | int nqus = p_ab->nqus; |
227 | 84 | int grad_os_l = p_ab->grad_os_l; |
228 | 84 | int nbits_avail = p_ab->nbits_avail; |
229 | 84 | int step = limit - grad_os_l; |
230 | 84 | int a_checked[LDAC_MAXGRADOS+1]; |
231 | | |
232 | 84 | if (*p_nbits_spec > nbits_avail) { |
233 | 42 | memset(a_checked, 0, (LDAC_MAXGRADOS+1)*sizeof(int)); |
234 | | |
235 | 189 | while (grad_os_l < limit) { |
236 | 189 | if (step > 1) { |
237 | 168 | step = (step+1)/2; |
238 | 168 | } |
239 | | |
240 | 189 | if (*p_nbits_spec < nbits_avail) { |
241 | 42 | grad_os_l -= step; |
242 | 42 | if (grad_os_l < 0) { |
243 | 0 | grad_os_l += step; |
244 | 0 | break; |
245 | 0 | } |
246 | 42 | else if (a_checked[grad_os_l]) { |
247 | 0 | grad_os_l += step; |
248 | 0 | break; |
249 | 0 | } |
250 | 42 | } |
251 | 147 | else if (*p_nbits_spec > nbits_avail) { |
252 | 147 | grad_os_l += step; |
253 | 147 | if (grad_os_l > LDAC_MAXGRADOS) { |
254 | 0 | grad_os_l -= step; |
255 | 0 | break; |
256 | 0 | } |
257 | 147 | else if (a_checked[grad_os_l]) { |
258 | 42 | grad_os_l -= step; |
259 | 42 | break; |
260 | 42 | } |
261 | 147 | } |
262 | 0 | else { |
263 | 0 | break; |
264 | 0 | } |
265 | | |
266 | 147 | p_ab->grad_os_l = grad_os_l; |
267 | 147 | *p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus); |
268 | 147 | a_checked[grad_os_l] = *p_nbits_spec; |
269 | 147 | ncalls++; |
270 | 147 | } |
271 | | |
272 | 84 | while ((*p_nbits_spec > nbits_avail) && (grad_os_l < limit)) { |
273 | 42 | p_ab->grad_os_l = ++grad_os_l; |
274 | 42 | *p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus); |
275 | 42 | ncalls++; |
276 | 42 | } |
277 | 42 | } |
278 | | |
279 | 84 | return ncalls; |
280 | 84 | } |
281 | | |
282 | | /*************************************************************************************************** |
283 | | Subfunction: Decrease Higher Offset of Gradient Curve |
284 | | ***************************************************************************************************/ |
285 | | static int decrease_offset_high_ldac( |
286 | | AB *p_ab, |
287 | | int *p_nbits_spec) |
288 | 42 | { |
289 | 42 | int ncalls = 0; |
290 | 42 | int nqus = p_ab->nqus; |
291 | 42 | int grad_os_h = p_ab->grad_os_h; |
292 | 42 | int nbits_avail = p_ab->nbits_avail; |
293 | 42 | int step = LDAC_MAXGRADOS - grad_os_h; |
294 | 42 | int a_checked[LDAC_MAXGRADOS+1]; |
295 | | |
296 | 42 | if (*p_nbits_spec > nbits_avail) { |
297 | 0 | memset(a_checked, 0, (LDAC_MAXGRADOS+1)*sizeof(int)); |
298 | |
|
299 | 0 | while (grad_os_h < LDAC_MAXGRADOS) { |
300 | 0 | if (step > 1) { |
301 | 0 | step = (step+1)/2; |
302 | 0 | } |
303 | |
|
304 | 0 | if (*p_nbits_spec < nbits_avail) { |
305 | 0 | grad_os_h -= step; |
306 | 0 | if (grad_os_h < 0) { |
307 | 0 | grad_os_h += step; |
308 | 0 | break; |
309 | 0 | } |
310 | 0 | else if (a_checked[grad_os_h]) { |
311 | 0 | grad_os_h += step; |
312 | 0 | break; |
313 | 0 | } |
314 | 0 | } |
315 | 0 | else if (*p_nbits_spec > nbits_avail) { |
316 | 0 | grad_os_h += step; |
317 | 0 | if (grad_os_h > LDAC_MAXGRADOS) { |
318 | 0 | grad_os_h -= step; |
319 | 0 | break; |
320 | 0 | } |
321 | 0 | else if (a_checked[grad_os_h]) { |
322 | 0 | grad_os_h -= step; |
323 | 0 | break; |
324 | 0 | } |
325 | 0 | } |
326 | 0 | else { |
327 | 0 | break; |
328 | 0 | } |
329 | | |
330 | 0 | p_ab->grad_os_h = grad_os_h; |
331 | 0 | *p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus); |
332 | 0 | a_checked[grad_os_h] = *p_nbits_spec; |
333 | 0 | ncalls++; |
334 | 0 | } |
335 | |
|
336 | 0 | while ((*p_nbits_spec > nbits_avail) && (grad_os_h < LDAC_MAXGRADOS)) { |
337 | 0 | p_ab->grad_os_h = ++grad_os_h; |
338 | 0 | *p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus); |
339 | 0 | ncalls++; |
340 | 0 | } |
341 | 0 | } |
342 | | |
343 | 42 | return ncalls; |
344 | 42 | } |
345 | | |
346 | | /*************************************************************************************************** |
347 | | Subfunction: Increase Lower Offset of Gradient Curve |
348 | | ***************************************************************************************************/ |
349 | | static int increase_offset_low_ldac( |
350 | | AB *p_ab, |
351 | | int *p_nbits_spec) |
352 | 42 | { |
353 | 42 | int ncalls = 0; |
354 | 42 | int nqus = p_ab->nqus; |
355 | 42 | int grad_os_l = p_ab->grad_os_l; |
356 | 42 | int nbits_avail = p_ab->nbits_avail; |
357 | 42 | int step = grad_os_l; |
358 | 42 | int a_checked[LDAC_MAXGRADOS+1]; |
359 | | |
360 | 42 | memset(a_checked, 0, (LDAC_MAXGRADOS+1)*sizeof(int)); |
361 | | |
362 | 252 | while (grad_os_l > 0) { |
363 | 252 | if (step > 1) { |
364 | 189 | step = (step+1)/2; |
365 | 189 | } |
366 | | |
367 | 252 | if (*p_nbits_spec < nbits_avail) { |
368 | 105 | grad_os_l -= step; |
369 | 105 | if (grad_os_l < 0) { |
370 | 0 | grad_os_l += step; |
371 | 0 | break; |
372 | 0 | } |
373 | 105 | else if (a_checked[grad_os_l]) { |
374 | 42 | grad_os_l += step; |
375 | 42 | break; |
376 | 42 | } |
377 | 105 | } |
378 | 147 | else if (*p_nbits_spec > nbits_avail) { |
379 | 147 | grad_os_l += step; |
380 | 147 | if (grad_os_l > LDAC_MAXGRADOS) { |
381 | 0 | grad_os_l -= step; |
382 | 0 | break; |
383 | 0 | } |
384 | 147 | else if (a_checked[grad_os_l]) { |
385 | 0 | grad_os_l -= step; |
386 | 0 | break; |
387 | 0 | } |
388 | 147 | } |
389 | 0 | else { |
390 | 0 | break; |
391 | 0 | } |
392 | | |
393 | 210 | p_ab->grad_os_l = grad_os_l; |
394 | 210 | *p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus); |
395 | 210 | a_checked[grad_os_l] = *p_nbits_spec; |
396 | 210 | ncalls++; |
397 | 210 | } |
398 | | |
399 | 42 | while ((*p_nbits_spec > nbits_avail) && (grad_os_l < LDAC_MAXGRADOS)) { |
400 | 0 | p_ab->grad_os_l = ++grad_os_l; |
401 | 0 | *p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus); |
402 | 0 | ncalls++; |
403 | 0 | } |
404 | | |
405 | 42 | return ncalls; |
406 | 42 | } |
407 | | |
408 | | |
409 | | /*************************************************************************************************** |
410 | | Subfunction: Increase Lower QU of Gradient Curve |
411 | | ***************************************************************************************************/ |
412 | | static int increase_qu_low_ldac( |
413 | | AB *p_ab, |
414 | | int *p_nbits_spec) |
415 | 0 | { |
416 | 0 | int ncalls = 0; |
417 | 0 | int nqus = p_ab->nqus; |
418 | 0 | int grad_qu_l = p_ab->grad_qu_l; |
419 | 0 | int grad_qu_h = p_ab->grad_qu_h; |
420 | 0 | int nbits_avail = p_ab->nbits_avail; |
421 | 0 | int step = grad_qu_h - grad_qu_l; |
422 | 0 | int a_checked[LDAC_DEFGRADQUH+1]; |
423 | |
|
424 | 0 | memset(a_checked, 0, (LDAC_DEFGRADQUH+1)*sizeof(int)); |
425 | |
|
426 | 0 | while ((grad_qu_l > 0) && (grad_qu_l < LDAC_DEFGRADQUH)) { |
427 | 0 | if (step > 1) { |
428 | 0 | step = (step+1)/2; |
429 | 0 | } |
430 | |
|
431 | 0 | if (*p_nbits_spec < nbits_avail) { |
432 | 0 | grad_qu_l += step; |
433 | 0 | if (grad_qu_l > LDAC_DEFGRADQUH) { |
434 | 0 | grad_qu_l -= step; |
435 | 0 | break; |
436 | 0 | } |
437 | 0 | else if (a_checked[grad_qu_l]) { |
438 | 0 | grad_qu_l -= step; |
439 | 0 | break; |
440 | 0 | } |
441 | 0 | } |
442 | 0 | else if (*p_nbits_spec > nbits_avail) { |
443 | 0 | grad_qu_l -= step; |
444 | 0 | if (grad_qu_l < 0) { |
445 | 0 | grad_qu_l += step; |
446 | 0 | break; |
447 | 0 | } |
448 | 0 | else if (a_checked[grad_qu_l]) { |
449 | 0 | grad_qu_l += step; |
450 | 0 | break; |
451 | 0 | } |
452 | 0 | } |
453 | 0 | else { |
454 | 0 | break; |
455 | 0 | } |
456 | | |
457 | 0 | p_ab->grad_qu_l = grad_qu_l; |
458 | 0 | *p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus); |
459 | 0 | a_checked[grad_qu_l] = *p_nbits_spec; |
460 | 0 | ncalls++; |
461 | 0 | } |
462 | |
|
463 | 0 | while ((*p_nbits_spec > nbits_avail) && (grad_qu_l <= LDAC_DEFGRADQUH)) { |
464 | 0 | p_ab->grad_qu_l = --grad_qu_l; |
465 | 0 | *p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus); |
466 | 0 | ncalls++; |
467 | 0 | } |
468 | |
|
469 | 0 | return ncalls; |
470 | 0 | } |
471 | | |
472 | | /*************************************************************************************************** |
473 | | Subfunction: Increase Lower QU of Gradient Curve |
474 | | ***************************************************************************************************/ |
475 | | static int increase_qu_low_0_ldac( |
476 | | AB *p_ab, |
477 | | int *p_nbits_spec) |
478 | 42 | { |
479 | 42 | int ncalls = 0; |
480 | 42 | int nqus = p_ab->nqus; |
481 | 42 | int grad_qu_l = p_ab->grad_qu_l; |
482 | 42 | int grad_qu_h = p_ab->grad_qu_h; |
483 | 42 | int nbits_avail = p_ab->nbits_avail; |
484 | 42 | int step = grad_qu_h - grad_qu_l; |
485 | 42 | int a_checked[LDAC_MAXGRADQU+1]; |
486 | | |
487 | 42 | memset(a_checked, 0, (LDAC_MAXGRADQU+1)*sizeof(int)); |
488 | | |
489 | 252 | while ((grad_qu_l > 0) && (grad_qu_l < grad_qu_h)) { |
490 | 252 | if (step > 1) { |
491 | 168 | step = step/2; |
492 | 168 | } |
493 | | |
494 | 252 | if (*p_nbits_spec < nbits_avail) { |
495 | 84 | grad_qu_l += step; |
496 | 84 | if (grad_qu_l >= grad_qu_h) { |
497 | 0 | grad_qu_l -= step; |
498 | 0 | break; |
499 | 0 | } |
500 | 84 | else if (a_checked[grad_qu_l]) { |
501 | 42 | grad_qu_l -= step; |
502 | 42 | break; |
503 | 42 | } |
504 | 84 | } |
505 | 168 | else if (*p_nbits_spec > nbits_avail) { |
506 | 168 | grad_qu_l -= step; |
507 | 168 | if (grad_qu_l < 0) { |
508 | 0 | grad_qu_l += step; |
509 | 0 | break; |
510 | 0 | } |
511 | 168 | else if (a_checked[grad_qu_l]) { |
512 | 0 | grad_qu_l += step; |
513 | 0 | break; |
514 | 0 | } |
515 | 168 | } |
516 | 0 | else { |
517 | 0 | break; |
518 | 0 | } |
519 | | |
520 | 210 | p_ab->grad_qu_l = grad_qu_l; |
521 | 210 | *p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus); |
522 | 210 | a_checked[grad_qu_l] = *p_nbits_spec; |
523 | 210 | ncalls++; |
524 | 210 | } |
525 | | |
526 | 42 | while ((*p_nbits_spec > nbits_avail) && (grad_qu_l > 0)) { |
527 | 0 | p_ab->grad_qu_l = --grad_qu_l; |
528 | 0 | *p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus); |
529 | 0 | ncalls++; |
530 | 0 | } |
531 | | |
532 | 42 | return ncalls; |
533 | 42 | } |
534 | | |
535 | | /*************************************************************************************************** |
536 | | Subfunction: Adjust Remaining Bits |
537 | | ***************************************************************************************************/ |
538 | | static int adjust_remain_bits_ldac( |
539 | | AB *p_ab, |
540 | | int *p_nbits_spec, |
541 | | int *p_nadjqus) |
542 | 42 | { |
543 | 42 | int ich, iqu; |
544 | 42 | int ncalls = 0; |
545 | 42 | int nbits_fix, nbits_spec; |
546 | 42 | int nbits_avail = p_ab->nbits_avail; |
547 | 42 | int idsp, idwl1, idwl2, tmp; |
548 | 42 | int step = LDAC_MAXNADJQUS>>1; |
549 | 42 | int nadjqus = LDAC_MAXNADJQUS>>1; |
550 | 42 | int nchs = p_ab->blk_nchs; |
551 | 42 | int nqus = min_ldac(LDAC_MAXNADJQUS, p_ab->nqus); |
552 | 42 | int grad_mode = p_ab->grad_mode; |
553 | 42 | int *p_grad = p_ab->a_grad; |
554 | 42 | int *p_idsf, *p_addwl, *p_idwl1, *p_idwl2, *p_tmp; |
555 | 42 | AC *p_ac; |
556 | | |
557 | 42 | nbits_fix = 0; |
558 | 84 | for (ich = 0; ich < nchs; ich++){ |
559 | 42 | p_ac = p_ab->ap_ac[ich]; |
560 | 42 | p_idsf = p_ac->a_idsf; |
561 | 42 | p_addwl = p_ac->a_addwl; |
562 | 42 | p_idwl1 = p_ac->a_idwl1; |
563 | 42 | p_idwl2 = p_ac->a_idwl2; |
564 | 42 | p_tmp = p_ac->a_tmp; |
565 | | |
566 | 42 | if (grad_mode == LDAC_MODE_0) { |
567 | 1.13k | for (iqu = 0; iqu < nqus; iqu++) { |
568 | 1.09k | idwl1 = p_idwl1[iqu]; |
569 | 1.09k | idwl2 = p_idwl2[iqu]; |
570 | 1.09k | idsp = ga_idsp_ldac[iqu]; |
571 | 1.09k | nbits_fix += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu]; |
572 | 1.09k | tmp = p_idsf[iqu] + p_grad[iqu]; |
573 | 1.09k | if (tmp < LDAC_MINIDWL1) { |
574 | 42 | tmp = LDAC_MINIDWL1; |
575 | 42 | } |
576 | 1.09k | p_tmp[iqu] = tmp; |
577 | 1.09k | } |
578 | 42 | } |
579 | 0 | else if (grad_mode == LDAC_MODE_1) { |
580 | 0 | for (iqu = 0; iqu < nqus; iqu++) { |
581 | 0 | idwl1 = p_idwl1[iqu]; |
582 | 0 | idwl2 = p_idwl2[iqu]; |
583 | 0 | idsp = ga_idsp_ldac[iqu]; |
584 | 0 | nbits_fix += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu]; |
585 | 0 | tmp = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu]; |
586 | 0 | if (tmp > 0) { |
587 | 0 | tmp = tmp >> 1; |
588 | 0 | } |
589 | 0 | if (tmp < LDAC_MINIDWL1) { |
590 | 0 | tmp = LDAC_MINIDWL1; |
591 | 0 | } |
592 | 0 | p_tmp[iqu] = tmp; |
593 | 0 | } |
594 | 0 | } |
595 | 0 | else if (grad_mode == LDAC_MODE_2) { |
596 | 0 | for (iqu = 0; iqu < nqus; iqu++) { |
597 | 0 | idwl1 = p_idwl1[iqu]; |
598 | 0 | idwl2 = p_idwl2[iqu]; |
599 | 0 | idsp = ga_idsp_ldac[iqu]; |
600 | 0 | nbits_fix += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu]; |
601 | 0 | tmp = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu]; |
602 | 0 | if (tmp > 0) { |
603 | 0 | tmp = (tmp*3) >> 3; |
604 | 0 | } |
605 | 0 | if (tmp < LDAC_MINIDWL1) { |
606 | 0 | tmp = LDAC_MINIDWL1; |
607 | 0 | } |
608 | 0 | p_tmp[iqu] = tmp; |
609 | 0 | } |
610 | 0 | } |
611 | 0 | else if (grad_mode == LDAC_MODE_3) { |
612 | 0 | for (iqu = 0; iqu < nqus; iqu++) { |
613 | 0 | idwl1 = p_idwl1[iqu]; |
614 | 0 | idwl2 = p_idwl2[iqu]; |
615 | 0 | idsp = ga_idsp_ldac[iqu]; |
616 | 0 | nbits_fix += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu]; |
617 | 0 | tmp = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu]; |
618 | 0 | if (tmp > 0) { |
619 | 0 | tmp = tmp >> 2; |
620 | 0 | } |
621 | 0 | if (tmp < LDAC_MINIDWL1) { |
622 | 0 | tmp = LDAC_MINIDWL1; |
623 | 0 | } |
624 | 0 | p_tmp[iqu] = tmp; |
625 | 0 | } |
626 | 0 | } |
627 | 42 | } |
628 | | |
629 | 42 | nbits_fix = *p_nbits_spec - nbits_fix; |
630 | 42 | nbits_spec = nbits_fix + encode_audio_block_b_ldac(p_ab, nadjqus); |
631 | 42 | ncalls++; |
632 | | |
633 | 168 | while (step > 1) { |
634 | 147 | step >>= 1; |
635 | | |
636 | 147 | if (nbits_spec < nbits_avail) { |
637 | 21 | nadjqus += step; |
638 | 21 | if (nadjqus > p_ab->nqus) { |
639 | 0 | nadjqus = p_ab->nqus; |
640 | 0 | } |
641 | 21 | } |
642 | 126 | else if (nbits_spec > nbits_avail) { |
643 | 105 | nadjqus -= step; |
644 | 105 | } |
645 | 21 | else { |
646 | 21 | if (nadjqus > p_ab->nqus) { |
647 | 0 | nadjqus = p_ab->nqus; |
648 | 0 | } |
649 | 21 | break; |
650 | 21 | } |
651 | 126 | nbits_spec = nbits_fix + encode_audio_block_b_ldac(p_ab, nadjqus); |
652 | 126 | ncalls++; |
653 | 126 | } |
654 | | |
655 | 42 | if (nbits_spec > nbits_avail) { |
656 | 0 | nadjqus--; |
657 | 0 | nbits_spec = nbits_fix + encode_audio_block_b_ldac(p_ab, nadjqus); |
658 | 0 | ncalls++; |
659 | 0 | } |
660 | 42 | *p_nadjqus = nadjqus; |
661 | 42 | *p_nbits_spec = nbits_spec; |
662 | | |
663 | 42 | return ncalls; |
664 | 42 | } |
665 | | |
666 | | /*************************************************************************************************** |
667 | | Allocate Bits |
668 | | ***************************************************************************************************/ |
669 | 42 | #define LDAC_UPPER_NOISE_LEVEL 20 |
670 | | #define LDAC_LOWER_NOISE_LEVEL 5 |
671 | | |
672 | | DECLFUNC int alloc_bits_ldac( |
673 | | AB *p_ab) |
674 | 42 | { |
675 | 42 | int nbits_avail, nbits_side = 0, nbits_spec = 0; |
676 | 42 | int nbits_ab = p_ab->nbits_ab; |
677 | | |
678 | 42 | nbits_side = encode_side_info_ldac(p_ab); |
679 | 42 | p_ab->nbits_avail = nbits_avail = nbits_ab - nbits_side; |
680 | | |
681 | 42 | nbits_spec = encode_audio_block_a_ldac(p_ab, p_ab->nqus); |
682 | | |
683 | 42 | if (nbits_spec > nbits_avail) { |
684 | 42 | if (p_ab->grad_mode == LDAC_MODE_0) { |
685 | 42 | decrease_offset_low_ldac(p_ab, LDAC_UPPER_NOISE_LEVEL, &nbits_spec); |
686 | | |
687 | 42 | decrease_offset_high_ldac(p_ab, &nbits_spec); |
688 | | |
689 | 42 | decrease_offset_low_ldac(p_ab, LDAC_MAXGRADOS, &nbits_spec); |
690 | 42 | } |
691 | 0 | else { |
692 | 0 | decrease_offset_low_ldac(p_ab, LDAC_MAXGRADOS, &nbits_spec); |
693 | 0 | } |
694 | | |
695 | 42 | while ((nbits_spec > nbits_avail) && (p_ab->nbands > LDAC_BAND_OFFSET)) { |
696 | 0 | p_ab->nbands--; |
697 | 0 | p_ab->nqus = ga_nqus_ldac[p_ab->nbands]; |
698 | |
|
699 | 0 | nbits_side = encode_side_info_ldac(p_ab); |
700 | 0 | p_ab->nbits_avail = nbits_avail = nbits_ab - nbits_side; |
701 | |
|
702 | 0 | nbits_spec = encode_audio_block_a_ldac(p_ab, p_ab->nqus); |
703 | 0 | } |
704 | 42 | } |
705 | | |
706 | 42 | if (nbits_spec < nbits_avail) { |
707 | 42 | if (p_ab->grad_mode == LDAC_MODE_0) { |
708 | 42 | increase_offset_low_ldac(p_ab, &nbits_spec); |
709 | | |
710 | 42 | increase_qu_low_0_ldac(p_ab, &nbits_spec); |
711 | 42 | } |
712 | 0 | else { |
713 | 0 | increase_offset_low_ldac(p_ab, &nbits_spec); |
714 | |
|
715 | 0 | increase_qu_low_ldac(p_ab, &nbits_spec); |
716 | 0 | } |
717 | 42 | } |
718 | | |
719 | 42 | p_ab->nadjqus = 0; |
720 | 42 | adjust_remain_bits_ldac(p_ab, &nbits_spec, &p_ab->nadjqus); |
721 | | |
722 | 42 | if (nbits_spec > nbits_avail) { |
723 | 0 | *p_ab->p_error_code = LDAC_ERR_BIT_ALLOCATION; |
724 | 0 | return LDAC_FALSE; |
725 | 0 | } |
726 | 42 | p_ab->nbits_spec = nbits_spec; |
727 | 42 | p_ab->nbits_used = nbits_spec + nbits_side; |
728 | | |
729 | | |
730 | 42 | return LDAC_TRUE; |
731 | 42 | } |
732 | | |
733 | | |