GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
Line | Branch | Exec | Source |
1 |
/* |
||
2 |
* ATRAC3+ compatible decoder |
||
3 |
* |
||
4 |
* Copyright (c) 2010-2013 Maxim Poliakovski |
||
5 |
* |
||
6 |
* This file is part of FFmpeg. |
||
7 |
* |
||
8 |
* FFmpeg is free software; you can redistribute it and/or |
||
9 |
* modify it under the terms of the GNU Lesser General Public |
||
10 |
* License as published by the Free Software Foundation; either |
||
11 |
* version 2.1 of the License, or (at your option) any later version. |
||
12 |
* |
||
13 |
* FFmpeg is distributed in the hope that it will be useful, |
||
14 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
15 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
16 |
* Lesser General Public License for more details. |
||
17 |
* |
||
18 |
* You should have received a copy of the GNU Lesser General Public |
||
19 |
* License along with FFmpeg; if not, write to the Free Software |
||
20 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
21 |
*/ |
||
22 |
|||
23 |
/** |
||
24 |
* @file |
||
25 |
* Bitstream parser for ATRAC3+ decoder. |
||
26 |
*/ |
||
27 |
|||
28 |
#include "libavutil/avassert.h" |
||
29 |
#include "avcodec.h" |
||
30 |
#include "get_bits.h" |
||
31 |
#include "atrac3plus.h" |
||
32 |
#include "atrac3plus_data.h" |
||
33 |
|||
34 |
static VLC_TYPE tables_data[154276][2]; |
||
35 |
static VLC wl_vlc_tabs[4]; |
||
36 |
static VLC sf_vlc_tabs[8]; |
||
37 |
static VLC ct_vlc_tabs[4]; |
||
38 |
static VLC spec_vlc_tabs[112]; |
||
39 |
static VLC gain_vlc_tabs[11]; |
||
40 |
static VLC tone_vlc_tabs[7]; |
||
41 |
|||
42 |
/** |
||
43 |
* Generate canonical VLC table from given descriptor. |
||
44 |
* |
||
45 |
* @param[in] cb ptr to codebook descriptor |
||
46 |
* @param[in,out] xlat ptr to ptr to translation table |
||
47 |
* @param[in,out] tab_offset starting offset to the generated vlc table |
||
48 |
* @param[out] out_vlc ptr to vlc table to be generated |
||
49 |
*/ |
||
50 |
242 |
static av_cold void build_canonical_huff(const uint8_t *cb, const uint8_t **xlat, |
|
51 |
int *tab_offset, VLC *out_vlc) |
||
52 |
{ |
||
53 |
int i, max_len; |
||
54 |
uint8_t bits[256]; |
||
55 |
242 |
int index = 0; |
|
56 |
|||
57 |
✓✓ | 3146 |
for (int b = 1; b <= 12; b++) { |
58 |
✓✓ | 21614 |
for (i = *cb++; i > 0; i--) { |
59 |
✗✓ | 18710 |
av_assert0(index < 256); |
60 |
18710 |
bits[index] = b; |
|
61 |
18710 |
index++; |
|
62 |
} |
||
63 |
} |
||
64 |
242 |
max_len = bits[index - 1]; |
|
65 |
|||
66 |
242 |
out_vlc->table = &tables_data[*tab_offset]; |
|
67 |
242 |
out_vlc->table_allocated = 1 << max_len; |
|
68 |
|||
69 |
242 |
ff_init_vlc_from_lengths(out_vlc, max_len, index, bits, 1, |
|
70 |
*xlat, 1, 1, 0, INIT_VLC_USE_NEW_STATIC, NULL); |
||
71 |
|||
72 |
242 |
*tab_offset += 1 << max_len; |
|
73 |
242 |
*xlat += index; |
|
74 |
242 |
} |
|
75 |
|||
76 |
2 |
av_cold void ff_atrac3p_init_vlcs(void) |
|
77 |
{ |
||
78 |
2 |
int i, tab_offset = 0; |
|
79 |
const uint8_t *xlats; |
||
80 |
|||
81 |
2 |
xlats = atrac3p_wl_ct_xlats; |
|
82 |
✓✓ | 10 |
for (int i = 0; i < 4; i++) { |
83 |
8 |
build_canonical_huff(atrac3p_wl_cbs[i], &xlats, |
|
84 |
&tab_offset, &wl_vlc_tabs[i]); |
||
85 |
8 |
build_canonical_huff(atrac3p_ct_cbs[i], &xlats, |
|
86 |
&tab_offset, &ct_vlc_tabs[i]); |
||
87 |
} |
||
88 |
|||
89 |
2 |
xlats = atrac3p_sf_xlats; |
|
90 |
✓✓ | 18 |
for (int i = 0; i < 8; i++) |
91 |
16 |
build_canonical_huff(atrac3p_sf_cbs[i], &xlats, |
|
92 |
&tab_offset, &sf_vlc_tabs[i]); |
||
93 |
|||
94 |
/* build huffman tables for spectrum decoding */ |
||
95 |
2 |
xlats = atrac3p_spectra_xlats; |
|
96 |
✓✓ | 226 |
for (i = 0; i < 112; i++) { |
97 |
✓✓ | 224 |
if (atrac3p_spectra_cbs[i][0] >= 0) |
98 |
174 |
build_canonical_huff(atrac3p_spectra_cbs[i], |
|
99 |
&xlats, &tab_offset, &spec_vlc_tabs[i]); |
||
100 |
else /* Reuse already initialized VLC table */ |
||
101 |
50 |
spec_vlc_tabs[i] = spec_vlc_tabs[-atrac3p_spectra_cbs[i][0]]; |
|
102 |
} |
||
103 |
|||
104 |
/* build huffman tables for gain data decoding */ |
||
105 |
2 |
xlats = atrac3p_gain_xlats; |
|
106 |
✓✓ | 24 |
for (i = 0; i < 11; i++) |
107 |
22 |
build_canonical_huff(atrac3p_gain_cbs[i], &xlats, |
|
108 |
&tab_offset, &gain_vlc_tabs[i]); |
||
109 |
|||
110 |
/* build huffman tables for tone decoding */ |
||
111 |
2 |
xlats = atrac3p_tone_xlats; |
|
112 |
✓✓ | 16 |
for (i = 0; i < 7; i++) |
113 |
14 |
build_canonical_huff(atrac3p_tone_cbs[i], &xlats, |
|
114 |
&tab_offset, &tone_vlc_tabs[i]); |
||
115 |
2 |
} |
|
116 |
|||
117 |
/** |
||
118 |
* Decode number of coded quantization units. |
||
119 |
* |
||
120 |
* @param[in] gb the GetBit context |
||
121 |
* @param[in,out] chan ptr to the channel parameters |
||
122 |
* @param[in,out] ctx ptr to the channel unit context |
||
123 |
* @param[in] avctx ptr to the AVCodecContext |
||
124 |
* @return result code: 0 = OK, otherwise - error code |
||
125 |
*/ |
||
126 |
724 |
static int num_coded_units(GetBitContext *gb, Atrac3pChanParams *chan, |
|
127 |
Atrac3pChanUnitCtx *ctx, AVCodecContext *avctx) |
||
128 |
{ |
||
129 |
724 |
chan->fill_mode = get_bits(gb, 2); |
|
130 |
✓✓ | 724 |
if (!chan->fill_mode) { |
131 |
155 |
chan->num_coded_vals = ctx->num_quant_units; |
|
132 |
} else { |
||
133 |
569 |
chan->num_coded_vals = get_bits(gb, 5); |
|
134 |
✗✓ | 569 |
if (chan->num_coded_vals > ctx->num_quant_units) { |
135 |
av_log(avctx, AV_LOG_ERROR, |
||
136 |
"Invalid number of transmitted units!\n"); |
||
137 |
return AVERROR_INVALIDDATA; |
||
138 |
} |
||
139 |
|||
140 |
✓✓ | 569 |
if (chan->fill_mode == 3) |
141 |
134 |
chan->split_point = get_bits(gb, 2) + (chan->ch_num << 1) + 1; |
|
142 |
} |
||
143 |
|||
144 |
724 |
return 0; |
|
145 |
} |
||
146 |
|||
147 |
/** |
||
148 |
* Add weighting coefficients to the decoded word-length information. |
||
149 |
* |
||
150 |
* @param[in,out] ctx ptr to the channel unit context |
||
151 |
* @param[in,out] chan ptr to the channel parameters |
||
152 |
* @param[in] wtab_idx index of the table of weights |
||
153 |
* @param[in] avctx ptr to the AVCodecContext |
||
154 |
* @return result code: 0 = OK, otherwise - error code |
||
155 |
*/ |
||
156 |
110 |
static int add_wordlen_weights(Atrac3pChanUnitCtx *ctx, |
|
157 |
Atrac3pChanParams *chan, int wtab_idx, |
||
158 |
AVCodecContext *avctx) |
||
159 |
{ |
||
160 |
int i; |
||
161 |
110 |
const int8_t *weights_tab = |
|
162 |
110 |
&atrac3p_wl_weights[chan->ch_num * 3 + wtab_idx - 1][0]; |
|
163 |
|||
164 |
✓✓ | 2970 |
for (i = 0; i < ctx->num_quant_units; i++) { |
165 |
2860 |
chan->qu_wordlen[i] += weights_tab[i]; |
|
166 |
✓✗✗✓ |
2860 |
if (chan->qu_wordlen[i] < 0 || chan->qu_wordlen[i] > 7) { |
167 |
av_log(avctx, AV_LOG_ERROR, |
||
168 |
"WL index out of range: pos=%d, val=%d!\n", |
||
169 |
i, chan->qu_wordlen[i]); |
||
170 |
return AVERROR_INVALIDDATA; |
||
171 |
} |
||
172 |
} |
||
173 |
|||
174 |
110 |
return 0; |
|
175 |
} |
||
176 |
|||
177 |
/** |
||
178 |
* Subtract weighting coefficients from decoded scalefactors. |
||
179 |
* |
||
180 |
* @param[in,out] ctx ptr to the channel unit context |
||
181 |
* @param[in,out] chan ptr to the channel parameters |
||
182 |
* @param[in] wtab_idx index of table of weights |
||
183 |
* @param[in] avctx ptr to the AVCodecContext |
||
184 |
* @return result code: 0 = OK, otherwise - error code |
||
185 |
*/ |
||
186 |
144 |
static int subtract_sf_weights(Atrac3pChanUnitCtx *ctx, |
|
187 |
Atrac3pChanParams *chan, int wtab_idx, |
||
188 |
AVCodecContext *avctx) |
||
189 |
{ |
||
190 |
int i; |
||
191 |
144 |
const int8_t *weights_tab = &atrac3p_sf_weights[wtab_idx - 1][0]; |
|
192 |
|||
193 |
✓✓ | 3888 |
for (i = 0; i < ctx->used_quant_units; i++) { |
194 |
3744 |
chan->qu_sf_idx[i] -= weights_tab[i]; |
|
195 |
✓✗✗✓ |
3744 |
if (chan->qu_sf_idx[i] < 0 || chan->qu_sf_idx[i] > 63) { |
196 |
av_log(avctx, AV_LOG_ERROR, |
||
197 |
"SF index out of range: pos=%d, val=%d!\n", |
||
198 |
i, chan->qu_sf_idx[i]); |
||
199 |
return AVERROR_INVALIDDATA; |
||
200 |
} |
||
201 |
} |
||
202 |
|||
203 |
144 |
return 0; |
|
204 |
} |
||
205 |
|||
206 |
/** |
||
207 |
* Unpack vector quantization tables. |
||
208 |
* |
||
209 |
* @param[in] start_val start value for the unpacked table |
||
210 |
* @param[in] shape_vec ptr to table to unpack |
||
211 |
* @param[out] dst ptr to output array |
||
212 |
* @param[in] num_values number of values to unpack |
||
213 |
*/ |
||
214 |
243 |
static inline void unpack_vq_shape(int start_val, const int8_t *shape_vec, |
|
215 |
int *dst, int num_values) |
||
216 |
{ |
||
217 |
int i; |
||
218 |
|||
219 |
✓✗ | 243 |
if (num_values) { |
220 |
243 |
dst[0] = dst[1] = dst[2] = start_val; |
|
221 |
✓✓ | 4965 |
for (i = 3; i < num_values; i++) |
222 |
4722 |
dst[i] = start_val - shape_vec[atrac3p_qu_num_to_seg[i] - 1]; |
|
223 |
} |
||
224 |
243 |
} |
|
225 |
|||
226 |
#define UNPACK_SF_VQ_SHAPE(gb, dst, num_vals) \ |
||
227 |
start_val = get_bits((gb), 6); \ |
||
228 |
unpack_vq_shape(start_val, &atrac3p_sf_shapes[get_bits((gb), 6)][0], \ |
||
229 |
(dst), (num_vals)) |
||
230 |
|||
231 |
/** |
||
232 |
* Decode word length for each quantization unit of a channel. |
||
233 |
* |
||
234 |
* @param[in] gb the GetBit context |
||
235 |
* @param[in,out] ctx ptr to the channel unit context |
||
236 |
* @param[in] ch_num channel to process |
||
237 |
* @param[in] avctx ptr to the AVCodecContext |
||
238 |
* @return result code: 0 = OK, otherwise - error code |
||
239 |
*/ |
||
240 |
1626 |
static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
241 |
int ch_num, AVCodecContext *avctx) |
||
242 |
{ |
||
243 |
1626 |
int i, weight_idx = 0, delta, diff, pos, delta_bits, min_val, flag, |
|
244 |
ret, start_val; |
||
245 |
VLC *vlc_tab; |
||
246 |
1626 |
Atrac3pChanParams *chan = &ctx->channels[ch_num]; |
|
247 |
1626 |
Atrac3pChanParams *ref_chan = &ctx->channels[0]; |
|
248 |
|||
249 |
1626 |
chan->fill_mode = 0; |
|
250 |
|||
251 |
✓✓✓✓ ✗ |
1626 |
switch (get_bits(gb, 2)) { /* switch according to coding mode */ |
252 |
902 |
case 0: /* coded using constant number of bits */ |
|
253 |
✓✓ | 29766 |
for (i = 0; i < ctx->num_quant_units; i++) |
254 |
28864 |
chan->qu_wordlen[i] = get_bits(gb, 3); |
|
255 |
902 |
break; |
|
256 |
368 |
case 1: |
|
257 |
✓✓ | 368 |
if (ch_num) { |
258 |
✗✓ | 351 |
if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0) |
259 |
return ret; |
||
260 |
|||
261 |
✓✓ | 351 |
if (chan->num_coded_vals) { |
262 |
314 |
vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)]; |
|
263 |
|||
264 |
✓✓ | 4833 |
for (i = 0; i < chan->num_coded_vals; i++) { |
265 |
4519 |
delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
266 |
4519 |
chan->qu_wordlen[i] = (ref_chan->qu_wordlen[i] + delta) & 7; |
|
267 |
} |
||
268 |
} |
||
269 |
} else { |
||
270 |
17 |
weight_idx = get_bits(gb, 2); |
|
271 |
✗✓ | 17 |
if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0) |
272 |
return ret; |
||
273 |
|||
274 |
✓✗ | 17 |
if (chan->num_coded_vals) { |
275 |
17 |
pos = get_bits(gb, 5); |
|
276 |
✗✓ | 17 |
if (pos > chan->num_coded_vals) { |
277 |
av_log(avctx, AV_LOG_ERROR, |
||
278 |
"WL mode 1: invalid position!\n"); |
||
279 |
return AVERROR_INVALIDDATA; |
||
280 |
} |
||
281 |
|||
282 |
17 |
delta_bits = get_bits(gb, 2); |
|
283 |
17 |
min_val = get_bits(gb, 3); |
|
284 |
|||
285 |
✓✓ | 75 |
for (i = 0; i < pos; i++) |
286 |
58 |
chan->qu_wordlen[i] = get_bits(gb, 3); |
|
287 |
|||
288 |
✓✓ | 363 |
for (i = pos; i < chan->num_coded_vals; i++) |
289 |
346 |
chan->qu_wordlen[i] = (min_val + get_bitsz(gb, delta_bits)) & 7; |
|
290 |
} |
||
291 |
} |
||
292 |
368 |
break; |
|
293 |
162 |
case 2: |
|
294 |
✗✓ | 162 |
if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0) |
295 |
return ret; |
||
296 |
|||
297 |
✓✓✓✗ |
162 |
if (ch_num && chan->num_coded_vals) { |
298 |
11 |
vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)]; |
|
299 |
11 |
delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
300 |
11 |
chan->qu_wordlen[0] = (ref_chan->qu_wordlen[0] + delta) & 7; |
|
301 |
|||
302 |
✓✓ | 151 |
for (i = 1; i < chan->num_coded_vals; i++) { |
303 |
140 |
diff = ref_chan->qu_wordlen[i] - ref_chan->qu_wordlen[i - 1]; |
|
304 |
140 |
delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
305 |
140 |
chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + diff + delta) & 7; |
|
306 |
} |
||
307 |
✓✗ | 151 |
} else if (chan->num_coded_vals) { |
308 |
151 |
flag = get_bits(gb, 1); |
|
309 |
151 |
vlc_tab = &wl_vlc_tabs[get_bits(gb, 1)]; |
|
310 |
|||
311 |
151 |
start_val = get_bits(gb, 3); |
|
312 |
151 |
unpack_vq_shape(start_val, |
|
313 |
151 |
&atrac3p_wl_shapes[start_val][get_bits(gb, 4)][0], |
|
314 |
151 |
chan->qu_wordlen, chan->num_coded_vals); |
|
315 |
|||
316 |
✓✓ | 151 |
if (!flag) { |
317 |
✓✓ | 2964 |
for (i = 0; i < chan->num_coded_vals; i++) { |
318 |
2826 |
delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
319 |
2826 |
chan->qu_wordlen[i] = (chan->qu_wordlen[i] + delta) & 7; |
|
320 |
} |
||
321 |
} else { |
||
322 |
✓✓ | 128 |
for (i = 0; i < (chan->num_coded_vals & - 2); i += 2) |
323 |
✓✓ | 115 |
if (!get_bits1(gb)) { |
324 |
102 |
chan->qu_wordlen[i] = (chan->qu_wordlen[i] + |
|
325 |
51 |
get_vlc2(gb, vlc_tab->table, |
|
326 |
51 |
vlc_tab->bits, 1)) & 7; |
|
327 |
102 |
chan->qu_wordlen[i + 1] = (chan->qu_wordlen[i + 1] + |
|
328 |
51 |
get_vlc2(gb, vlc_tab->table, |
|
329 |
51 |
vlc_tab->bits, 1)) & 7; |
|
330 |
} |
||
331 |
|||
332 |
✓✓ | 13 |
if (chan->num_coded_vals & 1) |
333 |
6 |
chan->qu_wordlen[i] = (chan->qu_wordlen[i] + |
|
334 |
3 |
get_vlc2(gb, vlc_tab->table, |
|
335 |
3 |
vlc_tab->bits, 1)) & 7; |
|
336 |
} |
||
337 |
} |
||
338 |
162 |
break; |
|
339 |
194 |
case 3: |
|
340 |
194 |
weight_idx = get_bits(gb, 2); |
|
341 |
✗✓ | 194 |
if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0) |
342 |
return ret; |
||
343 |
|||
344 |
✓✓ | 194 |
if (chan->num_coded_vals) { |
345 |
157 |
vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)]; |
|
346 |
|||
347 |
/* first coefficient is coded directly */ |
||
348 |
157 |
chan->qu_wordlen[0] = get_bits(gb, 3); |
|
349 |
|||
350 |
✓✓ | 3005 |
for (i = 1; i < chan->num_coded_vals; i++) { |
351 |
2848 |
delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
352 |
2848 |
chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + delta) & 7; |
|
353 |
} |
||
354 |
} |
||
355 |
194 |
break; |
|
356 |
} |
||
357 |
|||
358 |
✓✓ | 1626 |
if (chan->fill_mode == 2) { |
359 |
✓✓ | 2147 |
for (i = chan->num_coded_vals; i < ctx->num_quant_units; i++) |
360 |
✗✓ | 1978 |
chan->qu_wordlen[i] = ch_num ? get_bits1(gb) : 1; |
361 |
✓✓ | 1457 |
} else if (chan->fill_mode == 3) { |
362 |
267 |
pos = ch_num ? chan->num_coded_vals + chan->split_point |
|
363 |
✓✓ | 134 |
: ctx->num_quant_units - chan->split_point; |
364 |
✗✓ | 134 |
if (pos > FF_ARRAY_ELEMS(chan->qu_wordlen)) { |
365 |
av_log(avctx, AV_LOG_ERROR, "Split point beyond array\n"); |
||
366 |
pos = FF_ARRAY_ELEMS(chan->qu_wordlen); |
||
367 |
} |
||
368 |
✓✓ | 663 |
for (i = chan->num_coded_vals; i < pos; i++) |
369 |
529 |
chan->qu_wordlen[i] = 1; |
|
370 |
} |
||
371 |
|||
372 |
✓✓ | 1626 |
if (weight_idx) |
373 |
110 |
return add_wordlen_weights(ctx, chan, weight_idx, avctx); |
|
374 |
|||
375 |
1516 |
return 0; |
|
376 |
} |
||
377 |
|||
378 |
/** |
||
379 |
* Decode scale factor indexes for each quant unit of a channel. |
||
380 |
* |
||
381 |
* @param[in] gb the GetBit context |
||
382 |
* @param[in,out] ctx ptr to the channel unit context |
||
383 |
* @param[in] ch_num channel to process |
||
384 |
* @param[in] avctx ptr to the AVCodecContext |
||
385 |
* @return result code: 0 = OK, otherwise - error code |
||
386 |
*/ |
||
387 |
1552 |
static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
388 |
int ch_num, AVCodecContext *avctx) |
||
389 |
{ |
||
390 |
1552 |
int i, weight_idx = 0, delta, diff, num_long_vals, |
|
391 |
delta_bits, min_val, vlc_sel, start_val; |
||
392 |
VLC *vlc_tab; |
||
393 |
1552 |
Atrac3pChanParams *chan = &ctx->channels[ch_num]; |
|
394 |
1552 |
Atrac3pChanParams *ref_chan = &ctx->channels[0]; |
|
395 |
|||
396 |
✓✓✓✓ ✗ |
1552 |
switch (get_bits(gb, 2)) { /* switch according to coding mode */ |
397 |
902 |
case 0: /* coded using constant number of bits */ |
|
398 |
✓✓ | 27962 |
for (i = 0; i < ctx->used_quant_units; i++) |
399 |
27060 |
chan->qu_sf_idx[i] = get_bits(gb, 6); |
|
400 |
902 |
break; |
|
401 |
322 |
case 1: |
|
402 |
✓✓ | 322 |
if (ch_num) { |
403 |
211 |
vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)]; |
|
404 |
|||
405 |
✓✓ | 5697 |
for (i = 0; i < ctx->used_quant_units; i++) { |
406 |
5486 |
delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
407 |
5486 |
chan->qu_sf_idx[i] = (ref_chan->qu_sf_idx[i] + delta) & 0x3F; |
|
408 |
} |
||
409 |
} else { |
||
410 |
111 |
weight_idx = get_bits(gb, 2); |
|
411 |
✓✓ | 111 |
if (weight_idx == 3) { |
412 |
42 |
UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units); |
|
413 |
|||
414 |
42 |
num_long_vals = get_bits(gb, 5); |
|
415 |
42 |
delta_bits = get_bits(gb, 2); |
|
416 |
42 |
min_val = get_bits(gb, 4) - 7; |
|
417 |
|||
418 |
✓✓ | 874 |
for (i = 0; i < num_long_vals; i++) |
419 |
1664 |
chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] + |
|
420 |
832 |
get_bits(gb, 4) - 7) & 0x3F; |
|
421 |
|||
422 |
/* all others are: min_val + delta */ |
||
423 |
✓✓ | 302 |
for (i = num_long_vals; i < ctx->used_quant_units; i++) |
424 |
520 |
chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] + min_val + |
|
425 |
260 |
get_bitsz(gb, delta_bits)) & 0x3F; |
|
426 |
} else { |
||
427 |
69 |
num_long_vals = get_bits(gb, 5); |
|
428 |
69 |
delta_bits = get_bits(gb, 3); |
|
429 |
69 |
min_val = get_bits(gb, 6); |
|
430 |
✓✗✗✓ |
69 |
if (num_long_vals > ctx->used_quant_units || delta_bits == 7) { |
431 |
av_log(avctx, AV_LOG_ERROR, |
||
432 |
"SF mode 1: invalid parameters!\n"); |
||
433 |
return AVERROR_INVALIDDATA; |
||
434 |
} |
||
435 |
|||
436 |
/* read full-precision SF indexes */ |
||
437 |
✓✓ | 719 |
for (i = 0; i < num_long_vals; i++) |
438 |
650 |
chan->qu_sf_idx[i] = get_bits(gb, 6); |
|
439 |
|||
440 |
/* all others are: min_val + delta */ |
||
441 |
✓✓ | 1213 |
for (i = num_long_vals; i < ctx->used_quant_units; i++) |
442 |
1144 |
chan->qu_sf_idx[i] = (min_val + |
|
443 |
1144 |
get_bitsz(gb, delta_bits)) & 0x3F; |
|
444 |
} |
||
445 |
} |
||
446 |
322 |
break; |
|
447 |
163 |
case 2: |
|
448 |
✓✓ | 163 |
if (ch_num) { |
449 |
114 |
vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)]; |
|
450 |
|||
451 |
114 |
delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
452 |
114 |
chan->qu_sf_idx[0] = (ref_chan->qu_sf_idx[0] + delta) & 0x3F; |
|
453 |
|||
454 |
✓✓ | 2964 |
for (i = 1; i < ctx->used_quant_units; i++) { |
455 |
2850 |
diff = ref_chan->qu_sf_idx[i] - ref_chan->qu_sf_idx[i - 1]; |
|
456 |
2850 |
delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
457 |
2850 |
chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + diff + delta) & 0x3F; |
|
458 |
} |
||
459 |
} else { |
||
460 |
49 |
vlc_tab = &sf_vlc_tabs[get_bits(gb, 2) + 4]; |
|
461 |
|||
462 |
49 |
UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units); |
|
463 |
|||
464 |
✓✓ | 1323 |
for (i = 0; i < ctx->used_quant_units; i++) { |
465 |
1274 |
delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
466 |
1274 |
chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] + |
|
467 |
1274 |
sign_extend(delta, 4)) & 0x3F; |
|
468 |
} |
||
469 |
} |
||
470 |
163 |
break; |
|
471 |
165 |
case 3: |
|
472 |
✗✓ | 165 |
if (ch_num) { |
473 |
/* copy coefficients from reference channel */ |
||
474 |
for (i = 0; i < ctx->used_quant_units; i++) |
||
475 |
chan->qu_sf_idx[i] = ref_chan->qu_sf_idx[i]; |
||
476 |
} else { |
||
477 |
165 |
weight_idx = get_bits(gb, 2); |
|
478 |
165 |
vlc_sel = get_bits(gb, 2); |
|
479 |
165 |
vlc_tab = &sf_vlc_tabs[vlc_sel]; |
|
480 |
|||
481 |
✓✓ | 165 |
if (weight_idx == 3) { |
482 |
1 |
vlc_tab = &sf_vlc_tabs[vlc_sel + 4]; |
|
483 |
|||
484 |
1 |
UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units); |
|
485 |
|||
486 |
1 |
diff = (get_bits(gb, 4) + 56) & 0x3F; |
|
487 |
1 |
chan->qu_sf_idx[0] = (chan->qu_sf_idx[0] + diff) & 0x3F; |
|
488 |
|||
489 |
✓✓ | 26 |
for (i = 1; i < ctx->used_quant_units; i++) { |
490 |
25 |
delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
491 |
25 |
diff = (diff + sign_extend(delta, 4)) & 0x3F; |
|
492 |
25 |
chan->qu_sf_idx[i] = (diff + chan->qu_sf_idx[i]) & 0x3F; |
|
493 |
} |
||
494 |
} else { |
||
495 |
/* 1st coefficient is coded directly */ |
||
496 |
164 |
chan->qu_sf_idx[0] = get_bits(gb, 6); |
|
497 |
|||
498 |
✓✓ | 4264 |
for (i = 1; i < ctx->used_quant_units; i++) { |
499 |
4100 |
delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
500 |
4100 |
chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + delta) & 0x3F; |
|
501 |
} |
||
502 |
} |
||
503 |
} |
||
504 |
165 |
break; |
|
505 |
} |
||
506 |
|||
507 |
✓✓✓✓ |
1552 |
if (weight_idx && weight_idx < 3) |
508 |
144 |
return subtract_sf_weights(ctx, chan, weight_idx, avctx); |
|
509 |
|||
510 |
1408 |
return 0; |
|
511 |
} |
||
512 |
|||
513 |
/** |
||
514 |
* Decode word length information for each channel. |
||
515 |
* |
||
516 |
* @param[in] gb the GetBit context |
||
517 |
* @param[in,out] ctx ptr to the channel unit context |
||
518 |
* @param[in] num_channels number of channels to process |
||
519 |
* @param[in] avctx ptr to the AVCodecContext |
||
520 |
* @return result code: 0 = OK, otherwise - error code |
||
521 |
*/ |
||
522 |
813 |
static int decode_quant_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
523 |
int num_channels, AVCodecContext *avctx) |
||
524 |
{ |
||
525 |
int ch_num, i, ret; |
||
526 |
|||
527 |
✓✓ | 2439 |
for (ch_num = 0; ch_num < num_channels; ch_num++) { |
528 |
1626 |
memset(ctx->channels[ch_num].qu_wordlen, 0, |
|
529 |
sizeof(ctx->channels[ch_num].qu_wordlen)); |
||
530 |
|||
531 |
✗✓ | 1626 |
if ((ret = decode_channel_wordlen(gb, ctx, ch_num, avctx)) < 0) |
532 |
return ret; |
||
533 |
} |
||
534 |
|||
535 |
/* scan for last non-zero coeff in both channels and |
||
536 |
* set number of quant units having coded spectrum */ |
||
537 |
✓✓ | 2677 |
for (i = ctx->num_quant_units - 1; i >= 0; i--) |
538 |
✓✓✓✗ |
2640 |
if (ctx->channels[0].qu_wordlen[i] || |
539 |
✓✗ | 1864 |
(num_channels == 2 && ctx->channels[1].qu_wordlen[i])) |
540 |
break; |
||
541 |
813 |
ctx->used_quant_units = i + 1; |
|
542 |
|||
543 |
813 |
return 0; |
|
544 |
} |
||
545 |
|||
546 |
/** |
||
547 |
* Decode scale factor indexes for each channel. |
||
548 |
* |
||
549 |
* @param[in] gb the GetBit context |
||
550 |
* @param[in,out] ctx ptr to the channel unit context |
||
551 |
* @param[in] num_channels number of channels to process |
||
552 |
* @param[in] avctx ptr to the AVCodecContext |
||
553 |
* @return result code: 0 = OK, otherwise - error code |
||
554 |
*/ |
||
555 |
813 |
static int decode_scale_factors(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
556 |
int num_channels, AVCodecContext *avctx) |
||
557 |
{ |
||
558 |
int ch_num, ret; |
||
559 |
|||
560 |
✓✓ | 813 |
if (!ctx->used_quant_units) |
561 |
37 |
return 0; |
|
562 |
|||
563 |
✓✓ | 2328 |
for (ch_num = 0; ch_num < num_channels; ch_num++) { |
564 |
1552 |
memset(ctx->channels[ch_num].qu_sf_idx, 0, |
|
565 |
sizeof(ctx->channels[ch_num].qu_sf_idx)); |
||
566 |
|||
567 |
✗✓ | 1552 |
if ((ret = decode_channel_sf_idx(gb, ctx, ch_num, avctx)) < 0) |
568 |
return ret; |
||
569 |
} |
||
570 |
|||
571 |
776 |
return 0; |
|
572 |
} |
||
573 |
|||
574 |
/** |
||
575 |
* Decode number of code table values. |
||
576 |
* |
||
577 |
* @param[in] gb the GetBit context |
||
578 |
* @param[in,out] ctx ptr to the channel unit context |
||
579 |
* @param[in] avctx ptr to the AVCodecContext |
||
580 |
* @return result code: 0 = OK, otherwise - error code |
||
581 |
*/ |
||
582 |
1552 |
static int get_num_ct_values(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
583 |
AVCodecContext *avctx) |
||
584 |
{ |
||
585 |
int num_coded_vals; |
||
586 |
|||
587 |
✓✓ | 1552 |
if (get_bits1(gb)) { |
588 |
356 |
num_coded_vals = get_bits(gb, 5); |
|
589 |
✗✓ | 356 |
if (num_coded_vals > ctx->used_quant_units) { |
590 |
av_log(avctx, AV_LOG_ERROR, |
||
591 |
"Invalid number of code table indexes: %d!\n", num_coded_vals); |
||
592 |
return AVERROR_INVALIDDATA; |
||
593 |
} |
||
594 |
356 |
return num_coded_vals; |
|
595 |
} else |
||
596 |
1196 |
return ctx->used_quant_units; |
|
597 |
} |
||
598 |
|||
599 |
#define DEC_CT_IDX_COMMON(OP) \ |
||
600 |
num_vals = get_num_ct_values(gb, ctx, avctx); \ |
||
601 |
if (num_vals < 0) \ |
||
602 |
return num_vals; \ |
||
603 |
\ |
||
604 |
for (i = 0; i < num_vals; i++) { \ |
||
605 |
if (chan->qu_wordlen[i]) { \ |
||
606 |
chan->qu_tab_idx[i] = OP; \ |
||
607 |
} else if (ch_num && ref_chan->qu_wordlen[i]) \ |
||
608 |
/* get clone master flag */ \ |
||
609 |
chan->qu_tab_idx[i] = get_bits1(gb); \ |
||
610 |
} |
||
611 |
|||
612 |
#define CODING_DIRECT get_bits(gb, num_bits) |
||
613 |
|||
614 |
#define CODING_VLC get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1) |
||
615 |
|||
616 |
#define CODING_VLC_DELTA \ |
||
617 |
(!i) ? CODING_VLC \ |
||
618 |
: (pred + get_vlc2(gb, delta_vlc->table, \ |
||
619 |
delta_vlc->bits, 1)) & mask; \ |
||
620 |
pred = chan->qu_tab_idx[i] |
||
621 |
|||
622 |
#define CODING_VLC_DIFF \ |
||
623 |
(ref_chan->qu_tab_idx[i] + \ |
||
624 |
get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)) & mask |
||
625 |
|||
626 |
/** |
||
627 |
* Decode code table indexes for each quant unit of a channel. |
||
628 |
* |
||
629 |
* @param[in] gb the GetBit context |
||
630 |
* @param[in,out] ctx ptr to the channel unit context |
||
631 |
* @param[in] ch_num channel to process |
||
632 |
* @param[in] avctx ptr to the AVCodecContext |
||
633 |
* @return result code: 0 = OK, otherwise - error code |
||
634 |
*/ |
||
635 |
1552 |
static int decode_channel_code_tab(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
636 |
int ch_num, AVCodecContext *avctx) |
||
637 |
{ |
||
638 |
int i, num_vals, num_bits, pred; |
||
639 |
✓✓ | 1552 |
int mask = ctx->use_full_table ? 7 : 3; /* mask for modular arithmetic */ |
640 |
VLC *vlc_tab, *delta_vlc; |
||
641 |
1552 |
Atrac3pChanParams *chan = &ctx->channels[ch_num]; |
|
642 |
1552 |
Atrac3pChanParams *ref_chan = &ctx->channels[0]; |
|
643 |
|||
644 |
1552 |
chan->table_type = get_bits1(gb); |
|
645 |
|||
646 |
✓✓✓✓ ✗ |
1552 |
switch (get_bits(gb, 2)) { /* switch according to coding mode */ |
647 |
980 |
case 0: /* directly coded */ |
|
648 |
980 |
num_bits = ctx->use_full_table + 2; |
|
649 |
✗✓✓✓ ✓✗✓✗ ✓✓ |
29385 |
DEC_CT_IDX_COMMON(CODING_DIRECT); |
650 |
980 |
break; |
|
651 |
275 |
case 1: /* entropy-coded */ |
|
652 |
550 |
vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[1] |
|
653 |
✓✗ | 275 |
: ct_vlc_tabs; |
654 |
✗✓✓✓ ✓✗✓✗ ✓✓ |
6385 |
DEC_CT_IDX_COMMON(CODING_VLC); |
655 |
275 |
break; |
|
656 |
191 |
case 2: /* entropy-coded delta */ |
|
657 |
✓✗ | 191 |
if (ctx->use_full_table) { |
658 |
191 |
vlc_tab = &ct_vlc_tabs[1]; |
|
659 |
191 |
delta_vlc = &ct_vlc_tabs[2]; |
|
660 |
} else { |
||
661 |
vlc_tab = ct_vlc_tabs; |
||
662 |
delta_vlc = ct_vlc_tabs; |
||
663 |
} |
||
664 |
191 |
pred = 0; |
|
665 |
✗✓✓✗ ✓✓✗✗ ✗✗✓✓ |
4501 |
DEC_CT_IDX_COMMON(CODING_VLC_DELTA); |
666 |
191 |
break; |
|
667 |
106 |
case 3: /* entropy-coded difference to master */ |
|
668 |
✓✗ | 106 |
if (ch_num) { |
669 |
212 |
vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[3] |
|
670 |
✓✗ | 106 |
: ct_vlc_tabs; |
671 |
✗✓✓✓ ✓✗✓✗ ✓✓ |
1755 |
DEC_CT_IDX_COMMON(CODING_VLC_DIFF); |
672 |
} |
||
673 |
106 |
break; |
|
674 |
} |
||
675 |
|||
676 |
1552 |
return 0; |
|
677 |
} |
||
678 |
|||
679 |
/** |
||
680 |
* Decode code table indexes for each channel. |
||
681 |
* |
||
682 |
* @param[in] gb the GetBit context |
||
683 |
* @param[in,out] ctx ptr to the channel unit context |
||
684 |
* @param[in] num_channels number of channels to process |
||
685 |
* @param[in] avctx ptr to the AVCodecContext |
||
686 |
* @return result code: 0 = OK, otherwise - error code |
||
687 |
*/ |
||
688 |
813 |
static int decode_code_table_indexes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
689 |
int num_channels, AVCodecContext *avctx) |
||
690 |
{ |
||
691 |
int ch_num, ret; |
||
692 |
|||
693 |
✓✓ | 813 |
if (!ctx->used_quant_units) |
694 |
37 |
return 0; |
|
695 |
|||
696 |
776 |
ctx->use_full_table = get_bits1(gb); |
|
697 |
|||
698 |
✓✓ | 2328 |
for (ch_num = 0; ch_num < num_channels; ch_num++) { |
699 |
1552 |
memset(ctx->channels[ch_num].qu_tab_idx, 0, |
|
700 |
sizeof(ctx->channels[ch_num].qu_tab_idx)); |
||
701 |
|||
702 |
✗✓ | 1552 |
if ((ret = decode_channel_code_tab(gb, ctx, ch_num, avctx)) < 0) |
703 |
return ret; |
||
704 |
} |
||
705 |
|||
706 |
776 |
return 0; |
|
707 |
} |
||
708 |
|||
709 |
/** |
||
710 |
* Decode huffman-coded spectral lines for a given quant unit. |
||
711 |
* |
||
712 |
* This is a generalized version for all known coding modes. |
||
713 |
* Its speed can be improved by creating separate functions for each mode. |
||
714 |
* |
||
715 |
* @param[in] gb the GetBit context |
||
716 |
* @param[in] tab code table telling how to decode spectral lines |
||
717 |
* @param[in] vlc_tab ptr to the huffman table associated with the code table |
||
718 |
* @param[out] out pointer to buffer where decoded data should be stored |
||
719 |
* @param[in] num_specs number of spectral lines to decode |
||
720 |
*/ |
||
721 |
40703 |
static void decode_qu_spectra(GetBitContext *gb, const Atrac3pSpecCodeTab *tab, |
|
722 |
VLC *vlc_tab, int16_t *out, const int num_specs) |
||
723 |
{ |
||
724 |
int i, j, pos, cf; |
||
725 |
40703 |
int group_size = tab->group_size; |
|
726 |
40703 |
int num_coeffs = tab->num_coeffs; |
|
727 |
40703 |
int bits = tab->bits; |
|
728 |
40703 |
int is_signed = tab->is_signed; |
|
729 |
unsigned val; |
||
730 |
|||
731 |
✓✓ | 1209621 |
for (pos = 0; pos < num_specs;) { |
732 |
✓✓✓✓ |
1168918 |
if (group_size == 1 || get_bits1(gb)) { |
733 |
✓✓ | 2332486 |
for (j = 0; j < group_size; j++) { |
734 |
1180390 |
val = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); |
|
735 |
|||
736 |
✓✓ | 3119394 |
for (i = 0; i < num_coeffs; i++) { |
737 |
1939004 |
cf = av_mod_uintp2(val, bits); |
|
738 |
✓✓ | 1939004 |
if (is_signed) |
739 |
1268212 |
cf = sign_extend(cf, bits); |
|
740 |
✓✓✓✓ |
670792 |
else if (cf && get_bits1(gb)) |
741 |
233973 |
cf = -cf; |
|
742 |
|||
743 |
1939004 |
out[pos++] = cf; |
|
744 |
1939004 |
val >>= bits; |
|
745 |
} |
||
746 |
} |
||
747 |
} else /* group skipped */ |
||
748 |
16822 |
pos += group_size * num_coeffs; |
|
749 |
} |
||
750 |
40703 |
} |
|
751 |
|||
752 |
/** |
||
753 |
* Decode huffman-coded IMDCT spectrum for all channels. |
||
754 |
* |
||
755 |
* @param[in] gb the GetBit context |
||
756 |
* @param[in,out] ctx ptr to the channel unit context |
||
757 |
* @param[in] num_channels number of channels to process |
||
758 |
* @param[in] avctx ptr to the AVCodecContext |
||
759 |
*/ |
||
760 |
813 |
static void decode_spectrum(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
761 |
int num_channels, AVCodecContext *avctx) |
||
762 |
{ |
||
763 |
int i, ch_num, qu, wordlen, codetab, tab_index, num_specs; |
||
764 |
const Atrac3pSpecCodeTab *tab; |
||
765 |
Atrac3pChanParams *chan; |
||
766 |
|||
767 |
✓✓ | 2439 |
for (ch_num = 0; ch_num < num_channels; ch_num++) { |
768 |
1626 |
chan = &ctx->channels[ch_num]; |
|
769 |
|||
770 |
1626 |
memset(chan->spectrum, 0, sizeof(chan->spectrum)); |
|
771 |
|||
772 |
/* set power compensation level to disabled */ |
||
773 |
1626 |
memset(chan->power_levs, ATRAC3P_POWER_COMP_OFF, sizeof(chan->power_levs)); |
|
774 |
|||
775 |
✓✓ | 45586 |
for (qu = 0; qu < ctx->used_quant_units; qu++) { |
776 |
43960 |
num_specs = ff_atrac3p_qu_to_spec_pos[qu + 1] - |
|
777 |
43960 |
ff_atrac3p_qu_to_spec_pos[qu]; |
|
778 |
|||
779 |
43960 |
wordlen = chan->qu_wordlen[qu]; |
|
780 |
43960 |
codetab = chan->qu_tab_idx[qu]; |
|
781 |
✓✓ | 43960 |
if (wordlen) { |
782 |
✓✓ | 40703 |
if (!ctx->use_full_table) |
783 |
27060 |
codetab = atrac3p_ct_restricted_to_full[chan->table_type][wordlen - 1][codetab]; |
|
784 |
|||
785 |
40703 |
tab_index = (chan->table_type * 8 + codetab) * 7 + wordlen - 1; |
|
786 |
40703 |
tab = &atrac3p_spectra_tabs[tab_index]; |
|
787 |
|||
788 |
40703 |
decode_qu_spectra(gb, tab, &spec_vlc_tabs[tab_index], |
|
789 |
40703 |
&chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]], |
|
790 |
num_specs); |
||
791 |
✓✗✓✗ ✓✗ |
3257 |
} else if (ch_num && ctx->channels[0].qu_wordlen[qu] && !codetab) { |
792 |
/* copy coefficients from master */ |
||
793 |
3257 |
memcpy(&chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]], |
|
794 |
3257 |
&ctx->channels[0].spectrum[ff_atrac3p_qu_to_spec_pos[qu]], |
|
795 |
num_specs * |
||
796 |
sizeof(chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]])); |
||
797 |
3257 |
chan->qu_wordlen[qu] = ctx->channels[0].qu_wordlen[qu]; |
|
798 |
} |
||
799 |
} |
||
800 |
|||
801 |
/* Power compensation levels only present in the bitstream |
||
802 |
* if there are more than 2 quant units. The lowest two units |
||
803 |
* correspond to the frequencies 0...351 Hz, whose shouldn't |
||
804 |
* be affected by the power compensation. */ |
||
805 |
✓✓ | 1626 |
if (ctx->used_quant_units > 2) { |
806 |
1552 |
num_specs = atrac3p_subband_to_num_powgrps[ctx->num_coded_subbands - 1]; |
|
807 |
✓✓ | 8662 |
for (i = 0; i < num_specs; i++) |
808 |
7110 |
chan->power_levs[i] = get_bits(gb, 4); |
|
809 |
} |
||
810 |
} |
||
811 |
813 |
} |
|
812 |
|||
813 |
/** |
||
814 |
* Retrieve specified amount of flag bits from the input bitstream. |
||
815 |
* The data can be shortened in the case of the following two common conditions: |
||
816 |
* if all bits are zero then only one signal bit = 0 will be stored, |
||
817 |
* if all bits are ones then two signal bits = 1,0 will be stored. |
||
818 |
* Otherwise, all necessary bits will be directly stored |
||
819 |
* prefixed by two signal bits = 1,1. |
||
820 |
* |
||
821 |
* @param[in] gb ptr to the GetBitContext |
||
822 |
* @param[out] out where to place decoded flags |
||
823 |
* @param[in] num_flags number of flags to process |
||
824 |
* @return: 0 = all flag bits are zero, 1 = there is at least one non-zero flag bit |
||
825 |
*/ |
||
826 |
3252 |
static int get_subband_flags(GetBitContext *gb, uint8_t *out, int num_flags) |
|
827 |
{ |
||
828 |
int i, result; |
||
829 |
|||
830 |
3252 |
memset(out, 0, num_flags); |
|
831 |
|||
832 |
3252 |
result = get_bits1(gb); |
|
833 |
✓✓ | 3252 |
if (result) { |
834 |
✓✓ | 493 |
if (get_bits1(gb)) |
835 |
✓✓ | 4609 |
for (i = 0; i < num_flags; i++) |
836 |
4190 |
out[i] = get_bits1(gb); |
|
837 |
else |
||
838 |
74 |
memset(out, 1, num_flags); |
|
839 |
} |
||
840 |
|||
841 |
3252 |
return result; |
|
842 |
} |
||
843 |
|||
844 |
/** |
||
845 |
* Decode mdct window shape flags for all channels. |
||
846 |
* |
||
847 |
* @param[in] gb the GetBit context |
||
848 |
* @param[in,out] ctx ptr to the channel unit context |
||
849 |
* @param[in] num_channels number of channels to process |
||
850 |
*/ |
||
851 |
813 |
static void decode_window_shape(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
852 |
int num_channels) |
||
853 |
{ |
||
854 |
int ch_num; |
||
855 |
|||
856 |
✓✓ | 2439 |
for (ch_num = 0; ch_num < num_channels; ch_num++) |
857 |
1626 |
get_subband_flags(gb, ctx->channels[ch_num].wnd_shape, |
|
858 |
ctx->num_subbands); |
||
859 |
813 |
} |
|
860 |
|||
861 |
/** |
||
862 |
* Decode number of gain control points. |
||
863 |
* |
||
864 |
* @param[in] gb the GetBit context |
||
865 |
* @param[in,out] ctx ptr to the channel unit context |
||
866 |
* @param[in] ch_num channel to process |
||
867 |
* @param[in] coded_subbands number of subbands to process |
||
868 |
* @return result code: 0 = OK, otherwise - error code |
||
869 |
*/ |
||
870 |
582 |
static int decode_gainc_npoints(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
871 |
int ch_num, int coded_subbands) |
||
872 |
{ |
||
873 |
int i, delta, delta_bits, min_val; |
||
874 |
582 |
Atrac3pChanParams *chan = &ctx->channels[ch_num]; |
|
875 |
582 |
Atrac3pChanParams *ref_chan = &ctx->channels[0]; |
|
876 |
|||
877 |
✓✓✓✓ ✗ |
582 |
switch (get_bits(gb, 2)) { /* switch according to coding mode */ |
878 |
15 |
case 0: /* fixed-length coding */ |
|
879 |
✓✓ | 40 |
for (i = 0; i < coded_subbands; i++) |
880 |
25 |
chan->gain_data[i].num_points = get_bits(gb, 3); |
|
881 |
15 |
break; |
|
882 |
509 |
case 1: /* variable-length coding */ |
|
883 |
✓✓ | 4086 |
for (i = 0; i < coded_subbands; i++) |
884 |
3577 |
chan->gain_data[i].num_points = |
|
885 |
3577 |
get_vlc2(gb, gain_vlc_tabs[0].table, |
|
886 |
gain_vlc_tabs[0].bits, 1); |
||
887 |
509 |
break; |
|
888 |
38 |
case 2: |
|
889 |
✓✓ | 38 |
if (ch_num) { /* VLC modulo delta to master channel */ |
890 |
✓✓ | 162 |
for (i = 0; i < coded_subbands; i++) { |
891 |
142 |
delta = get_vlc2(gb, gain_vlc_tabs[1].table, |
|
892 |
gain_vlc_tabs[1].bits, 1); |
||
893 |
142 |
chan->gain_data[i].num_points = |
|
894 |
142 |
(ref_chan->gain_data[i].num_points + delta) & 7; |
|
895 |
} |
||
896 |
} else { /* VLC modulo delta to previous */ |
||
897 |
36 |
chan->gain_data[0].num_points = |
|
898 |
18 |
get_vlc2(gb, gain_vlc_tabs[0].table, |
|
899 |
gain_vlc_tabs[0].bits, 1); |
||
900 |
|||
901 |
✓✓ | 105 |
for (i = 1; i < coded_subbands; i++) { |
902 |
87 |
delta = get_vlc2(gb, gain_vlc_tabs[1].table, |
|
903 |
gain_vlc_tabs[1].bits, 1); |
||
904 |
87 |
chan->gain_data[i].num_points = |
|
905 |
87 |
(chan->gain_data[i - 1].num_points + delta) & 7; |
|
906 |
} |
||
907 |
} |
||
908 |
38 |
break; |
|
909 |
20 |
case 3: |
|
910 |
✓✓ | 20 |
if (ch_num) { /* copy data from master channel */ |
911 |
✓✓ | 66 |
for (i = 0; i < coded_subbands; i++) |
912 |
48 |
chan->gain_data[i].num_points = |
|
913 |
48 |
ref_chan->gain_data[i].num_points; |
|
914 |
} else { /* shorter delta to min */ |
||
915 |
2 |
delta_bits = get_bits(gb, 2); |
|
916 |
2 |
min_val = get_bits(gb, 3); |
|
917 |
|||
918 |
✓✓ | 25 |
for (i = 0; i < coded_subbands; i++) { |
919 |
23 |
chan->gain_data[i].num_points = min_val + get_bitsz(gb, delta_bits); |
|
920 |
✗✓ | 23 |
if (chan->gain_data[i].num_points > 7) |
921 |
return AVERROR_INVALIDDATA; |
||
922 |
} |
||
923 |
} |
||
924 |
} |
||
925 |
|||
926 |
582 |
return 0; |
|
927 |
} |
||
928 |
|||
929 |
/** |
||
930 |
* Implements coding mode 3 (slave) for gain compensation levels. |
||
931 |
* |
||
932 |
* @param[out] dst ptr to the output array |
||
933 |
* @param[in] ref ptr to the reference channel |
||
934 |
*/ |
||
935 |
1605 |
static inline void gainc_level_mode3s(AtracGainInfo *dst, AtracGainInfo *ref) |
|
936 |
{ |
||
937 |
int i; |
||
938 |
|||
939 |
✓✓ | 2000 |
for (i = 0; i < dst->num_points; i++) |
940 |
✓✓ | 395 |
dst->lev_code[i] = (i >= ref->num_points) ? 7 : ref->lev_code[i]; |
941 |
1605 |
} |
|
942 |
|||
943 |
/** |
||
944 |
* Implements coding mode 1 (master) for gain compensation levels. |
||
945 |
* |
||
946 |
* @param[in] gb the GetBit context |
||
947 |
* @param[in] ctx ptr to the channel unit context |
||
948 |
* @param[out] dst ptr to the output array |
||
949 |
*/ |
||
950 |
2009 |
static inline void gainc_level_mode1m(GetBitContext *gb, |
|
951 |
Atrac3pChanUnitCtx *ctx, |
||
952 |
AtracGainInfo *dst) |
||
953 |
{ |
||
954 |
int i, delta; |
||
955 |
|||
956 |
✓✓ | 2009 |
if (dst->num_points > 0) |
957 |
501 |
dst->lev_code[0] = get_vlc2(gb, gain_vlc_tabs[2].table, |
|
958 |
gain_vlc_tabs[2].bits, 1); |
||
959 |
|||
960 |
✓✓ | 2110 |
for (i = 1; i < dst->num_points; i++) { |
961 |
101 |
delta = get_vlc2(gb, gain_vlc_tabs[3].table, |
|
962 |
gain_vlc_tabs[3].bits, 1); |
||
963 |
101 |
dst->lev_code[i] = (dst->lev_code[i - 1] + delta) & 0xF; |
|
964 |
} |
||
965 |
2009 |
} |
|
966 |
|||
967 |
/** |
||
968 |
* Decode level code for each gain control point. |
||
969 |
* |
||
970 |
* @param[in] gb the GetBit context |
||
971 |
* @param[in,out] ctx ptr to the channel unit context |
||
972 |
* @param[in] ch_num channel to process |
||
973 |
* @param[in] coded_subbands number of subbands to process |
||
974 |
* @return result code: 0 = OK, otherwise - error code |
||
975 |
*/ |
||
976 |
582 |
static int decode_gainc_levels(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
977 |
int ch_num, int coded_subbands) |
||
978 |
{ |
||
979 |
int sb, i, delta, delta_bits, min_val, pred; |
||
980 |
582 |
Atrac3pChanParams *chan = &ctx->channels[ch_num]; |
|
981 |
582 |
Atrac3pChanParams *ref_chan = &ctx->channels[0]; |
|
982 |
|||
983 |
✓✓✓✓ ✗ |
582 |
switch (get_bits(gb, 2)) { /* switch according to coding mode */ |
984 |
9 |
case 0: /* fixed-length coding */ |
|
985 |
✓✓ | 62 |
for (sb = 0; sb < coded_subbands; sb++) |
986 |
✓✓ | 71 |
for (i = 0; i < chan->gain_data[sb].num_points; i++) |
987 |
18 |
chan->gain_data[sb].lev_code[i] = get_bits(gb, 4); |
|
988 |
9 |
break; |
|
989 |
302 |
case 1: |
|
990 |
✓✓ | 302 |
if (ch_num) { /* VLC modulo delta to master channel */ |
991 |
✓✓ | 112 |
for (sb = 0; sb < coded_subbands; sb++) |
992 |
✓✓ | 162 |
for (i = 0; i < chan->gain_data[sb].num_points; i++) { |
993 |
68 |
delta = get_vlc2(gb, gain_vlc_tabs[5].table, |
|
994 |
gain_vlc_tabs[5].bits, 1); |
||
995 |
136 |
pred = (i >= ref_chan->gain_data[sb].num_points) |
|
996 |
✓✓ | 68 |
? 7 : ref_chan->gain_data[sb].lev_code[i]; |
997 |
68 |
chan->gain_data[sb].lev_code[i] = (pred + delta) & 0xF; |
|
998 |
} |
||
999 |
} else { /* VLC modulo delta to previous */ |
||
1000 |
✓✓ | 2242 |
for (sb = 0; sb < coded_subbands; sb++) |
1001 |
1958 |
gainc_level_mode1m(gb, ctx, &chan->gain_data[sb]); |
|
1002 |
} |
||
1003 |
302 |
break; |
|
1004 |
36 |
case 2: |
|
1005 |
✓✓ | 36 |
if (ch_num) { /* VLC modulo delta to previous or clone master */ |
1006 |
✓✓ | 257 |
for (sb = 0; sb < coded_subbands; sb++) |
1007 |
✓✓ | 225 |
if (chan->gain_data[sb].num_points > 0) { |
1008 |
✓✓ | 102 |
if (get_bits1(gb)) |
1009 |
49 |
gainc_level_mode1m(gb, ctx, &chan->gain_data[sb]); |
|
1010 |
else |
||
1011 |
53 |
gainc_level_mode3s(&chan->gain_data[sb], |
|
1012 |
53 |
&ref_chan->gain_data[sb]); |
|
1013 |
} |
||
1014 |
} else { /* VLC modulo delta to lev_codes of previous subband */ |
||
1015 |
✓✓ | 4 |
if (chan->gain_data[0].num_points > 0) |
1016 |
2 |
gainc_level_mode1m(gb, ctx, &chan->gain_data[0]); |
|
1017 |
|||
1018 |
✓✓ | 38 |
for (sb = 1; sb < coded_subbands; sb++) |
1019 |
✓✓ | 77 |
for (i = 0; i < chan->gain_data[sb].num_points; i++) { |
1020 |
43 |
delta = get_vlc2(gb, gain_vlc_tabs[4].table, |
|
1021 |
gain_vlc_tabs[4].bits, 1); |
||
1022 |
86 |
pred = (i >= chan->gain_data[sb - 1].num_points) |
|
1023 |
✓✓ | 43 |
? 7 : chan->gain_data[sb - 1].lev_code[i]; |
1024 |
43 |
chan->gain_data[sb].lev_code[i] = (pred + delta) & 0xF; |
|
1025 |
} |
||
1026 |
} |
||
1027 |
36 |
break; |
|
1028 |
235 |
case 3: |
|
1029 |
✓✗ | 235 |
if (ch_num) { /* clone master */ |
1030 |
✓✓ | 1787 |
for (sb = 0; sb < coded_subbands; sb++) |
1031 |
1552 |
gainc_level_mode3s(&chan->gain_data[sb], |
|
1032 |
1552 |
&ref_chan->gain_data[sb]); |
|
1033 |
} else { /* shorter delta to min */ |
||
1034 |
delta_bits = get_bits(gb, 2); |
||
1035 |
min_val = get_bits(gb, 4); |
||
1036 |
|||
1037 |
for (sb = 0; sb < coded_subbands; sb++) |
||
1038 |
for (i = 0; i < chan->gain_data[sb].num_points; i++) { |
||
1039 |
chan->gain_data[sb].lev_code[i] = min_val + get_bitsz(gb, delta_bits); |
||
1040 |
if (chan->gain_data[sb].lev_code[i] > 15) |
||
1041 |
return AVERROR_INVALIDDATA; |
||
1042 |
} |
||
1043 |
} |
||
1044 |
235 |
break; |
|
1045 |
} |
||
1046 |
|||
1047 |
582 |
return 0; |
|
1048 |
} |
||
1049 |
|||
1050 |
/** |
||
1051 |
* Implements coding mode 0 for gain compensation locations. |
||
1052 |
* |
||
1053 |
* @param[in] gb the GetBit context |
||
1054 |
* @param[in] ctx ptr to the channel unit context |
||
1055 |
* @param[out] dst ptr to the output array |
||
1056 |
* @param[in] pos position of the value to be processed |
||
1057 |
*/ |
||
1058 |
664 |
static inline void gainc_loc_mode0(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
1059 |
AtracGainInfo *dst, int pos) |
||
1060 |
{ |
||
1061 |
int delta_bits; |
||
1062 |
|||
1063 |
✓✓✓✓ |
664 |
if (!pos || dst->loc_code[pos - 1] < 15) |
1064 |
646 |
dst->loc_code[pos] = get_bits(gb, 5); |
|
1065 |
✗✓ | 18 |
else if (dst->loc_code[pos - 1] >= 30) |
1066 |
dst->loc_code[pos] = 31; |
||
1067 |
else { |
||
1068 |
18 |
delta_bits = av_log2(30 - dst->loc_code[pos - 1]) + 1; |
|
1069 |
36 |
dst->loc_code[pos] = dst->loc_code[pos - 1] + |
|
1070 |
18 |
get_bits(gb, delta_bits) + 1; |
|
1071 |
} |
||
1072 |
664 |
} |
|
1073 |
|||
1074 |
/** |
||
1075 |
* Implements coding mode 1 for gain compensation locations. |
||
1076 |
* |
||
1077 |
* @param[in] gb the GetBit context |
||
1078 |
* @param[in] ctx ptr to the channel unit context |
||
1079 |
* @param[out] dst ptr to the output array |
||
1080 |
*/ |
||
1081 |
111 |
static inline void gainc_loc_mode1(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
1082 |
AtracGainInfo *dst) |
||
1083 |
{ |
||
1084 |
int i; |
||
1085 |
VLC *tab; |
||
1086 |
|||
1087 |
✓✓ | 111 |
if (dst->num_points > 0) { |
1088 |
/* 1st coefficient is stored directly */ |
||
1089 |
70 |
dst->loc_code[0] = get_bits(gb, 5); |
|
1090 |
|||
1091 |
✓✓ | 114 |
for (i = 1; i < dst->num_points; i++) { |
1092 |
/* switch VLC according to the curve direction |
||
1093 |
* (ascending/descending) */ |
||
1094 |
88 |
tab = (dst->lev_code[i] <= dst->lev_code[i - 1]) |
|
1095 |
? &gain_vlc_tabs[7] |
||
1096 |
✓✗ | 44 |
: &gain_vlc_tabs[9]; |
1097 |
44 |
dst->loc_code[i] = dst->loc_code[i - 1] + |
|
1098 |
44 |
get_vlc2(gb, tab->table, tab->bits, 1); |
|
1099 |
} |
||
1100 |
} |
||
1101 |
111 |
} |
|
1102 |
|||
1103 |
/** |
||
1104 |
* Decode location code for each gain control point. |
||
1105 |
* |
||
1106 |
* @param[in] gb the GetBit context |
||
1107 |
* @param[in,out] ctx ptr to the channel unit context |
||
1108 |
* @param[in] ch_num channel to process |
||
1109 |
* @param[in] coded_subbands number of subbands to process |
||
1110 |
* @param[in] avctx ptr to the AVCodecContext |
||
1111 |
* @return result code: 0 = OK, otherwise - error code |
||
1112 |
*/ |
||
1113 |
582 |
static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
1114 |
int ch_num, int coded_subbands, |
||
1115 |
AVCodecContext *avctx) |
||
1116 |
{ |
||
1117 |
int sb, i, delta, delta_bits, min_val, pred, more_than_ref; |
||
1118 |
AtracGainInfo *dst, *ref; |
||
1119 |
VLC *tab; |
||
1120 |
582 |
Atrac3pChanParams *chan = &ctx->channels[ch_num]; |
|
1121 |
582 |
Atrac3pChanParams *ref_chan = &ctx->channels[0]; |
|
1122 |
|||
1123 |
✓✓✓✓ ✗ |
582 |
switch (get_bits(gb, 2)) { /* switch according to coding mode */ |
1124 |
433 |
case 0: /* sequence of numbers in ascending order */ |
|
1125 |
✓✓ | 3350 |
for (sb = 0; sb < coded_subbands; sb++) |
1126 |
✓✓ | 3563 |
for (i = 0; i < chan->gain_data[sb].num_points; i++) |
1127 |
646 |
gainc_loc_mode0(gb, ctx, &chan->gain_data[sb], i); |
|
1128 |
433 |
break; |
|
1129 |
64 |
case 1: |
|
1130 |
✓✓ | 64 |
if (ch_num) { |
1131 |
✓✓ | 365 |
for (sb = 0; sb < coded_subbands; sb++) { |
1132 |
✓✓ | 312 |
if (chan->gain_data[sb].num_points <= 0) |
1133 |
219 |
continue; |
|
1134 |
93 |
dst = &chan->gain_data[sb]; |
|
1135 |
93 |
ref = &ref_chan->gain_data[sb]; |
|
1136 |
|||
1137 |
/* 1st value is vlc-coded modulo delta to master */ |
||
1138 |
93 |
delta = get_vlc2(gb, gain_vlc_tabs[10].table, |
|
1139 |
gain_vlc_tabs[10].bits, 1); |
||
1140 |
✓✓ | 93 |
pred = ref->num_points > 0 ? ref->loc_code[0] : 0; |
1141 |
93 |
dst->loc_code[0] = (pred + delta) & 0x1F; |
|
1142 |
|||
1143 |
✓✓ | 113 |
for (i = 1; i < dst->num_points; i++) { |
1144 |
20 |
more_than_ref = i >= ref->num_points; |
|
1145 |
✗✓ | 20 |
if (dst->lev_code[i] > dst->lev_code[i - 1]) { |
1146 |
/* ascending curve */ |
||
1147 |
if (more_than_ref) { |
||
1148 |
delta = |
||
1149 |
get_vlc2(gb, gain_vlc_tabs[9].table, |
||
1150 |
gain_vlc_tabs[9].bits, 1); |
||
1151 |
dst->loc_code[i] = dst->loc_code[i - 1] + delta; |
||
1152 |
} else { |
||
1153 |
if (get_bits1(gb)) |
||
1154 |
gainc_loc_mode0(gb, ctx, dst, i); // direct coding |
||
1155 |
else |
||
1156 |
dst->loc_code[i] = ref->loc_code[i]; // clone master |
||
1157 |
} |
||
1158 |
} else { /* descending curve */ |
||
1159 |
20 |
tab = more_than_ref ? &gain_vlc_tabs[7] |
|
1160 |
✓✓ | 20 |
: &gain_vlc_tabs[10]; |
1161 |
20 |
delta = get_vlc2(gb, tab->table, tab->bits, 1); |
|
1162 |
✓✓ | 20 |
if (more_than_ref) |
1163 |
13 |
dst->loc_code[i] = dst->loc_code[i - 1] + delta; |
|
1164 |
else |
||
1165 |
7 |
dst->loc_code[i] = (ref->loc_code[i] + delta) & 0x1F; |
|
1166 |
} |
||
1167 |
} |
||
1168 |
} |
||
1169 |
} else /* VLC delta to previous */ |
||
1170 |
✓✓ | 78 |
for (sb = 0; sb < coded_subbands; sb++) |
1171 |
67 |
gainc_loc_mode1(gb, ctx, &chan->gain_data[sb]); |
|
1172 |
64 |
break; |
|
1173 |
57 |
case 2: |
|
1174 |
✓✓ | 57 |
if (ch_num) { |
1175 |
✓✓ | 150 |
for (sb = 0; sb < coded_subbands; sb++) { |
1176 |
✓✓ | 134 |
if (chan->gain_data[sb].num_points <= 0) |
1177 |
74 |
continue; |
|
1178 |
60 |
dst = &chan->gain_data[sb]; |
|
1179 |
60 |
ref = &ref_chan->gain_data[sb]; |
|
1180 |
✓✓✓✓ |
60 |
if (dst->num_points > ref->num_points || get_bits1(gb)) |
1181 |
44 |
gainc_loc_mode1(gb, ctx, dst); |
|
1182 |
else /* clone master for the whole subband */ |
||
1183 |
✓✓ | 38 |
for (i = 0; i < chan->gain_data[sb].num_points; i++) |
1184 |
22 |
dst->loc_code[i] = ref->loc_code[i]; |
|
1185 |
} |
||
1186 |
} else { |
||
1187 |
/* data for the first subband is coded directly */ |
||
1188 |
✓✓ | 49 |
for (i = 0; i < chan->gain_data[0].num_points; i++) |
1189 |
8 |
gainc_loc_mode0(gb, ctx, &chan->gain_data[0], i); |
|
1190 |
|||
1191 |
✓✓ | 315 |
for (sb = 1; sb < coded_subbands; sb++) { |
1192 |
✓✓ | 274 |
if (chan->gain_data[sb].num_points <= 0) |
1193 |
177 |
continue; |
|
1194 |
97 |
dst = &chan->gain_data[sb]; |
|
1195 |
|||
1196 |
/* 1st value is vlc-coded modulo delta to the corresponding |
||
1197 |
* value of the previous subband if any or zero */ |
||
1198 |
97 |
delta = get_vlc2(gb, gain_vlc_tabs[6].table, |
|
1199 |
gain_vlc_tabs[6].bits, 1); |
||
1200 |
194 |
pred = dst[-1].num_points > 0 |
|
1201 |
✓✓ | 97 |
? dst[-1].loc_code[0] : 0; |
1202 |
97 |
dst->loc_code[0] = (pred + delta) & 0x1F; |
|
1203 |
|||
1204 |
✓✓ | 123 |
for (i = 1; i < dst->num_points; i++) { |
1205 |
26 |
more_than_ref = i >= dst[-1].num_points; |
|
1206 |
/* Select VLC table according to curve direction and |
||
1207 |
* presence of prediction. */ |
||
1208 |
✓✓ | 26 |
tab = &gain_vlc_tabs[(dst->lev_code[i] > dst->lev_code[i - 1]) * |
1209 |
26 |
2 + more_than_ref + 6]; |
|
1210 |
26 |
delta = get_vlc2(gb, tab->table, tab->bits, 1); |
|
1211 |
✓✓ | 26 |
if (more_than_ref) |
1212 |
23 |
dst->loc_code[i] = dst->loc_code[i - 1] + delta; |
|
1213 |
else |
||
1214 |
3 |
dst->loc_code[i] = (dst[-1].loc_code[i] + delta) & 0x1F; |
|
1215 |
} |
||
1216 |
} |
||
1217 |
} |
||
1218 |
57 |
break; |
|
1219 |
28 |
case 3: |
|
1220 |
✓✓ | 28 |
if (ch_num) { /* clone master or direct or direct coding */ |
1221 |
✓✓ | 84 |
for (sb = 0; sb < coded_subbands; sb++) |
1222 |
✓✓ | 102 |
for (i = 0; i < chan->gain_data[sb].num_points; i++) { |
1223 |
✓✓ | 33 |
if (i >= ref_chan->gain_data[sb].num_points) |
1224 |
10 |
gainc_loc_mode0(gb, ctx, &chan->gain_data[sb], i); |
|
1225 |
else |
||
1226 |
23 |
chan->gain_data[sb].loc_code[i] = |
|
1227 |
23 |
ref_chan->gain_data[sb].loc_code[i]; |
|
1228 |
} |
||
1229 |
} else { /* shorter delta to min */ |
||
1230 |
13 |
delta_bits = get_bits(gb, 2) + 1; |
|
1231 |
13 |
min_val = get_bits(gb, 5); |
|
1232 |
|||
1233 |
✓✓ | 119 |
for (sb = 0; sb < coded_subbands; sb++) |
1234 |
✓✓ | 173 |
for (i = 0; i < chan->gain_data[sb].num_points; i++) |
1235 |
67 |
chan->gain_data[sb].loc_code[i] = min_val + i + |
|
1236 |
67 |
get_bits(gb, delta_bits); |
|
1237 |
} |
||
1238 |
28 |
break; |
|
1239 |
} |
||
1240 |
|||
1241 |
/* Validate decoded information */ |
||
1242 |
✓✓ | 4502 |
for (sb = 0; sb < coded_subbands; sb++) { |
1243 |
3920 |
dst = &chan->gain_data[sb]; |
|
1244 |
✓✓ | 5046 |
for (i = 0; i < chan->gain_data[sb].num_points; i++) { |
1245 |
✓✗✓✗ ✓✓ |
1126 |
if (dst->loc_code[i] < 0 || dst->loc_code[i] > 31 || |
1246 |
✗✓ | 151 |
(i && dst->loc_code[i] <= dst->loc_code[i - 1])) { |
1247 |
av_log(avctx, AV_LOG_ERROR, |
||
1248 |
"Invalid gain location: ch=%d, sb=%d, pos=%d, val=%d\n", |
||
1249 |
ch_num, sb, i, dst->loc_code[i]); |
||
1250 |
return AVERROR_INVALIDDATA; |
||
1251 |
} |
||
1252 |
} |
||
1253 |
} |
||
1254 |
|||
1255 |
582 |
return 0; |
|
1256 |
} |
||
1257 |
|||
1258 |
/** |
||
1259 |
* Decode gain control data for all channels. |
||
1260 |
* |
||
1261 |
* @param[in] gb the GetBit context |
||
1262 |
* @param[in,out] ctx ptr to the channel unit context |
||
1263 |
* @param[in] num_channels number of channels to process |
||
1264 |
* @param[in] avctx ptr to the AVCodecContext |
||
1265 |
* @return result code: 0 = OK, otherwise - error code |
||
1266 |
*/ |
||
1267 |
813 |
static int decode_gainc_data(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
1268 |
int num_channels, AVCodecContext *avctx) |
||
1269 |
{ |
||
1270 |
int ch_num, coded_subbands, sb, ret; |
||
1271 |
|||
1272 |
✓✓ | 2439 |
for (ch_num = 0; ch_num < num_channels; ch_num++) { |
1273 |
1626 |
memset(ctx->channels[ch_num].gain_data, 0, |
|
1274 |
sizeof(*ctx->channels[ch_num].gain_data) * ATRAC3P_SUBBANDS); |
||
1275 |
|||
1276 |
✓✓ | 1626 |
if (get_bits1(gb)) { /* gain control data present? */ |
1277 |
582 |
coded_subbands = get_bits(gb, 4) + 1; |
|
1278 |
✓✓ | 582 |
if (get_bits1(gb)) /* is high band gain data replication on? */ |
1279 |
6 |
ctx->channels[ch_num].num_gain_subbands = get_bits(gb, 4) + 1; |
|
1280 |
else |
||
1281 |
576 |
ctx->channels[ch_num].num_gain_subbands = coded_subbands; |
|
1282 |
|||
1283 |
✓✗✓✗ |
1164 |
if ((ret = decode_gainc_npoints(gb, ctx, ch_num, coded_subbands)) < 0 || |
1284 |
✗✓ | 1164 |
(ret = decode_gainc_levels(gb, ctx, ch_num, coded_subbands)) < 0 || |
1285 |
582 |
(ret = decode_gainc_loc_codes(gb, ctx, ch_num, coded_subbands, avctx)) < 0) |
|
1286 |
return ret; |
||
1287 |
|||
1288 |
✓✗ | 582 |
if (coded_subbands > 0) { /* propagate gain data if requested */ |
1289 |
✓✓ | 588 |
for (sb = coded_subbands; sb < ctx->channels[ch_num].num_gain_subbands; sb++) |
1290 |
6 |
ctx->channels[ch_num].gain_data[sb] = |
|
1291 |
6 |
ctx->channels[ch_num].gain_data[sb - 1]; |
|
1292 |
} |
||
1293 |
} else { |
||
1294 |
1044 |
ctx->channels[ch_num].num_gain_subbands = 0; |
|
1295 |
} |
||
1296 |
} |
||
1297 |
|||
1298 |
813 |
return 0; |
|
1299 |
} |
||
1300 |
|||
1301 |
/** |
||
1302 |
* Decode envelope for all tones of a channel. |
||
1303 |
* |
||
1304 |
* @param[in] gb the GetBit context |
||
1305 |
* @param[in,out] ctx ptr to the channel unit context |
||
1306 |
* @param[in] ch_num channel to process |
||
1307 |
* @param[in] band_has_tones ptr to an array of per-band-flags: |
||
1308 |
* 1 - tone data present |
||
1309 |
*/ |
||
1310 |
static void decode_tones_envelope(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
||
1311 |
int ch_num, int band_has_tones[]) |
||
1312 |
{ |
||
1313 |
int sb; |
||
1314 |
Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info; |
||
1315 |
Atrac3pWavesData *ref = ctx->channels[0].tones_info; |
||
1316 |
|||
1317 |
if (!ch_num || !get_bits1(gb)) { /* mode 0: fixed-length coding */ |
||
1318 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { |
||
1319 |
if (!band_has_tones[sb]) |
||
1320 |
continue; |
||
1321 |
dst[sb].pend_env.has_start_point = get_bits1(gb); |
||
1322 |
dst[sb].pend_env.start_pos = dst[sb].pend_env.has_start_point |
||
1323 |
? get_bits(gb, 5) : -1; |
||
1324 |
dst[sb].pend_env.has_stop_point = get_bits1(gb); |
||
1325 |
dst[sb].pend_env.stop_pos = dst[sb].pend_env.has_stop_point |
||
1326 |
? get_bits(gb, 5) : 32; |
||
1327 |
} |
||
1328 |
} else { /* mode 1(slave only): copy master */ |
||
1329 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { |
||
1330 |
if (!band_has_tones[sb]) |
||
1331 |
continue; |
||
1332 |
dst[sb].pend_env.has_start_point = ref[sb].pend_env.has_start_point; |
||
1333 |
dst[sb].pend_env.has_stop_point = ref[sb].pend_env.has_stop_point; |
||
1334 |
dst[sb].pend_env.start_pos = ref[sb].pend_env.start_pos; |
||
1335 |
dst[sb].pend_env.stop_pos = ref[sb].pend_env.stop_pos; |
||
1336 |
} |
||
1337 |
} |
||
1338 |
} |
||
1339 |
|||
1340 |
/** |
||
1341 |
* Decode number of tones for each subband of a channel. |
||
1342 |
* |
||
1343 |
* @param[in] gb the GetBit context |
||
1344 |
* @param[in,out] ctx ptr to the channel unit context |
||
1345 |
* @param[in] ch_num channel to process |
||
1346 |
* @param[in] band_has_tones ptr to an array of per-band-flags: |
||
1347 |
* 1 - tone data present |
||
1348 |
* @param[in] avctx ptr to the AVCodecContext |
||
1349 |
* @return result code: 0 = OK, otherwise - error code |
||
1350 |
*/ |
||
1351 |
static int decode_band_numwavs(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
||
1352 |
int ch_num, int band_has_tones[], |
||
1353 |
AVCodecContext *avctx) |
||
1354 |
{ |
||
1355 |
int mode, sb, delta; |
||
1356 |
Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info; |
||
1357 |
Atrac3pWavesData *ref = ctx->channels[0].tones_info; |
||
1358 |
|||
1359 |
mode = get_bits(gb, ch_num + 1); |
||
1360 |
switch (mode) { |
||
1361 |
case 0: /** fixed-length coding */ |
||
1362 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) |
||
1363 |
if (band_has_tones[sb]) |
||
1364 |
dst[sb].num_wavs = get_bits(gb, 4); |
||
1365 |
break; |
||
1366 |
case 1: /** variable-length coding */ |
||
1367 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) |
||
1368 |
if (band_has_tones[sb]) |
||
1369 |
dst[sb].num_wavs = |
||
1370 |
get_vlc2(gb, tone_vlc_tabs[1].table, |
||
1371 |
tone_vlc_tabs[1].bits, 1); |
||
1372 |
break; |
||
1373 |
case 2: /** VLC modulo delta to master (slave only) */ |
||
1374 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) |
||
1375 |
if (band_has_tones[sb]) { |
||
1376 |
delta = get_vlc2(gb, tone_vlc_tabs[2].table, |
||
1377 |
tone_vlc_tabs[2].bits, 1); |
||
1378 |
delta = sign_extend(delta, 3); |
||
1379 |
dst[sb].num_wavs = (ref[sb].num_wavs + delta) & 0xF; |
||
1380 |
} |
||
1381 |
break; |
||
1382 |
case 3: /** copy master (slave only) */ |
||
1383 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) |
||
1384 |
if (band_has_tones[sb]) |
||
1385 |
dst[sb].num_wavs = ref[sb].num_wavs; |
||
1386 |
break; |
||
1387 |
} |
||
1388 |
|||
1389 |
/** initialize start tone index for each subband */ |
||
1390 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) |
||
1391 |
if (band_has_tones[sb]) { |
||
1392 |
if (ctx->waves_info->tones_index + dst[sb].num_wavs > 48) { |
||
1393 |
av_log(avctx, AV_LOG_ERROR, |
||
1394 |
"Too many tones: %d (max. 48), frame: %d!\n", |
||
1395 |
ctx->waves_info->tones_index + dst[sb].num_wavs, |
||
1396 |
avctx->frame_number); |
||
1397 |
return AVERROR_INVALIDDATA; |
||
1398 |
} |
||
1399 |
dst[sb].start_index = ctx->waves_info->tones_index; |
||
1400 |
ctx->waves_info->tones_index += dst[sb].num_wavs; |
||
1401 |
} |
||
1402 |
|||
1403 |
return 0; |
||
1404 |
} |
||
1405 |
|||
1406 |
/** |
||
1407 |
* Decode frequency information for each subband of a channel. |
||
1408 |
* |
||
1409 |
* @param[in] gb the GetBit context |
||
1410 |
* @param[in,out] ctx ptr to the channel unit context |
||
1411 |
* @param[in] ch_num channel to process |
||
1412 |
* @param[in] band_has_tones ptr to an array of per-band-flags: |
||
1413 |
* 1 - tone data present |
||
1414 |
*/ |
||
1415 |
static void decode_tones_frequency(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
||
1416 |
int ch_num, int band_has_tones[]) |
||
1417 |
{ |
||
1418 |
int sb, i, direction, nbits, pred, delta; |
||
1419 |
Atrac3pWaveParam *iwav, *owav; |
||
1420 |
Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info; |
||
1421 |
Atrac3pWavesData *ref = ctx->channels[0].tones_info; |
||
1422 |
|||
1423 |
if (!ch_num || !get_bits1(gb)) { /* mode 0: fixed-length coding */ |
||
1424 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { |
||
1425 |
if (!band_has_tones[sb] || !dst[sb].num_wavs) |
||
1426 |
continue; |
||
1427 |
iwav = &ctx->waves_info->waves[dst[sb].start_index]; |
||
1428 |
direction = (dst[sb].num_wavs > 1) ? get_bits1(gb) : 0; |
||
1429 |
if (direction) { /** packed numbers in descending order */ |
||
1430 |
if (dst[sb].num_wavs) |
||
1431 |
iwav[dst[sb].num_wavs - 1].freq_index = get_bits(gb, 10); |
||
1432 |
for (i = dst[sb].num_wavs - 2; i >= 0 ; i--) { |
||
1433 |
nbits = av_log2(iwav[i+1].freq_index) + 1; |
||
1434 |
iwav[i].freq_index = get_bits(gb, nbits); |
||
1435 |
} |
||
1436 |
} else { /** packed numbers in ascending order */ |
||
1437 |
for (i = 0; i < dst[sb].num_wavs; i++) { |
||
1438 |
if (!i || iwav[i - 1].freq_index < 512) |
||
1439 |
iwav[i].freq_index = get_bits(gb, 10); |
||
1440 |
else { |
||
1441 |
nbits = av_log2(1023 - iwav[i - 1].freq_index) + 1; |
||
1442 |
iwav[i].freq_index = get_bits(gb, nbits) + |
||
1443 |
1024 - (1 << nbits); |
||
1444 |
} |
||
1445 |
} |
||
1446 |
} |
||
1447 |
} |
||
1448 |
} else { /* mode 1: VLC modulo delta to master (slave only) */ |
||
1449 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { |
||
1450 |
if (!band_has_tones[sb] || !dst[sb].num_wavs) |
||
1451 |
continue; |
||
1452 |
iwav = &ctx->waves_info->waves[ref[sb].start_index]; |
||
1453 |
owav = &ctx->waves_info->waves[dst[sb].start_index]; |
||
1454 |
for (i = 0; i < dst[sb].num_wavs; i++) { |
||
1455 |
delta = get_vlc2(gb, tone_vlc_tabs[6].table, |
||
1456 |
tone_vlc_tabs[6].bits, 1); |
||
1457 |
delta = sign_extend(delta, 8); |
||
1458 |
pred = (i < ref[sb].num_wavs) ? iwav[i].freq_index : |
||
1459 |
(ref[sb].num_wavs ? iwav[ref[sb].num_wavs - 1].freq_index : 0); |
||
1460 |
owav[i].freq_index = (pred + delta) & 0x3FF; |
||
1461 |
} |
||
1462 |
} |
||
1463 |
} |
||
1464 |
} |
||
1465 |
|||
1466 |
/** |
||
1467 |
* Decode amplitude information for each subband of a channel. |
||
1468 |
* |
||
1469 |
* @param[in] gb the GetBit context |
||
1470 |
* @param[in,out] ctx ptr to the channel unit context |
||
1471 |
* @param[in] ch_num channel to process |
||
1472 |
* @param[in] band_has_tones ptr to an array of per-band-flags: |
||
1473 |
* 1 - tone data present |
||
1474 |
*/ |
||
1475 |
static void decode_tones_amplitude(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
||
1476 |
int ch_num, int band_has_tones[]) |
||
1477 |
{ |
||
1478 |
int mode, sb, j, i, diff, maxdiff, fi, delta, pred; |
||
1479 |
Atrac3pWaveParam *wsrc, *wref; |
||
1480 |
int refwaves[48] = { 0 }; |
||
1481 |
Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info; |
||
1482 |
Atrac3pWavesData *ref = ctx->channels[0].tones_info; |
||
1483 |
|||
1484 |
if (ch_num) { |
||
1485 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { |
||
1486 |
if (!band_has_tones[sb] || !dst[sb].num_wavs) |
||
1487 |
continue; |
||
1488 |
wsrc = &ctx->waves_info->waves[dst[sb].start_index]; |
||
1489 |
wref = &ctx->waves_info->waves[ref[sb].start_index]; |
||
1490 |
for (j = 0; j < dst[sb].num_wavs; j++) { |
||
1491 |
for (i = 0, fi = 0, maxdiff = 1024; i < ref[sb].num_wavs; i++) { |
||
1492 |
diff = FFABS(wsrc[j].freq_index - wref[i].freq_index); |
||
1493 |
if (diff < maxdiff) { |
||
1494 |
maxdiff = diff; |
||
1495 |
fi = i; |
||
1496 |
} |
||
1497 |
} |
||
1498 |
|||
1499 |
if (maxdiff < 8) |
||
1500 |
refwaves[dst[sb].start_index + j] = fi + ref[sb].start_index; |
||
1501 |
else if (j < ref[sb].num_wavs) |
||
1502 |
refwaves[dst[sb].start_index + j] = j + ref[sb].start_index; |
||
1503 |
else |
||
1504 |
refwaves[dst[sb].start_index + j] = -1; |
||
1505 |
} |
||
1506 |
} |
||
1507 |
} |
||
1508 |
|||
1509 |
mode = get_bits(gb, ch_num + 1); |
||
1510 |
|||
1511 |
switch (mode) { |
||
1512 |
case 0: /** fixed-length coding */ |
||
1513 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { |
||
1514 |
if (!band_has_tones[sb] || !dst[sb].num_wavs) |
||
1515 |
continue; |
||
1516 |
if (ctx->waves_info->amplitude_mode) |
||
1517 |
for (i = 0; i < dst[sb].num_wavs; i++) |
||
1518 |
ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = get_bits(gb, 6); |
||
1519 |
else |
||
1520 |
ctx->waves_info->waves[dst[sb].start_index].amp_sf = get_bits(gb, 6); |
||
1521 |
} |
||
1522 |
break; |
||
1523 |
case 1: /** min + VLC delta */ |
||
1524 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { |
||
1525 |
if (!band_has_tones[sb] || !dst[sb].num_wavs) |
||
1526 |
continue; |
||
1527 |
if (ctx->waves_info->amplitude_mode) |
||
1528 |
for (i = 0; i < dst[sb].num_wavs; i++) |
||
1529 |
ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = |
||
1530 |
get_vlc2(gb, tone_vlc_tabs[3].table, |
||
1531 |
tone_vlc_tabs[3].bits, 1) + 20; |
||
1532 |
else |
||
1533 |
ctx->waves_info->waves[dst[sb].start_index].amp_sf = |
||
1534 |
get_vlc2(gb, tone_vlc_tabs[4].table, |
||
1535 |
tone_vlc_tabs[4].bits, 1) + 24; |
||
1536 |
} |
||
1537 |
break; |
||
1538 |
case 2: /** VLC modulo delta to master (slave only) */ |
||
1539 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { |
||
1540 |
if (!band_has_tones[sb] || !dst[sb].num_wavs) |
||
1541 |
continue; |
||
1542 |
for (i = 0; i < dst[sb].num_wavs; i++) { |
||
1543 |
delta = get_vlc2(gb, tone_vlc_tabs[5].table, |
||
1544 |
tone_vlc_tabs[5].bits, 1); |
||
1545 |
delta = sign_extend(delta, 5); |
||
1546 |
pred = refwaves[dst[sb].start_index + i] >= 0 ? |
||
1547 |
ctx->waves_info->waves[refwaves[dst[sb].start_index + i]].amp_sf : 34; |
||
1548 |
ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = (pred + delta) & 0x3F; |
||
1549 |
} |
||
1550 |
} |
||
1551 |
break; |
||
1552 |
case 3: /** clone master (slave only) */ |
||
1553 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { |
||
1554 |
if (!band_has_tones[sb]) |
||
1555 |
continue; |
||
1556 |
for (i = 0; i < dst[sb].num_wavs; i++) |
||
1557 |
ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = |
||
1558 |
refwaves[dst[sb].start_index + i] >= 0 |
||
1559 |
? ctx->waves_info->waves[refwaves[dst[sb].start_index + i]].amp_sf |
||
1560 |
: 32; |
||
1561 |
} |
||
1562 |
break; |
||
1563 |
} |
||
1564 |
} |
||
1565 |
|||
1566 |
/** |
||
1567 |
* Decode phase information for each subband of a channel. |
||
1568 |
* |
||
1569 |
* @param[in] gb the GetBit context |
||
1570 |
* @param[in,out] ctx ptr to the channel unit context |
||
1571 |
* @param[in] ch_num channel to process |
||
1572 |
* @param[in] band_has_tones ptr to an array of per-band-flags: |
||
1573 |
* 1 - tone data present |
||
1574 |
*/ |
||
1575 |
static void decode_tones_phase(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
||
1576 |
int ch_num, int band_has_tones[]) |
||
1577 |
{ |
||
1578 |
int sb, i; |
||
1579 |
Atrac3pWaveParam *wparam; |
||
1580 |
Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info; |
||
1581 |
|||
1582 |
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { |
||
1583 |
if (!band_has_tones[sb]) |
||
1584 |
continue; |
||
1585 |
wparam = &ctx->waves_info->waves[dst[sb].start_index]; |
||
1586 |
for (i = 0; i < dst[sb].num_wavs; i++) |
||
1587 |
wparam[i].phase_index = get_bits(gb, 5); |
||
1588 |
} |
||
1589 |
} |
||
1590 |
|||
1591 |
/** |
||
1592 |
* Decode tones info for all channels. |
||
1593 |
* |
||
1594 |
* @param[in] gb the GetBit context |
||
1595 |
* @param[in,out] ctx ptr to the channel unit context |
||
1596 |
* @param[in] num_channels number of channels to process |
||
1597 |
* @param[in] avctx ptr to the AVCodecContext |
||
1598 |
* @return result code: 0 = OK, otherwise - error code |
||
1599 |
*/ |
||
1600 |
813 |
static int decode_tones_info(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
1601 |
int num_channels, AVCodecContext *avctx) |
||
1602 |
{ |
||
1603 |
int ch_num, i, ret; |
||
1604 |
int band_has_tones[16]; |
||
1605 |
|||
1606 |
✓✓ | 2439 |
for (ch_num = 0; ch_num < num_channels; ch_num++) |
1607 |
1626 |
memset(ctx->channels[ch_num].tones_info, 0, |
|
1608 |
sizeof(*ctx->channels[ch_num].tones_info) * ATRAC3P_SUBBANDS); |
||
1609 |
|||
1610 |
813 |
ctx->waves_info->tones_present = get_bits1(gb); |
|
1611 |
✓✗ | 813 |
if (!ctx->waves_info->tones_present) |
1612 |
813 |
return 0; |
|
1613 |
|||
1614 |
memset(ctx->waves_info->waves, 0, sizeof(ctx->waves_info->waves)); |
||
1615 |
|||
1616 |
ctx->waves_info->amplitude_mode = get_bits1(gb); |
||
1617 |
if (!ctx->waves_info->amplitude_mode) { |
||
1618 |
avpriv_report_missing_feature(avctx, "GHA amplitude mode 0"); |
||
1619 |
return AVERROR_PATCHWELCOME; |
||
1620 |
} |
||
1621 |
|||
1622 |
ctx->waves_info->num_tone_bands = |
||
1623 |
get_vlc2(gb, tone_vlc_tabs[0].table, |
||
1624 |
tone_vlc_tabs[0].bits, 1) + 1; |
||
1625 |
|||
1626 |
if (num_channels == 2) { |
||
1627 |
get_subband_flags(gb, ctx->waves_info->tone_sharing, ctx->waves_info->num_tone_bands); |
||
1628 |
get_subband_flags(gb, ctx->waves_info->tone_master, ctx->waves_info->num_tone_bands); |
||
1629 |
get_subband_flags(gb, ctx->waves_info->invert_phase, ctx->waves_info->num_tone_bands); |
||
1630 |
} |
||
1631 |
|||
1632 |
ctx->waves_info->tones_index = 0; |
||
1633 |
|||
1634 |
for (ch_num = 0; ch_num < num_channels; ch_num++) { |
||
1635 |
for (i = 0; i < ctx->waves_info->num_tone_bands; i++) |
||
1636 |
band_has_tones[i] = !ch_num ? 1 : !ctx->waves_info->tone_sharing[i]; |
||
1637 |
|||
1638 |
decode_tones_envelope(gb, ctx, ch_num, band_has_tones); |
||
1639 |
if ((ret = decode_band_numwavs(gb, ctx, ch_num, band_has_tones, |
||
1640 |
avctx)) < 0) |
||
1641 |
return ret; |
||
1642 |
|||
1643 |
decode_tones_frequency(gb, ctx, ch_num, band_has_tones); |
||
1644 |
decode_tones_amplitude(gb, ctx, ch_num, band_has_tones); |
||
1645 |
decode_tones_phase(gb, ctx, ch_num, band_has_tones); |
||
1646 |
} |
||
1647 |
|||
1648 |
if (num_channels == 2) { |
||
1649 |
for (i = 0; i < ctx->waves_info->num_tone_bands; i++) { |
||
1650 |
if (ctx->waves_info->tone_sharing[i]) |
||
1651 |
ctx->channels[1].tones_info[i] = ctx->channels[0].tones_info[i]; |
||
1652 |
|||
1653 |
if (ctx->waves_info->tone_master[i]) |
||
1654 |
FFSWAP(Atrac3pWavesData, ctx->channels[0].tones_info[i], |
||
1655 |
ctx->channels[1].tones_info[i]); |
||
1656 |
} |
||
1657 |
} |
||
1658 |
|||
1659 |
return 0; |
||
1660 |
} |
||
1661 |
|||
1662 |
813 |
int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, |
|
1663 |
int num_channels, AVCodecContext *avctx) |
||
1664 |
{ |
||
1665 |
int ret; |
||
1666 |
|||
1667 |
/* parse sound header */ |
||
1668 |
813 |
ctx->num_quant_units = get_bits(gb, 5) + 1; |
|
1669 |
✓✓✗✓ |
813 |
if (ctx->num_quant_units > 28 && ctx->num_quant_units < 32) { |
1670 |
av_log(avctx, AV_LOG_ERROR, |
||
1671 |
"Invalid number of quantization units: %d!\n", |
||
1672 |
ctx->num_quant_units); |
||
1673 |
return AVERROR_INVALIDDATA; |
||
1674 |
} |
||
1675 |
|||
1676 |
813 |
ctx->mute_flag = get_bits1(gb); |
|
1677 |
|||
1678 |
/* decode various sound parameters */ |
||
1679 |
✗✓ | 813 |
if ((ret = decode_quant_wordlen(gb, ctx, num_channels, avctx)) < 0) |
1680 |
return ret; |
||
1681 |
|||
1682 |
813 |
ctx->num_subbands = atrac3p_qu_to_subband[ctx->num_quant_units - 1] + 1; |
|
1683 |
1626 |
ctx->num_coded_subbands = ctx->used_quant_units |
|
1684 |
776 |
? atrac3p_qu_to_subband[ctx->used_quant_units - 1] + 1 |
|
1685 |
✓✓ | 813 |
: 0; |
1686 |
|||
1687 |
✗✓ | 813 |
if ((ret = decode_scale_factors(gb, ctx, num_channels, avctx)) < 0) |
1688 |
return ret; |
||
1689 |
|||
1690 |
✗✓ | 813 |
if ((ret = decode_code_table_indexes(gb, ctx, num_channels, avctx)) < 0) |
1691 |
return ret; |
||
1692 |
|||
1693 |
813 |
decode_spectrum(gb, ctx, num_channels, avctx); |
|
1694 |
|||
1695 |
✓✗ | 813 |
if (num_channels == 2) { |
1696 |
813 |
get_subband_flags(gb, ctx->swap_channels, ctx->num_coded_subbands); |
|
1697 |
813 |
get_subband_flags(gb, ctx->negate_coeffs, ctx->num_coded_subbands); |
|
1698 |
} |
||
1699 |
|||
1700 |
813 |
decode_window_shape(gb, ctx, num_channels); |
|
1701 |
|||
1702 |
✗✓ | 813 |
if ((ret = decode_gainc_data(gb, ctx, num_channels, avctx)) < 0) |
1703 |
return ret; |
||
1704 |
|||
1705 |
✗✓ | 813 |
if ((ret = decode_tones_info(gb, ctx, num_channels, avctx)) < 0) |
1706 |
return ret; |
||
1707 |
|||
1708 |
/* decode global noise info */ |
||
1709 |
813 |
ctx->noise_present = get_bits1(gb); |
|
1710 |
✗✓ | 813 |
if (ctx->noise_present) { |
1711 |
ctx->noise_level_index = get_bits(gb, 4); |
||
1712 |
ctx->noise_table_index = get_bits(gb, 4); |
||
1713 |
} |
||
1714 |
|||
1715 |
813 |
return 0; |
|
1716 |
} |
Generated by: GCOVR (Version 4.2) |