Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * MPEG-4 ALS decoder | ||
3 | * Copyright (c) 2009 Thilo Borgmann <thilo.borgmann _at_ mail.de> | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | /** | ||
23 | * @file | ||
24 | * MPEG-4 ALS decoder | ||
25 | * @author Thilo Borgmann <thilo.borgmann _at_ mail.de> | ||
26 | */ | ||
27 | |||
28 | #include <inttypes.h> | ||
29 | |||
30 | #include "avcodec.h" | ||
31 | #include "get_bits.h" | ||
32 | #include "unary.h" | ||
33 | #include "mpeg4audio.h" | ||
34 | #include "bgmc.h" | ||
35 | #include "bswapdsp.h" | ||
36 | #include "codec_internal.h" | ||
37 | #include "decode.h" | ||
38 | #include "internal.h" | ||
39 | #include "mlz.h" | ||
40 | #include "libavutil/mem.h" | ||
41 | #include "libavutil/opt.h" | ||
42 | #include "libavutil/samplefmt.h" | ||
43 | #include "libavutil/crc.h" | ||
44 | #include "libavutil/softfloat_ieee754.h" | ||
45 | #include "libavutil/intreadwrite.h" | ||
46 | |||
47 | #include <stdint.h> | ||
48 | |||
49 | /** Rice parameters and corresponding index offsets for decoding the | ||
50 | * indices of scaled PARCOR values. The table chosen is set globally | ||
51 | * by the encoder and stored in ALSSpecificConfig. | ||
52 | */ | ||
53 | static const int8_t parcor_rice_table[3][20][2] = { | ||
54 | { {-52, 4}, {-29, 5}, {-31, 4}, { 19, 4}, {-16, 4}, | ||
55 | { 12, 3}, { -7, 3}, { 9, 3}, { -5, 3}, { 6, 3}, | ||
56 | { -4, 3}, { 3, 3}, { -3, 2}, { 3, 2}, { -2, 2}, | ||
57 | { 3, 2}, { -1, 2}, { 2, 2}, { -1, 2}, { 2, 2} }, | ||
58 | { {-58, 3}, {-42, 4}, {-46, 4}, { 37, 5}, {-36, 4}, | ||
59 | { 29, 4}, {-29, 4}, { 25, 4}, {-23, 4}, { 20, 4}, | ||
60 | {-17, 4}, { 16, 4}, {-12, 4}, { 12, 3}, {-10, 4}, | ||
61 | { 7, 3}, { -4, 4}, { 3, 3}, { -1, 3}, { 1, 3} }, | ||
62 | { {-59, 3}, {-45, 5}, {-50, 4}, { 38, 4}, {-39, 4}, | ||
63 | { 32, 4}, {-30, 4}, { 25, 3}, {-23, 3}, { 20, 3}, | ||
64 | {-20, 3}, { 16, 3}, {-13, 3}, { 10, 3}, { -7, 3}, | ||
65 | { 3, 3}, { 0, 3}, { -1, 3}, { 2, 3}, { -1, 2} } | ||
66 | }; | ||
67 | |||
68 | |||
69 | /** Scaled PARCOR values used for the first two PARCOR coefficients. | ||
70 | * To be indexed by the Rice coded indices. | ||
71 | * Generated by: parcor_scaled_values[i] = 32 + ((i * (i+1)) << 7) - (1 << 20) | ||
72 | * Actual values are divided by 32 in order to be stored in 16 bits. | ||
73 | */ | ||
74 | static const int16_t parcor_scaled_values[] = { | ||
75 | -1048544 / 32, -1048288 / 32, -1047776 / 32, -1047008 / 32, | ||
76 | -1045984 / 32, -1044704 / 32, -1043168 / 32, -1041376 / 32, | ||
77 | -1039328 / 32, -1037024 / 32, -1034464 / 32, -1031648 / 32, | ||
78 | -1028576 / 32, -1025248 / 32, -1021664 / 32, -1017824 / 32, | ||
79 | -1013728 / 32, -1009376 / 32, -1004768 / 32, -999904 / 32, | ||
80 | -994784 / 32, -989408 / 32, -983776 / 32, -977888 / 32, | ||
81 | -971744 / 32, -965344 / 32, -958688 / 32, -951776 / 32, | ||
82 | -944608 / 32, -937184 / 32, -929504 / 32, -921568 / 32, | ||
83 | -913376 / 32, -904928 / 32, -896224 / 32, -887264 / 32, | ||
84 | -878048 / 32, -868576 / 32, -858848 / 32, -848864 / 32, | ||
85 | -838624 / 32, -828128 / 32, -817376 / 32, -806368 / 32, | ||
86 | -795104 / 32, -783584 / 32, -771808 / 32, -759776 / 32, | ||
87 | -747488 / 32, -734944 / 32, -722144 / 32, -709088 / 32, | ||
88 | -695776 / 32, -682208 / 32, -668384 / 32, -654304 / 32, | ||
89 | -639968 / 32, -625376 / 32, -610528 / 32, -595424 / 32, | ||
90 | -580064 / 32, -564448 / 32, -548576 / 32, -532448 / 32, | ||
91 | -516064 / 32, -499424 / 32, -482528 / 32, -465376 / 32, | ||
92 | -447968 / 32, -430304 / 32, -412384 / 32, -394208 / 32, | ||
93 | -375776 / 32, -357088 / 32, -338144 / 32, -318944 / 32, | ||
94 | -299488 / 32, -279776 / 32, -259808 / 32, -239584 / 32, | ||
95 | -219104 / 32, -198368 / 32, -177376 / 32, -156128 / 32, | ||
96 | -134624 / 32, -112864 / 32, -90848 / 32, -68576 / 32, | ||
97 | -46048 / 32, -23264 / 32, -224 / 32, 23072 / 32, | ||
98 | 46624 / 32, 70432 / 32, 94496 / 32, 118816 / 32, | ||
99 | 143392 / 32, 168224 / 32, 193312 / 32, 218656 / 32, | ||
100 | 244256 / 32, 270112 / 32, 296224 / 32, 322592 / 32, | ||
101 | 349216 / 32, 376096 / 32, 403232 / 32, 430624 / 32, | ||
102 | 458272 / 32, 486176 / 32, 514336 / 32, 542752 / 32, | ||
103 | 571424 / 32, 600352 / 32, 629536 / 32, 658976 / 32, | ||
104 | 688672 / 32, 718624 / 32, 748832 / 32, 779296 / 32, | ||
105 | 810016 / 32, 840992 / 32, 872224 / 32, 903712 / 32, | ||
106 | 935456 / 32, 967456 / 32, 999712 / 32, 1032224 / 32 | ||
107 | }; | ||
108 | |||
109 | |||
110 | /** Gain values of p(0) for long-term prediction. | ||
111 | * To be indexed by the Rice coded indices. | ||
112 | */ | ||
113 | static const uint8_t ltp_gain_values [4][4] = { | ||
114 | { 0, 8, 16, 24}, | ||
115 | {32, 40, 48, 56}, | ||
116 | {64, 70, 76, 82}, | ||
117 | {88, 92, 96, 100} | ||
118 | }; | ||
119 | |||
120 | |||
121 | /** Inter-channel weighting factors for multi-channel correlation. | ||
122 | * To be indexed by the Rice coded indices. | ||
123 | */ | ||
124 | static const int16_t mcc_weightings[] = { | ||
125 | 204, 192, 179, 166, 153, 140, 128, 115, | ||
126 | 102, 89, 76, 64, 51, 38, 25, 12, | ||
127 | 0, -12, -25, -38, -51, -64, -76, -89, | ||
128 | -102, -115, -128, -140, -153, -166, -179, -192 | ||
129 | }; | ||
130 | |||
131 | |||
132 | /** Tail codes used in arithmetic coding using block Gilbert-Moore codes. | ||
133 | */ | ||
134 | static const uint8_t tail_code[16][6] = { | ||
135 | { 74, 44, 25, 13, 7, 3}, | ||
136 | { 68, 42, 24, 13, 7, 3}, | ||
137 | { 58, 39, 23, 13, 7, 3}, | ||
138 | {126, 70, 37, 19, 10, 5}, | ||
139 | {132, 70, 37, 20, 10, 5}, | ||
140 | {124, 70, 38, 20, 10, 5}, | ||
141 | {120, 69, 37, 20, 11, 5}, | ||
142 | {116, 67, 37, 20, 11, 5}, | ||
143 | {108, 66, 36, 20, 10, 5}, | ||
144 | {102, 62, 36, 20, 10, 5}, | ||
145 | { 88, 58, 34, 19, 10, 5}, | ||
146 | {162, 89, 49, 25, 13, 7}, | ||
147 | {156, 87, 49, 26, 14, 7}, | ||
148 | {150, 86, 47, 26, 14, 7}, | ||
149 | {142, 84, 47, 26, 14, 7}, | ||
150 | {131, 79, 46, 26, 14, 7} | ||
151 | }; | ||
152 | |||
153 | |||
154 | enum RA_Flag { | ||
155 | RA_FLAG_NONE, | ||
156 | RA_FLAG_FRAMES, | ||
157 | RA_FLAG_HEADER | ||
158 | }; | ||
159 | |||
160 | |||
161 | typedef struct ALSSpecificConfig { | ||
162 | uint32_t samples; ///< number of samples, 0xFFFFFFFF if unknown | ||
163 | int resolution; ///< 000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit | ||
164 | int floating; ///< 1 = IEEE 32-bit floating-point, 0 = integer | ||
165 | int msb_first; ///< 1 = original CRC calculated on big-endian system, 0 = little-endian | ||
166 | int frame_length; ///< frame length for each frame (last frame may differ) | ||
167 | int ra_distance; ///< distance between RA frames (in frames, 0...255) | ||
168 | enum RA_Flag ra_flag; ///< indicates where the size of ra units is stored | ||
169 | int adapt_order; ///< adaptive order: 1 = on, 0 = off | ||
170 | int coef_table; ///< table index of Rice code parameters | ||
171 | int long_term_prediction; ///< long term prediction (LTP): 1 = on, 0 = off | ||
172 | int max_order; ///< maximum prediction order (0..1023) | ||
173 | int block_switching; ///< number of block switching levels | ||
174 | int bgmc; ///< "Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only) | ||
175 | int sb_part; ///< sub-block partition | ||
176 | int joint_stereo; ///< joint stereo: 1 = on, 0 = off | ||
177 | int mc_coding; ///< extended inter-channel coding (multi channel coding): 1 = on, 0 = off | ||
178 | int chan_config; ///< indicates that a chan_config_info field is present | ||
179 | int chan_sort; ///< channel rearrangement: 1 = on, 0 = off | ||
180 | int rlslms; ///< use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off | ||
181 | int chan_config_info; ///< mapping of channels to loudspeaker locations. Unused until setting channel configuration is implemented. | ||
182 | int *chan_pos; ///< original channel positions | ||
183 | int crc_enabled; ///< enable Cyclic Redundancy Checksum | ||
184 | } ALSSpecificConfig; | ||
185 | |||
186 | |||
187 | typedef struct ALSChannelData { | ||
188 | int stop_flag; | ||
189 | int master_channel; | ||
190 | int time_diff_flag; | ||
191 | int time_diff_sign; | ||
192 | int time_diff_index; | ||
193 | int weighting[6]; | ||
194 | } ALSChannelData; | ||
195 | |||
196 | |||
197 | typedef struct ALSDecContext { | ||
198 | AVClass *av_class; | ||
199 | AVCodecContext *avctx; | ||
200 | ALSSpecificConfig sconf; | ||
201 | GetBitContext gb; | ||
202 | BswapDSPContext bdsp; | ||
203 | const AVCRC *crc_table; | ||
204 | uint32_t crc_org; ///< CRC value of the original input data | ||
205 | uint32_t crc; ///< CRC value calculated from decoded data | ||
206 | unsigned int cur_frame_length; ///< length of the current frame to decode | ||
207 | unsigned int frame_id; ///< the frame ID / number of the current frame | ||
208 | unsigned int js_switch; ///< if true, joint-stereo decoding is enforced | ||
209 | unsigned int cs_switch; ///< if true, channel rearrangement is done | ||
210 | unsigned int num_blocks; ///< number of blocks used in the current frame | ||
211 | unsigned int s_max; ///< maximum Rice parameter allowed in entropy coding | ||
212 | uint8_t *bgmc_lut; ///< pointer at lookup tables used for BGMC | ||
213 | int *bgmc_lut_status; ///< pointer at lookup table status flags used for BGMC | ||
214 | int ltp_lag_length; ///< number of bits used for ltp lag value | ||
215 | int *const_block; ///< contains const_block flags for all channels | ||
216 | unsigned int *shift_lsbs; ///< contains shift_lsbs flags for all channels | ||
217 | unsigned int *opt_order; ///< contains opt_order flags for all channels | ||
218 | int *store_prev_samples; ///< contains store_prev_samples flags for all channels | ||
219 | int *use_ltp; ///< contains use_ltp flags for all channels | ||
220 | int *ltp_lag; ///< contains ltp lag values for all channels | ||
221 | int **ltp_gain; ///< gain values for ltp 5-tap filter for a channel | ||
222 | int *ltp_gain_buffer; ///< contains all gain values for ltp 5-tap filter | ||
223 | int32_t **quant_cof; ///< quantized parcor coefficients for a channel | ||
224 | int32_t *quant_cof_buffer; ///< contains all quantized parcor coefficients | ||
225 | int32_t **lpc_cof; ///< coefficients of the direct form prediction filter for a channel | ||
226 | int32_t *lpc_cof_buffer; ///< contains all coefficients of the direct form prediction filter | ||
227 | int32_t *lpc_cof_reversed_buffer; ///< temporary buffer to set up a reversed versio of lpc_cof_buffer | ||
228 | ALSChannelData **chan_data; ///< channel data for multi-channel correlation | ||
229 | ALSChannelData *chan_data_buffer; ///< contains channel data for all channels | ||
230 | int *reverted_channels; ///< stores a flag for each reverted channel | ||
231 | int32_t *prev_raw_samples; ///< contains unshifted raw samples from the previous block | ||
232 | int32_t **raw_samples; ///< decoded raw samples for each channel | ||
233 | int32_t *raw_buffer; ///< contains all decoded raw samples including carryover samples | ||
234 | uint8_t *crc_buffer; ///< buffer of byte order corrected samples used for CRC check | ||
235 | MLZ* mlz; ///< masked lz decompression structure | ||
236 | SoftFloat_IEEE754 *acf; ///< contains common multiplier for all channels | ||
237 | int *last_acf_mantissa; ///< contains the last acf mantissa data of common multiplier for all channels | ||
238 | int *shift_value; ///< value by which the binary point is to be shifted for all channels | ||
239 | int *last_shift_value; ///< contains last shift value for all channels | ||
240 | int **raw_mantissa; ///< decoded mantissa bits of the difference signal | ||
241 | unsigned char *larray; ///< buffer to store the output of masked lz decompression | ||
242 | int *nbits; ///< contains the number of bits to read for masked lz decompression for all samples | ||
243 | int highest_decoded_channel; | ||
244 | int user_max_order; ///< user specified maximum prediction order | ||
245 | } ALSDecContext; | ||
246 | |||
247 | |||
248 | typedef struct ALSBlockData { | ||
249 | unsigned int block_length; ///< number of samples within the block | ||
250 | unsigned int ra_block; ///< if true, this is a random access block | ||
251 | int *const_block; ///< if true, this is a constant value block | ||
252 | int js_blocks; ///< true if this block contains a difference signal | ||
253 | unsigned int *shift_lsbs; ///< shift of values for this block | ||
254 | unsigned int *opt_order; ///< prediction order of this block | ||
255 | int *store_prev_samples;///< if true, carryover samples have to be stored | ||
256 | int *use_ltp; ///< if true, long-term prediction is used | ||
257 | int *ltp_lag; ///< lag value for long-term prediction | ||
258 | int *ltp_gain; ///< gain values for ltp 5-tap filter | ||
259 | int32_t *quant_cof; ///< quantized parcor coefficients | ||
260 | int32_t *lpc_cof; ///< coefficients of the direct form prediction | ||
261 | int32_t *raw_samples; ///< decoded raw samples / residuals for this block | ||
262 | int32_t *prev_raw_samples; ///< contains unshifted raw samples from the previous block | ||
263 | int32_t *raw_other; ///< decoded raw samples of the other channel of a channel pair | ||
264 | } ALSBlockData; | ||
265 | |||
266 | |||
267 | 14 | static av_cold void dprint_specific_config(ALSDecContext *ctx) | |
268 | { | ||
269 | #ifdef DEBUG | ||
270 | AVCodecContext *avctx = ctx->avctx; | ||
271 | ALSSpecificConfig *sconf = &ctx->sconf; | ||
272 | |||
273 | ff_dlog(avctx, "resolution = %i\n", sconf->resolution); | ||
274 | ff_dlog(avctx, "floating = %i\n", sconf->floating); | ||
275 | ff_dlog(avctx, "frame_length = %i\n", sconf->frame_length); | ||
276 | ff_dlog(avctx, "ra_distance = %i\n", sconf->ra_distance); | ||
277 | ff_dlog(avctx, "ra_flag = %i\n", sconf->ra_flag); | ||
278 | ff_dlog(avctx, "adapt_order = %i\n", sconf->adapt_order); | ||
279 | ff_dlog(avctx, "coef_table = %i\n", sconf->coef_table); | ||
280 | ff_dlog(avctx, "long_term_prediction = %i\n", sconf->long_term_prediction); | ||
281 | ff_dlog(avctx, "max_order = %i\n", sconf->max_order); | ||
282 | ff_dlog(avctx, "block_switching = %i\n", sconf->block_switching); | ||
283 | ff_dlog(avctx, "bgmc = %i\n", sconf->bgmc); | ||
284 | ff_dlog(avctx, "sb_part = %i\n", sconf->sb_part); | ||
285 | ff_dlog(avctx, "joint_stereo = %i\n", sconf->joint_stereo); | ||
286 | ff_dlog(avctx, "mc_coding = %i\n", sconf->mc_coding); | ||
287 | ff_dlog(avctx, "chan_config = %i\n", sconf->chan_config); | ||
288 | ff_dlog(avctx, "chan_sort = %i\n", sconf->chan_sort); | ||
289 | ff_dlog(avctx, "RLSLMS = %i\n", sconf->rlslms); | ||
290 | ff_dlog(avctx, "chan_config_info = %i\n", sconf->chan_config_info); | ||
291 | #endif | ||
292 | 14 | } | |
293 | |||
294 | |||
295 | /** Read an ALSSpecificConfig from a buffer into the output struct. | ||
296 | */ | ||
297 | 14 | static av_cold int read_specific_config(ALSDecContext *ctx) | |
298 | { | ||
299 | GetBitContext gb; | ||
300 | uint64_t ht_size; | ||
301 | int i, config_offset; | ||
302 | 14 | MPEG4AudioConfig m4ac = {0}; | |
303 | 14 | ALSSpecificConfig *sconf = &ctx->sconf; | |
304 | 14 | AVCodecContext *avctx = ctx->avctx; | |
305 | uint32_t als_id, header_size, trailer_size; | ||
306 | int ret; | ||
307 | |||
308 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
|
14 | if ((ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size)) < 0) |
309 | ✗ | return ret; | |
310 | |||
311 | 14 | config_offset = avpriv_mpeg4audio_get_config2(&m4ac, avctx->extradata, | |
312 | avctx->extradata_size, 1, avctx); | ||
313 | |||
314 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (config_offset < 0) |
315 | ✗ | return AVERROR_INVALIDDATA; | |
316 | |||
317 | 14 | skip_bits_long(&gb, config_offset); | |
318 | |||
319 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
|
14 | if (get_bits_left(&gb) < (30 << 3)) |
320 | ✗ | return AVERROR_INVALIDDATA; | |
321 | |||
322 | // read the fixed items | ||
323 | 14 | als_id = get_bits_long(&gb, 32); | |
324 | 14 | avctx->sample_rate = m4ac.sample_rate; | |
325 | 14 | skip_bits_long(&gb, 32); // sample rate already known | |
326 | 14 | sconf->samples = get_bits_long(&gb, 32); | |
327 | |||
328 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (avctx->ch_layout.nb_channels != m4ac.channels) { |
329 | ✗ | av_channel_layout_uninit(&avctx->ch_layout); | |
330 | ✗ | avctx->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC; | |
331 | ✗ | avctx->ch_layout.nb_channels = m4ac.channels; | |
332 | } | ||
333 | |||
334 | 14 | skip_bits(&gb, 16); // number of channels already known | |
335 | 14 | skip_bits(&gb, 3); // skip file_type | |
336 | 14 | sconf->resolution = get_bits(&gb, 3); | |
337 | 14 | sconf->floating = get_bits1(&gb); | |
338 | 14 | sconf->msb_first = get_bits1(&gb); | |
339 | 14 | sconf->frame_length = get_bits(&gb, 16) + 1; | |
340 | 14 | sconf->ra_distance = get_bits(&gb, 8); | |
341 | 14 | sconf->ra_flag = get_bits(&gb, 2); | |
342 | 14 | sconf->adapt_order = get_bits1(&gb); | |
343 | 14 | sconf->coef_table = get_bits(&gb, 2); | |
344 | 14 | sconf->long_term_prediction = get_bits1(&gb); | |
345 | 14 | sconf->max_order = get_bits(&gb, 10); | |
346 | 14 | sconf->block_switching = get_bits(&gb, 2); | |
347 | 14 | sconf->bgmc = get_bits1(&gb); | |
348 | 14 | sconf->sb_part = get_bits1(&gb); | |
349 | 14 | sconf->joint_stereo = get_bits1(&gb); | |
350 | 14 | sconf->mc_coding = get_bits1(&gb); | |
351 | 14 | sconf->chan_config = get_bits1(&gb); | |
352 | 14 | sconf->chan_sort = get_bits1(&gb); | |
353 | 14 | sconf->crc_enabled = get_bits1(&gb); | |
354 | 14 | sconf->rlslms = get_bits1(&gb); | |
355 | 14 | skip_bits(&gb, 5); // skip 5 reserved bits | |
356 | 14 | skip_bits1(&gb); // skip aux_data_enabled | |
357 | |||
358 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (sconf->max_order > ctx->user_max_order) { |
359 | ✗ | av_log(avctx, AV_LOG_ERROR, "order %d exceeds specified max %d\n", sconf->max_order, ctx->user_max_order); | |
360 | ✗ | return AVERROR_INVALIDDATA; | |
361 | } | ||
362 | |||
363 | |||
364 | // check for ALSSpecificConfig struct | ||
365 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (als_id != MKBETAG('A','L','S','\0')) |
366 | ✗ | return AVERROR_INVALIDDATA; | |
367 | |||
368 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (avctx->ch_layout.nb_channels > FF_SANE_NB_CHANNELS) { |
369 | ✗ | avpriv_request_sample(avctx, "Huge number of channels"); | |
370 | ✗ | return AVERROR_PATCHWELCOME; | |
371 | } | ||
372 | |||
373 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (avctx->ch_layout.nb_channels == 0) |
374 | ✗ | return AVERROR_INVALIDDATA; | |
375 | |||
376 | 14 | ctx->cur_frame_length = sconf->frame_length; | |
377 | |||
378 | // read channel config | ||
379 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (sconf->chan_config) |
380 | ✗ | sconf->chan_config_info = get_bits(&gb, 16); | |
381 | // TODO: use this to set avctx->channel_layout | ||
382 | |||
383 | |||
384 | // read channel sorting | ||
385 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
14 | if (sconf->chan_sort && avctx->ch_layout.nb_channels > 1) { |
386 | ✗ | int chan_pos_bits = av_ceil_log2(avctx->ch_layout.nb_channels); | |
387 | ✗ | int bits_needed = avctx->ch_layout.nb_channels * chan_pos_bits + 7; | |
388 | ✗ | if (get_bits_left(&gb) < bits_needed) | |
389 | ✗ | return AVERROR_INVALIDDATA; | |
390 | |||
391 | ✗ | if (!(sconf->chan_pos = av_malloc_array(avctx->ch_layout.nb_channels, sizeof(*sconf->chan_pos)))) | |
392 | ✗ | return AVERROR(ENOMEM); | |
393 | |||
394 | ✗ | ctx->cs_switch = 1; | |
395 | |||
396 | ✗ | for (i = 0; i < avctx->ch_layout.nb_channels; i++) { | |
397 | ✗ | sconf->chan_pos[i] = -1; | |
398 | } | ||
399 | |||
400 | ✗ | for (i = 0; i < avctx->ch_layout.nb_channels; i++) { | |
401 | int idx; | ||
402 | |||
403 | ✗ | idx = get_bits(&gb, chan_pos_bits); | |
404 | ✗ | if (idx >= avctx->ch_layout.nb_channels || sconf->chan_pos[idx] != -1) { | |
405 | ✗ | av_log(avctx, AV_LOG_WARNING, "Invalid channel reordering.\n"); | |
406 | ✗ | ctx->cs_switch = 0; | |
407 | ✗ | break; | |
408 | } | ||
409 | ✗ | sconf->chan_pos[idx] = i; | |
410 | } | ||
411 | |||
412 | ✗ | align_get_bits(&gb); | |
413 | } | ||
414 | |||
415 | |||
416 | // read fixed header and trailer sizes, | ||
417 | // if size = 0xFFFFFFFF then there is no data field! | ||
418 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
|
14 | if (get_bits_left(&gb) < 64) |
419 | ✗ | return AVERROR_INVALIDDATA; | |
420 | |||
421 | 14 | header_size = get_bits_long(&gb, 32); | |
422 | 14 | trailer_size = get_bits_long(&gb, 32); | |
423 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (header_size == 0xFFFFFFFF) |
424 | ✗ | header_size = 0; | |
425 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (trailer_size == 0xFFFFFFFF) |
426 | ✗ | trailer_size = 0; | |
427 | |||
428 | 14 | ht_size = ((int64_t)(header_size) + (int64_t)(trailer_size)) << 3; | |
429 | |||
430 | |||
431 | // skip the header and trailer data | ||
432 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
|
14 | if (get_bits_left(&gb) < ht_size) |
433 | ✗ | return AVERROR_INVALIDDATA; | |
434 | |||
435 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (ht_size > INT32_MAX) |
436 | ✗ | return AVERROR_PATCHWELCOME; | |
437 | |||
438 | 14 | skip_bits_long(&gb, ht_size); | |
439 | |||
440 | |||
441 | // initialize CRC calculation | ||
442 |
1/2✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
|
14 | if (sconf->crc_enabled) { |
443 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
|
14 | if (get_bits_left(&gb) < 32) |
444 | ✗ | return AVERROR_INVALIDDATA; | |
445 | |||
446 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) { |
447 | ✗ | ctx->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE); | |
448 | ✗ | ctx->crc = 0xFFFFFFFF; | |
449 | ✗ | ctx->crc_org = ~get_bits_long(&gb, 32); | |
450 | } else | ||
451 | 14 | skip_bits_long(&gb, 32); | |
452 | } | ||
453 | |||
454 | |||
455 | // no need to read the rest of ALSSpecificConfig (ra_unit_size & aux data) | ||
456 | |||
457 | 14 | dprint_specific_config(ctx); | |
458 | |||
459 | 14 | return 0; | |
460 | } | ||
461 | |||
462 | |||
463 | /** Check the ALSSpecificConfig for unsupported features. | ||
464 | */ | ||
465 | 14 | static int check_specific_config(ALSDecContext *ctx) | |
466 | { | ||
467 | 14 | ALSSpecificConfig *sconf = &ctx->sconf; | |
468 | 14 | int error = 0; | |
469 | |||
470 | // report unsupported feature and set error value | ||
471 | #define MISSING_ERR(cond, str, errval) \ | ||
472 | { \ | ||
473 | if (cond) { \ | ||
474 | avpriv_report_missing_feature(ctx->avctx, \ | ||
475 | str); \ | ||
476 | error = errval; \ | ||
477 | } \ | ||
478 | } | ||
479 | |||
480 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | MISSING_ERR(sconf->rlslms, "Adaptive RLS-LMS prediction", AVERROR_PATCHWELCOME); |
481 | |||
482 | 14 | return error; | |
483 | } | ||
484 | |||
485 | |||
486 | /** Parse the bs_info field to extract the block partitioning used in | ||
487 | * block switching mode, refer to ISO/IEC 14496-3, section 11.6.2. | ||
488 | */ | ||
489 | 3146 | static void parse_bs_info(const uint32_t bs_info, unsigned int n, | |
490 | unsigned int div, unsigned int **div_blocks, | ||
491 | unsigned int *num_blocks) | ||
492 | { | ||
493 |
4/4✓ Branch 0 taken 3080 times.
✓ Branch 1 taken 66 times.
✓ Branch 2 taken 121 times.
✓ Branch 3 taken 2959 times.
|
3146 | if (n < 31 && ((bs_info << n) & 0x40000000)) { |
494 | // if the level is valid and the investigated bit n is set | ||
495 | // then recursively check both children at bits (2n+1) and (2n+2) | ||
496 | 121 | n *= 2; | |
497 | 121 | div += 1; | |
498 | 121 | parse_bs_info(bs_info, n + 1, div, div_blocks, num_blocks); | |
499 | 121 | parse_bs_info(bs_info, n + 2, div, div_blocks, num_blocks); | |
500 | } else { | ||
501 | // else the bit is not set or the last level has been reached | ||
502 | // (bit implicitly not set) | ||
503 | 3025 | **div_blocks = div; | |
504 | 3025 | (*div_blocks)++; | |
505 | 3025 | (*num_blocks)++; | |
506 | } | ||
507 | 3146 | } | |
508 | |||
509 | |||
510 | /** Read and decode a Rice codeword. | ||
511 | */ | ||
512 | 7307594 | static int32_t decode_rice(GetBitContext *gb, unsigned int k) | |
513 | { | ||
514 | 7307594 | int max = get_bits_left(gb) - k; | |
515 | 7307594 | unsigned q = get_unary(gb, 0, max); | |
516 |
2/2✓ Branch 0 taken 7076207 times.
✓ Branch 1 taken 231387 times.
|
7307594 | int r = k ? get_bits1(gb) : !(q & 1); |
517 | |||
518 |
2/2✓ Branch 0 taken 7018473 times.
✓ Branch 1 taken 289121 times.
|
7307594 | if (k > 1) { |
519 | 7018473 | q <<= (k - 1); | |
520 | 7018473 | q += get_bits_long(gb, k - 1); | |
521 |
2/2✓ Branch 0 taken 231387 times.
✓ Branch 1 taken 57734 times.
|
289121 | } else if (!k) { |
522 | 231387 | q >>= 1; | |
523 | } | ||
524 |
2/2✓ Branch 0 taken 3337708 times.
✓ Branch 1 taken 3969886 times.
|
7307594 | return r ? q : ~q; |
525 | } | ||
526 | |||
527 | |||
528 | /** Convert PARCOR coefficient k to direct filter coefficient. | ||
529 | */ | ||
530 | 137495 | static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof) | |
531 | { | ||
532 | int i, j; | ||
533 | |||
534 |
2/2✓ Branch 0 taken 2446840 times.
✓ Branch 1 taken 137495 times.
|
2584335 | for (i = 0, j = k - 1; i < j; i++, j--) { |
535 | 2446840 | unsigned tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20); | |
536 | 2446840 | cof[j] += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20); | |
537 | 2446840 | cof[i] += tmp1; | |
538 | } | ||
539 |
2/2✓ Branch 0 taken 68217 times.
✓ Branch 1 taken 69278 times.
|
137495 | if (i == j) |
540 | 68217 | cof[i] += ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20); | |
541 | |||
542 | 137495 | cof[k] = par[k]; | |
543 | 137495 | } | |
544 | |||
545 | |||
546 | /** Read block switching field if necessary and set actual block sizes. | ||
547 | * Also assure that the block sizes of the last frame correspond to the | ||
548 | * actual number of samples. | ||
549 | */ | ||
550 | 2904 | static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks, | |
551 | uint32_t *bs_info) | ||
552 | { | ||
553 | 2904 | ALSSpecificConfig *sconf = &ctx->sconf; | |
554 | 2904 | GetBitContext *gb = &ctx->gb; | |
555 | 2904 | unsigned int *ptr_div_blocks = div_blocks; | |
556 | unsigned int b; | ||
557 | |||
558 |
2/2✓ Branch 0 taken 112 times.
✓ Branch 1 taken 2792 times.
|
2904 | if (sconf->block_switching) { |
559 | 112 | unsigned int bs_info_len = 1 << (sconf->block_switching + 2); | |
560 | 112 | *bs_info = get_bits_long(gb, bs_info_len); | |
561 | 112 | *bs_info <<= (32 - bs_info_len); | |
562 | } | ||
563 | |||
564 | 2904 | ctx->num_blocks = 0; | |
565 | 2904 | parse_bs_info(*bs_info, 0, 0, &ptr_div_blocks, &ctx->num_blocks); | |
566 | |||
567 | // The last frame may have an overdetermined block structure given in | ||
568 | // the bitstream. In that case the defined block structure would need | ||
569 | // more samples than available to be consistent. | ||
570 | // The block structure is actually used but the block sizes are adapted | ||
571 | // to fit the actual number of available samples. | ||
572 | // Example: 5 samples, 2nd level block sizes: 2 2 2 2. | ||
573 | // This results in the actual block sizes: 2 2 1 0. | ||
574 | // This is not specified in 14496-3 but actually done by the reference | ||
575 | // codec RM22 revision 2. | ||
576 | // This appears to happen in case of an odd number of samples in the last | ||
577 | // frame which is actually not allowed by the block length switching part | ||
578 | // of 14496-3. | ||
579 | // The ALS conformance files feature an odd number of samples in the last | ||
580 | // frame. | ||
581 | |||
582 |
2/2✓ Branch 0 taken 3025 times.
✓ Branch 1 taken 2904 times.
|
5929 | for (b = 0; b < ctx->num_blocks; b++) |
583 | 3025 | div_blocks[b] = ctx->sconf.frame_length >> div_blocks[b]; | |
584 | |||
585 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 2892 times.
|
2904 | if (ctx->cur_frame_length != ctx->sconf.frame_length) { |
586 | 12 | unsigned int remaining = ctx->cur_frame_length; | |
587 | |||
588 |
1/2✓ Branch 0 taken 17 times.
✗ Branch 1 not taken.
|
17 | for (b = 0; b < ctx->num_blocks; b++) { |
589 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 5 times.
|
17 | if (remaining <= div_blocks[b]) { |
590 | 12 | div_blocks[b] = remaining; | |
591 | 12 | ctx->num_blocks = b + 1; | |
592 | 12 | break; | |
593 | } | ||
594 | |||
595 | 5 | remaining -= div_blocks[b]; | |
596 | } | ||
597 | } | ||
598 | 2904 | } | |
599 | |||
600 | |||
601 | /** Read the block data for a constant block | ||
602 | */ | ||
603 | ✗ | static int read_const_block_data(ALSDecContext *ctx, ALSBlockData *bd) | |
604 | { | ||
605 | ✗ | ALSSpecificConfig *sconf = &ctx->sconf; | |
606 | ✗ | AVCodecContext *avctx = ctx->avctx; | |
607 | ✗ | GetBitContext *gb = &ctx->gb; | |
608 | |||
609 | ✗ | if (bd->block_length <= 0) | |
610 | ✗ | return AVERROR_INVALIDDATA; | |
611 | |||
612 | ✗ | *bd->raw_samples = 0; | |
613 | ✗ | *bd->const_block = get_bits1(gb); // 1 = constant value, 0 = zero block (silence) | |
614 | ✗ | bd->js_blocks = get_bits1(gb); | |
615 | |||
616 | // skip 5 reserved bits | ||
617 | ✗ | skip_bits(gb, 5); | |
618 | |||
619 | ✗ | if (*bd->const_block) { | |
620 | ✗ | unsigned int const_val_bits = sconf->floating ? 24 : avctx->bits_per_raw_sample; | |
621 | ✗ | *bd->raw_samples = get_sbits_long(gb, const_val_bits); | |
622 | } | ||
623 | |||
624 | // ensure constant block decoding by reusing this field | ||
625 | ✗ | *bd->const_block = 1; | |
626 | |||
627 | ✗ | return 0; | |
628 | } | ||
629 | |||
630 | |||
631 | /** Decode the block data for a constant block | ||
632 | */ | ||
633 | ✗ | static void decode_const_block_data(ALSDecContext *ctx, ALSBlockData *bd) | |
634 | { | ||
635 | ✗ | int smp = bd->block_length - 1; | |
636 | ✗ | int32_t val = *bd->raw_samples; | |
637 | ✗ | int32_t *dst = bd->raw_samples + 1; | |
638 | |||
639 | // write raw samples into buffer | ||
640 | ✗ | for (; smp; smp--) | |
641 | ✗ | *dst++ = val; | |
642 | ✗ | } | |
643 | |||
644 | |||
645 | /** Read the block data for a non-constant block | ||
646 | */ | ||
647 | 4767 | static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd) | |
648 | { | ||
649 | 4767 | ALSSpecificConfig *sconf = &ctx->sconf; | |
650 | 4767 | AVCodecContext *avctx = ctx->avctx; | |
651 | 4767 | GetBitContext *gb = &ctx->gb; | |
652 | unsigned int k; | ||
653 | unsigned int s[8]; | ||
654 | unsigned int sx[8]; | ||
655 | unsigned int sub_blocks, log2_sub_blocks, sb_length; | ||
656 | 4767 | unsigned int start = 0; | |
657 | unsigned int opt_order; | ||
658 | int sb; | ||
659 | 4767 | int32_t *quant_cof = bd->quant_cof; | |
660 | int32_t *current_res; | ||
661 | |||
662 | |||
663 | // ensure variable block decoding by reusing this field | ||
664 | 4767 | *bd->const_block = 0; | |
665 | |||
666 | 4767 | *bd->opt_order = 1; | |
667 | 4767 | bd->js_blocks = get_bits1(gb); | |
668 | |||
669 | 4767 | opt_order = *bd->opt_order; | |
670 | |||
671 | // determine the number of subblocks for entropy decoding | ||
672 |
3/4✓ Branch 0 taken 3045 times.
✓ Branch 1 taken 1722 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3045 times.
|
4767 | if (!sconf->bgmc && !sconf->sb_part) { |
673 | ✗ | log2_sub_blocks = 0; | |
674 | } else { | ||
675 |
3/4✓ Branch 0 taken 1722 times.
✓ Branch 1 taken 3045 times.
✓ Branch 2 taken 1722 times.
✗ Branch 3 not taken.
|
4767 | if (sconf->bgmc && sconf->sb_part) |
676 | 1722 | log2_sub_blocks = get_bits(gb, 2); | |
677 | else | ||
678 | 3045 | log2_sub_blocks = 2 * get_bits1(gb); | |
679 | } | ||
680 | |||
681 | 4767 | sub_blocks = 1 << log2_sub_blocks; | |
682 | |||
683 | // do not continue in case of a damaged stream since | ||
684 | // block_length must be evenly divisible by sub_blocks | ||
685 |
2/4✓ Branch 0 taken 4767 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4767 times.
|
4767 | if (bd->block_length & (sub_blocks - 1) || bd->block_length <= 0) { |
686 | ✗ | av_log(avctx, AV_LOG_WARNING, | |
687 | "Block length is not evenly divisible by the number of subblocks.\n"); | ||
688 | ✗ | return AVERROR_INVALIDDATA; | |
689 | } | ||
690 | |||
691 | 4767 | sb_length = bd->block_length >> log2_sub_blocks; | |
692 | |||
693 |
2/2✓ Branch 0 taken 1722 times.
✓ Branch 1 taken 3045 times.
|
4767 | if (sconf->bgmc) { |
694 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1722 times.
|
1722 | s[0] = get_bits(gb, 8 + (sconf->resolution > 1)); |
695 |
2/2✓ Branch 0 taken 1426 times.
✓ Branch 1 taken 1722 times.
|
3148 | for (k = 1; k < sub_blocks; k++) |
696 | 1426 | s[k] = s[k - 1] + decode_rice(gb, 2); | |
697 | |||
698 |
2/2✓ Branch 0 taken 3148 times.
✓ Branch 1 taken 1722 times.
|
4870 | for (k = 0; k < sub_blocks; k++) { |
699 | 3148 | sx[k] = s[k] & 0x0F; | |
700 | 3148 | s [k] >>= 4; | |
701 | } | ||
702 | } else { | ||
703 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3045 times.
|
3045 | s[0] = get_bits(gb, 4 + (sconf->resolution > 1)); |
704 |
2/2✓ Branch 0 taken 2280 times.
✓ Branch 1 taken 3045 times.
|
5325 | for (k = 1; k < sub_blocks; k++) |
705 | 2280 | s[k] = s[k - 1] + decode_rice(gb, 0); | |
706 | } | ||
707 |
2/2✓ Branch 0 taken 3706 times.
✓ Branch 1 taken 4767 times.
|
8473 | for (k = 1; k < sub_blocks; k++) |
708 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3706 times.
|
3706 | if (s[k] > 32) { |
709 | ✗ | av_log(avctx, AV_LOG_ERROR, "k invalid for rice code.\n"); | |
710 | ✗ | return AVERROR_INVALIDDATA; | |
711 | } | ||
712 | |||
713 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4767 times.
|
4767 | if (get_bits1(gb)) |
714 | ✗ | *bd->shift_lsbs = get_bits(gb, 4) + 1; | |
715 | |||
716 |
4/6✓ Branch 0 taken 9 times.
✓ Branch 1 taken 4758 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 9 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 4758 times.
|
4767 | *bd->store_prev_samples = (bd->js_blocks && bd->raw_other) || *bd->shift_lsbs; |
717 | |||
718 | |||
719 |
1/2✓ Branch 0 taken 4767 times.
✗ Branch 1 not taken.
|
4767 | if (!sconf->rlslms) { |
720 |
3/4✓ Branch 0 taken 1975 times.
✓ Branch 1 taken 2792 times.
✓ Branch 2 taken 1975 times.
✗ Branch 3 not taken.
|
6742 | if (sconf->adapt_order && sconf->max_order) { |
721 | 1975 | int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1, | |
722 | 1975 | 2, sconf->max_order + 1)); | |
723 | 1975 | *bd->opt_order = get_bits(gb, opt_order_length); | |
724 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1975 times.
|
1975 | if (*bd->opt_order > sconf->max_order) { |
725 | ✗ | *bd->opt_order = sconf->max_order; | |
726 | ✗ | av_log(avctx, AV_LOG_ERROR, "Predictor order too large.\n"); | |
727 | ✗ | return AVERROR_INVALIDDATA; | |
728 | } | ||
729 | } else { | ||
730 | 2792 | *bd->opt_order = sconf->max_order; | |
731 | } | ||
732 | 4767 | opt_order = *bd->opt_order; | |
733 | |||
734 |
1/2✓ Branch 0 taken 4767 times.
✗ Branch 1 not taken.
|
4767 | if (opt_order) { |
735 | int add_base; | ||
736 | |||
737 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4767 times.
|
4767 | if (sconf->coef_table == 3) { |
738 | ✗ | add_base = 0x7F; | |
739 | |||
740 | // read coefficient 0 | ||
741 | ✗ | quant_cof[0] = 32 * parcor_scaled_values[get_bits(gb, 7)]; | |
742 | |||
743 | // read coefficient 1 | ||
744 | ✗ | if (opt_order > 1) | |
745 | ✗ | quant_cof[1] = -32 * parcor_scaled_values[get_bits(gb, 7)]; | |
746 | |||
747 | // read coefficients 2 to opt_order | ||
748 | ✗ | for (k = 2; k < opt_order; k++) | |
749 | ✗ | quant_cof[k] = get_bits(gb, 7); | |
750 | } else { | ||
751 | int k_max; | ||
752 | 4767 | add_base = 1; | |
753 | |||
754 | // read coefficient 0 to 19 | ||
755 | 4767 | k_max = FFMIN(opt_order, 20); | |
756 |
2/2✓ Branch 0 taken 65747 times.
✓ Branch 1 taken 4767 times.
|
70514 | for (k = 0; k < k_max; k++) { |
757 | 65747 | int rice_param = parcor_rice_table[sconf->coef_table][k][1]; | |
758 | 65747 | int offset = parcor_rice_table[sconf->coef_table][k][0]; | |
759 | 65747 | quant_cof[k] = decode_rice(gb, rice_param) + offset; | |
760 |
2/4✓ Branch 0 taken 65747 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 65747 times.
|
65747 | if (quant_cof[k] < -64 || quant_cof[k] > 63) { |
761 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
762 | "quant_cof %"PRId32" is out of range.\n", | ||
763 | ✗ | quant_cof[k]); | |
764 | ✗ | return AVERROR_INVALIDDATA; | |
765 | } | ||
766 | } | ||
767 | |||
768 | // read coefficients 20 to 126 | ||
769 | 4767 | k_max = FFMIN(opt_order, 127); | |
770 |
2/2✓ Branch 0 taken 70472 times.
✓ Branch 1 taken 4767 times.
|
75239 | for (; k < k_max; k++) |
771 | 70472 | quant_cof[k] = decode_rice(gb, 2) + (k & 1); | |
772 | |||
773 | // read coefficients 127 to opt_order | ||
774 |
2/2✓ Branch 0 taken 1276 times.
✓ Branch 1 taken 4767 times.
|
6043 | for (; k < opt_order; k++) |
775 | 1276 | quant_cof[k] = decode_rice(gb, 1); | |
776 | |||
777 | 4767 | quant_cof[0] = 32 * parcor_scaled_values[quant_cof[0] + 64]; | |
778 | |||
779 |
1/2✓ Branch 0 taken 4767 times.
✗ Branch 1 not taken.
|
4767 | if (opt_order > 1) |
780 | 4767 | quant_cof[1] = -32 * parcor_scaled_values[quant_cof[1] + 64]; | |
781 | } | ||
782 | |||
783 |
2/2✓ Branch 0 taken 127961 times.
✓ Branch 1 taken 4767 times.
|
132728 | for (k = 2; k < opt_order; k++) |
784 | 127961 | quant_cof[k] = (quant_cof[k] * (1U << 14)) + (add_base << 13); | |
785 | } | ||
786 | } | ||
787 | |||
788 | // read LTP gain and lag values | ||
789 |
2/2✓ Branch 0 taken 1722 times.
✓ Branch 1 taken 3045 times.
|
4767 | if (sconf->long_term_prediction) { |
790 | 1722 | *bd->use_ltp = get_bits1(gb); | |
791 | |||
792 |
2/2✓ Branch 0 taken 1558 times.
✓ Branch 1 taken 164 times.
|
1722 | if (*bd->use_ltp) { |
793 | int r, c; | ||
794 | |||
795 | 1558 | bd->ltp_gain[0] = decode_rice(gb, 1) * 8; | |
796 | 1558 | bd->ltp_gain[1] = decode_rice(gb, 2) * 8; | |
797 | |||
798 | 1558 | r = get_unary(gb, 0, 4); | |
799 | 1558 | c = get_bits(gb, 2); | |
800 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1558 times.
|
1558 | if (r >= 4) { |
801 | ✗ | av_log(avctx, AV_LOG_ERROR, "r overflow\n"); | |
802 | ✗ | return AVERROR_INVALIDDATA; | |
803 | } | ||
804 | |||
805 | 1558 | bd->ltp_gain[2] = ltp_gain_values[r][c]; | |
806 | |||
807 | 1558 | bd->ltp_gain[3] = decode_rice(gb, 2) * 8; | |
808 | 1558 | bd->ltp_gain[4] = decode_rice(gb, 1) * 8; | |
809 | |||
810 | 1558 | *bd->ltp_lag = get_bits(gb, ctx->ltp_lag_length); | |
811 | 1558 | *bd->ltp_lag += FFMAX(4, opt_order + 1); | |
812 | } | ||
813 | } | ||
814 | |||
815 | // read first value and residuals in case of a random access block | ||
816 |
2/2✓ Branch 0 taken 698 times.
✓ Branch 1 taken 4069 times.
|
4767 | if (bd->ra_block) { |
817 | 698 | start = FFMIN(opt_order, 3); | |
818 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 698 times.
|
698 | av_assert0(sb_length <= sconf->frame_length); |
819 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 698 times.
|
698 | if (sb_length <= start) { |
820 | // opt_order or sb_length may be corrupted, either way this is unsupported and not well defined in the specification | ||
821 | ✗ | av_log(avctx, AV_LOG_ERROR, "Sub block length smaller or equal start\n"); | |
822 | ✗ | return AVERROR_PATCHWELCOME; | |
823 | } | ||
824 | |||
825 |
1/2✓ Branch 0 taken 698 times.
✗ Branch 1 not taken.
|
698 | if (opt_order) |
826 | 698 | bd->raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4); | |
827 |
1/2✓ Branch 0 taken 698 times.
✗ Branch 1 not taken.
|
698 | if (opt_order > 1) |
828 | 698 | bd->raw_samples[1] = decode_rice(gb, FFMIN(s[0] + 3, ctx->s_max)); | |
829 |
2/2✓ Branch 0 taken 697 times.
✓ Branch 1 taken 1 times.
|
698 | if (opt_order > 2) |
830 | 697 | bd->raw_samples[2] = decode_rice(gb, FFMIN(s[0] + 1, ctx->s_max)); | |
831 | } | ||
832 | |||
833 | // read all residuals | ||
834 |
2/2✓ Branch 0 taken 1722 times.
✓ Branch 1 taken 3045 times.
|
4767 | if (sconf->bgmc) { |
835 | int delta[8]; | ||
836 | unsigned int k [8]; | ||
837 | 1722 | unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5); | |
838 | |||
839 | // read most significant bits | ||
840 | unsigned int high; | ||
841 | unsigned int low; | ||
842 | unsigned int value; | ||
843 | |||
844 | 1722 | int ret = ff_bgmc_decode_init(gb, &high, &low, &value); | |
845 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1722 times.
|
1722 | if (ret < 0) |
846 | ✗ | return ret; | |
847 | |||
848 | 1722 | current_res = bd->raw_samples + start; | |
849 | |||
850 |
2/2✓ Branch 0 taken 3148 times.
✓ Branch 1 taken 1722 times.
|
4870 | for (sb = 0; sb < sub_blocks; sb++) { |
851 |
2/2✓ Branch 0 taken 1722 times.
✓ Branch 1 taken 1426 times.
|
3148 | unsigned int sb_len = sb_length - (sb ? 0 : start); |
852 | |||
853 |
2/2✓ Branch 0 taken 285 times.
✓ Branch 1 taken 2863 times.
|
3148 | k [sb] = s[sb] > b ? s[sb] - b : 0; |
854 | 3148 | delta[sb] = 5 - s[sb] + k[sb]; | |
855 | |||
856 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3148 times.
|
3148 | if (k[sb] >= 32) |
857 | ✗ | return AVERROR_INVALIDDATA; | |
858 | |||
859 | 3148 | ff_bgmc_decode(gb, sb_len, current_res, | |
860 | delta[sb], sx[sb], &high, &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status); | ||
861 | |||
862 | 3148 | current_res += sb_len; | |
863 | } | ||
864 | |||
865 | 1722 | ff_bgmc_decode_end(gb); | |
866 | |||
867 | |||
868 | // read least significant bits and tails | ||
869 | 1722 | current_res = bd->raw_samples + start; | |
870 | |||
871 |
2/2✓ Branch 0 taken 3148 times.
✓ Branch 1 taken 1722 times.
|
4870 | for (sb = 0; sb < sub_blocks; sb++, start = 0) { |
872 | 3148 | unsigned int cur_tail_code = tail_code[sx[sb]][delta[sb]]; | |
873 | 3148 | unsigned int cur_k = k[sb]; | |
874 | 3148 | unsigned int cur_s = s[sb]; | |
875 | |||
876 |
2/2✓ Branch 0 taken 4580858 times.
✓ Branch 1 taken 3148 times.
|
4584006 | for (; start < sb_length; start++) { |
877 | 4580858 | int32_t res = *current_res; | |
878 | |||
879 |
2/2✓ Branch 0 taken 12582 times.
✓ Branch 1 taken 4568276 times.
|
4580858 | if (res == cur_tail_code) { |
880 |
2/2✓ Branch 0 taken 7025 times.
✓ Branch 1 taken 5557 times.
|
12582 | unsigned int max_msb = (2 + (sx[sb] > 2) + (sx[sb] > 10)) |
881 | 12582 | << (5 - delta[sb]); | |
882 | |||
883 | 12582 | res = decode_rice(gb, cur_s); | |
884 | |||
885 |
2/2✓ Branch 0 taken 6332 times.
✓ Branch 1 taken 6250 times.
|
12582 | if (res >= 0) { |
886 | 6332 | res += (max_msb ) << cur_k; | |
887 | } else { | ||
888 | 6250 | res -= (max_msb - 1) << cur_k; | |
889 | } | ||
890 | } else { | ||
891 |
2/2✓ Branch 0 taken 94057 times.
✓ Branch 1 taken 4474219 times.
|
4568276 | if (res > cur_tail_code) |
892 | 94057 | res--; | |
893 | |||
894 |
2/2✓ Branch 0 taken 2023961 times.
✓ Branch 1 taken 2544315 times.
|
4568276 | if (res & 1) |
895 | 2023961 | res = -res; | |
896 | |||
897 | 4568276 | res >>= 1; | |
898 | |||
899 |
2/2✓ Branch 0 taken 866509 times.
✓ Branch 1 taken 3701767 times.
|
4568276 | if (cur_k) { |
900 | 866509 | res *= 1U << cur_k; | |
901 | 866509 | res |= get_bits_long(gb, cur_k); | |
902 | } | ||
903 | } | ||
904 | |||
905 | 4580858 | *current_res++ = res; | |
906 | } | ||
907 | } | ||
908 | } else { | ||
909 | 3045 | current_res = bd->raw_samples + start; | |
910 | |||
911 |
2/2✓ Branch 0 taken 5325 times.
✓ Branch 1 taken 3045 times.
|
8370 | for (sb = 0; sb < sub_blocks; sb++, start = 0) |
912 |
2/2✓ Branch 0 taken 7139765 times.
✓ Branch 1 taken 5325 times.
|
7145090 | for (; start < sb_length; start++) |
913 | 7139765 | *current_res++ = decode_rice(gb, s[sb]); | |
914 | } | ||
915 | |||
916 | 4767 | return 0; | |
917 | } | ||
918 | |||
919 | |||
920 | /** Decode the block data for a non-constant block | ||
921 | */ | ||
922 | 4767 | static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd) | |
923 | { | ||
924 | 4767 | ALSSpecificConfig *sconf = &ctx->sconf; | |
925 | 4767 | unsigned int block_length = bd->block_length; | |
926 | 4767 | unsigned int smp = 0; | |
927 | unsigned int k; | ||
928 | 4767 | int opt_order = *bd->opt_order; | |
929 | int sb; | ||
930 | int64_t y; | ||
931 | 4767 | int32_t *quant_cof = bd->quant_cof; | |
932 | 4767 | int32_t *lpc_cof = bd->lpc_cof; | |
933 | 4767 | int32_t *raw_samples = bd->raw_samples; | |
934 | 4767 | int32_t *raw_samples_end = bd->raw_samples + bd->block_length; | |
935 | 4767 | int32_t *lpc_cof_reversed = ctx->lpc_cof_reversed_buffer; | |
936 | |||
937 | // reverse long-term prediction | ||
938 |
2/2✓ Branch 0 taken 1558 times.
✓ Branch 1 taken 3209 times.
|
4767 | if (*bd->use_ltp) { |
939 | int ltp_smp; | ||
940 | |||
941 |
2/2✓ Branch 0 taken 3837729 times.
✓ Branch 1 taken 1558 times.
|
3839287 | for (ltp_smp = FFMAX(*bd->ltp_lag - 2, 0); ltp_smp < block_length; ltp_smp++) { |
942 | 3837729 | int center = ltp_smp - *bd->ltp_lag; | |
943 | 3837729 | int begin = FFMAX(0, center - 2); | |
944 | 3837729 | int end = center + 3; | |
945 | 3837729 | int tab = 5 - (end - begin); | |
946 | int base; | ||
947 | |||
948 | 3837729 | y = 1 << 6; | |
949 | |||
950 |
2/2✓ Branch 0 taken 19173065 times.
✓ Branch 1 taken 3837729 times.
|
23010794 | for (base = begin; base < end; base++, tab++) |
951 | 19173065 | y += (uint64_t)MUL64(bd->ltp_gain[tab], raw_samples[base]); | |
952 | |||
953 | 3837729 | raw_samples[ltp_smp] += y >> 7; | |
954 | } | ||
955 | } | ||
956 | |||
957 | // reconstruct all samples from residuals | ||
958 |
2/2✓ Branch 0 taken 698 times.
✓ Branch 1 taken 4069 times.
|
4767 | if (bd->ra_block) { |
959 |
2/2✓ Branch 0 taken 53295 times.
✓ Branch 1 taken 698 times.
|
53993 | for (smp = 0; smp < FFMIN(opt_order, block_length); smp++) { |
960 | 53295 | y = 1 << 19; | |
961 | |||
962 |
2/2✓ Branch 0 taken 2639030 times.
✓ Branch 1 taken 53295 times.
|
2692325 | for (sb = 0; sb < smp; sb++) |
963 | 2639030 | y += (uint64_t)MUL64(lpc_cof[sb], raw_samples[-(sb + 1)]); | |
964 | |||
965 | 53295 | *raw_samples++ -= y >> 20; | |
966 | 53295 | parcor_to_lpc(smp, quant_cof, lpc_cof); | |
967 | } | ||
968 | } else { | ||
969 |
2/2✓ Branch 0 taken 84200 times.
✓ Branch 1 taken 4069 times.
|
88269 | for (k = 0; k < opt_order; k++) |
970 | 84200 | parcor_to_lpc(k, quant_cof, lpc_cof); | |
971 | |||
972 | // store previous samples in case that they have to be altered | ||
973 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 4060 times.
|
4069 | if (*bd->store_prev_samples) |
974 | 9 | memcpy(bd->prev_raw_samples, raw_samples - sconf->max_order, | |
975 | 9 | sizeof(*bd->prev_raw_samples) * sconf->max_order); | |
976 | |||
977 | // reconstruct difference signal for prediction (joint-stereo) | ||
978 |
3/4✓ Branch 0 taken 9 times.
✓ Branch 1 taken 4060 times.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
|
4069 | if (bd->js_blocks && bd->raw_other) { |
979 | uint32_t *left, *right; | ||
980 | |||
981 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 5 times.
|
9 | if (bd->raw_other > raw_samples) { // D = R - L |
982 | 4 | left = raw_samples; | |
983 | 4 | right = bd->raw_other; | |
984 | } else { // D = R - L | ||
985 | 5 | left = bd->raw_other; | |
986 | 5 | right = raw_samples; | |
987 | } | ||
988 | |||
989 |
2/2✓ Branch 0 taken 324 times.
✓ Branch 1 taken 9 times.
|
333 | for (sb = -1; sb >= -sconf->max_order; sb--) |
990 | 324 | raw_samples[sb] = right[sb] - left[sb]; | |
991 | } | ||
992 | |||
993 | // reconstruct shifted signal | ||
994 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4069 times.
|
4069 | if (*bd->shift_lsbs) |
995 | ✗ | for (sb = -1; sb >= -sconf->max_order; sb--) | |
996 | ✗ | raw_samples[sb] >>= *bd->shift_lsbs; | |
997 | } | ||
998 | |||
999 | // reverse linear prediction coefficients for efficiency | ||
1000 | 4767 | lpc_cof = lpc_cof + opt_order; | |
1001 | |||
1002 |
2/2✓ Branch 0 taken 137495 times.
✓ Branch 1 taken 4767 times.
|
142262 | for (sb = 0; sb < opt_order; sb++) |
1003 | 137495 | lpc_cof_reversed[sb] = lpc_cof[-(sb + 1)]; | |
1004 | |||
1005 | // reconstruct raw samples | ||
1006 | 4767 | raw_samples = bd->raw_samples + smp; | |
1007 | 4767 | lpc_cof = lpc_cof_reversed + opt_order; | |
1008 | |||
1009 |
2/2✓ Branch 0 taken 11669421 times.
✓ Branch 1 taken 4767 times.
|
11674188 | for (; raw_samples < raw_samples_end; raw_samples++) { |
1010 | 11669421 | y = 1 << 19; | |
1011 | |||
1012 |
2/2✓ Branch 0 taken 417572993 times.
✓ Branch 1 taken 11669421 times.
|
429242414 | for (sb = -opt_order; sb < 0; sb++) |
1013 | 417572993 | y += (uint64_t)MUL64(lpc_cof[sb], raw_samples[sb]); | |
1014 | |||
1015 | 11669421 | *raw_samples -= y >> 20; | |
1016 | } | ||
1017 | |||
1018 | 4767 | raw_samples = bd->raw_samples; | |
1019 | |||
1020 | // restore previous samples in case that they have been altered | ||
1021 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 4758 times.
|
4767 | if (*bd->store_prev_samples) |
1022 | 9 | memcpy(raw_samples - sconf->max_order, bd->prev_raw_samples, | |
1023 | 9 | sizeof(*raw_samples) * sconf->max_order); | |
1024 | |||
1025 | 4767 | return 0; | |
1026 | } | ||
1027 | |||
1028 | |||
1029 | /** Read the block data. | ||
1030 | */ | ||
1031 | 4767 | static int read_block(ALSDecContext *ctx, ALSBlockData *bd) | |
1032 | { | ||
1033 | int ret; | ||
1034 | 4767 | GetBitContext *gb = &ctx->gb; | |
1035 | 4767 | ALSSpecificConfig *sconf = &ctx->sconf; | |
1036 | |||
1037 | 4767 | *bd->shift_lsbs = 0; | |
1038 | |||
1039 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4767 times.
|
4767 | if (get_bits_left(gb) < 7) |
1040 | ✗ | return AVERROR_INVALIDDATA; | |
1041 | |||
1042 | // read block type flag and read the samples accordingly | ||
1043 |
1/2✓ Branch 1 taken 4767 times.
✗ Branch 2 not taken.
|
4767 | if (get_bits1(gb)) { |
1044 | 4767 | ret = read_var_block_data(ctx, bd); | |
1045 | } else { | ||
1046 | ✗ | ret = read_const_block_data(ctx, bd); | |
1047 | } | ||
1048 | |||
1049 |
3/4✓ Branch 0 taken 1722 times.
✓ Branch 1 taken 3045 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1722 times.
|
4767 | if (!sconf->mc_coding || ctx->js_switch) |
1050 | 3045 | align_get_bits(gb); | |
1051 | |||
1052 | 4767 | return ret; | |
1053 | } | ||
1054 | |||
1055 | |||
1056 | /** Decode the block data. | ||
1057 | */ | ||
1058 | 4767 | static int decode_block(ALSDecContext *ctx, ALSBlockData *bd) | |
1059 | { | ||
1060 | unsigned int smp; | ||
1061 | 4767 | int ret = 0; | |
1062 | |||
1063 | // read block type flag and read the samples accordingly | ||
1064 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4767 times.
|
4767 | if (*bd->const_block) |
1065 | ✗ | decode_const_block_data(ctx, bd); | |
1066 | else | ||
1067 | 4767 | ret = decode_var_block_data(ctx, bd); // always return 0 | |
1068 | |||
1069 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4767 times.
|
4767 | if (ret < 0) |
1070 | ✗ | return ret; | |
1071 | |||
1072 | // TODO: read RLSLMS extension data | ||
1073 | |||
1074 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4767 times.
|
4767 | if (*bd->shift_lsbs) |
1075 | ✗ | for (smp = 0; smp < bd->block_length; smp++) | |
1076 | ✗ | bd->raw_samples[smp] = (unsigned)bd->raw_samples[smp] << *bd->shift_lsbs; | |
1077 | |||
1078 | 4767 | return 0; | |
1079 | } | ||
1080 | |||
1081 | |||
1082 | /** Read and decode block data successively. | ||
1083 | */ | ||
1084 | 3045 | static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd) | |
1085 | { | ||
1086 | int ret; | ||
1087 | |||
1088 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3045 times.
|
3045 | if ((ret = read_block(ctx, bd)) < 0) |
1089 | ✗ | return ret; | |
1090 | |||
1091 | 3045 | return decode_block(ctx, bd); | |
1092 | } | ||
1093 | |||
1094 | |||
1095 | /** Compute the number of samples left to decode for the current frame and | ||
1096 | * sets these samples to zero. | ||
1097 | */ | ||
1098 | ✗ | static void zero_remaining(unsigned int b, unsigned int b_max, | |
1099 | const unsigned int *div_blocks, int32_t *buf) | ||
1100 | { | ||
1101 | ✗ | unsigned int count = 0; | |
1102 | |||
1103 | ✗ | while (b < b_max) | |
1104 | ✗ | count += div_blocks[b++]; | |
1105 | |||
1106 | ✗ | if (count) | |
1107 | ✗ | memset(buf, 0, sizeof(*buf) * count); | |
1108 | ✗ | } | |
1109 | |||
1110 | |||
1111 | /** Decode blocks independently. | ||
1112 | */ | ||
1113 | 2138 | static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame, | |
1114 | unsigned int c, const unsigned int *div_blocks, | ||
1115 | unsigned int *js_blocks) | ||
1116 | { | ||
1117 | int ret; | ||
1118 | unsigned int b; | ||
1119 | 2138 | ALSBlockData bd = { 0 }; | |
1120 | |||
1121 | 2138 | bd.ra_block = ra_frame; | |
1122 | 2138 | bd.const_block = ctx->const_block; | |
1123 | 2138 | bd.shift_lsbs = ctx->shift_lsbs; | |
1124 | 2138 | bd.opt_order = ctx->opt_order; | |
1125 | 2138 | bd.store_prev_samples = ctx->store_prev_samples; | |
1126 | 2138 | bd.use_ltp = ctx->use_ltp; | |
1127 | 2138 | bd.ltp_lag = ctx->ltp_lag; | |
1128 | 2138 | bd.ltp_gain = ctx->ltp_gain[0]; | |
1129 | 2138 | bd.quant_cof = ctx->quant_cof[0]; | |
1130 | 2138 | bd.lpc_cof = ctx->lpc_cof[0]; | |
1131 | 2138 | bd.prev_raw_samples = ctx->prev_raw_samples; | |
1132 | 2138 | bd.raw_samples = ctx->raw_samples[c]; | |
1133 | |||
1134 | |||
1135 |
2/2✓ Branch 0 taken 2179 times.
✓ Branch 1 taken 2138 times.
|
4317 | for (b = 0; b < ctx->num_blocks; b++) { |
1136 | 2179 | bd.block_length = div_blocks[b]; | |
1137 | |||
1138 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2179 times.
|
2179 | if ((ret = read_decode_block(ctx, &bd)) < 0) { |
1139 | // damaged block, write zero for the rest of the frame | ||
1140 | ✗ | zero_remaining(b, ctx->num_blocks, div_blocks, bd.raw_samples); | |
1141 | ✗ | return ret; | |
1142 | } | ||
1143 | 2179 | bd.raw_samples += div_blocks[b]; | |
1144 | 2179 | bd.ra_block = 0; | |
1145 | } | ||
1146 | |||
1147 | 2138 | return 0; | |
1148 | } | ||
1149 | |||
1150 | |||
1151 | /** Decode blocks dependently. | ||
1152 | */ | ||
1153 | 415 | static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame, | |
1154 | unsigned int c, const unsigned int *div_blocks, | ||
1155 | unsigned int *js_blocks) | ||
1156 | { | ||
1157 | 415 | ALSSpecificConfig *sconf = &ctx->sconf; | |
1158 | 415 | unsigned int offset = 0; | |
1159 | unsigned int b; | ||
1160 | int ret; | ||
1161 | 415 | ALSBlockData bd[2] = { { 0 } }; | |
1162 | |||
1163 | 415 | bd[0].ra_block = ra_frame; | |
1164 | 415 | bd[0].const_block = ctx->const_block; | |
1165 | 415 | bd[0].shift_lsbs = ctx->shift_lsbs; | |
1166 | 415 | bd[0].opt_order = ctx->opt_order; | |
1167 | 415 | bd[0].store_prev_samples = ctx->store_prev_samples; | |
1168 | 415 | bd[0].use_ltp = ctx->use_ltp; | |
1169 | 415 | bd[0].ltp_lag = ctx->ltp_lag; | |
1170 | 415 | bd[0].ltp_gain = ctx->ltp_gain[0]; | |
1171 | 415 | bd[0].quant_cof = ctx->quant_cof[0]; | |
1172 | 415 | bd[0].lpc_cof = ctx->lpc_cof[0]; | |
1173 | 415 | bd[0].prev_raw_samples = ctx->prev_raw_samples; | |
1174 | 415 | bd[0].js_blocks = *js_blocks; | |
1175 | |||
1176 | 415 | bd[1].ra_block = ra_frame; | |
1177 | 415 | bd[1].const_block = ctx->const_block; | |
1178 | 415 | bd[1].shift_lsbs = ctx->shift_lsbs; | |
1179 | 415 | bd[1].opt_order = ctx->opt_order; | |
1180 | 415 | bd[1].store_prev_samples = ctx->store_prev_samples; | |
1181 | 415 | bd[1].use_ltp = ctx->use_ltp; | |
1182 | 415 | bd[1].ltp_lag = ctx->ltp_lag; | |
1183 | 415 | bd[1].ltp_gain = ctx->ltp_gain[0]; | |
1184 | 415 | bd[1].quant_cof = ctx->quant_cof[0]; | |
1185 | 415 | bd[1].lpc_cof = ctx->lpc_cof[0]; | |
1186 | 415 | bd[1].prev_raw_samples = ctx->prev_raw_samples; | |
1187 | 415 | bd[1].js_blocks = *(js_blocks + 1); | |
1188 | |||
1189 | // decode all blocks | ||
1190 |
2/2✓ Branch 0 taken 433 times.
✓ Branch 1 taken 415 times.
|
848 | for (b = 0; b < ctx->num_blocks; b++) { |
1191 | unsigned int s; | ||
1192 | |||
1193 | 433 | bd[0].block_length = div_blocks[b]; | |
1194 | 433 | bd[1].block_length = div_blocks[b]; | |
1195 | |||
1196 | 433 | bd[0].raw_samples = ctx->raw_samples[c ] + offset; | |
1197 | 433 | bd[1].raw_samples = ctx->raw_samples[c + 1] + offset; | |
1198 | |||
1199 | 433 | bd[0].raw_other = bd[1].raw_samples; | |
1200 | 433 | bd[1].raw_other = bd[0].raw_samples; | |
1201 | |||
1202 |
2/4✓ Branch 1 taken 433 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 433 times.
|
866 | if ((ret = read_decode_block(ctx, &bd[0])) < 0 || |
1203 | 433 | (ret = read_decode_block(ctx, &bd[1])) < 0) | |
1204 | ✗ | goto fail; | |
1205 | |||
1206 | // reconstruct joint-stereo blocks | ||
1207 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 429 times.
|
433 | if (bd[0].js_blocks) { |
1208 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (bd[1].js_blocks) |
1209 | ✗ | av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair.\n"); | |
1210 | |||
1211 |
2/2✓ Branch 0 taken 16384 times.
✓ Branch 1 taken 4 times.
|
16388 | for (s = 0; s < div_blocks[b]; s++) |
1212 | 16384 | bd[0].raw_samples[s] = bd[1].raw_samples[s] - (unsigned)bd[0].raw_samples[s]; | |
1213 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 424 times.
|
429 | } else if (bd[1].js_blocks) { |
1214 |
2/2✓ Branch 0 taken 10240 times.
✓ Branch 1 taken 5 times.
|
10245 | for (s = 0; s < div_blocks[b]; s++) |
1215 | 10240 | bd[1].raw_samples[s] = bd[1].raw_samples[s] + (unsigned)bd[0].raw_samples[s]; | |
1216 | } | ||
1217 | |||
1218 | 433 | offset += div_blocks[b]; | |
1219 | 433 | bd[0].ra_block = 0; | |
1220 | 433 | bd[1].ra_block = 0; | |
1221 | } | ||
1222 | |||
1223 | // store carryover raw samples, | ||
1224 | // the others channel raw samples are stored by the calling function. | ||
1225 | 415 | memmove(ctx->raw_samples[c] - sconf->max_order, | |
1226 | 415 | ctx->raw_samples[c] - sconf->max_order + sconf->frame_length, | |
1227 | 415 | sizeof(*ctx->raw_samples[c]) * sconf->max_order); | |
1228 | |||
1229 | 415 | return 0; | |
1230 | ✗ | fail: | |
1231 | // damaged block, write zero for the rest of the frame | ||
1232 | ✗ | zero_remaining(b, ctx->num_blocks, div_blocks, bd[0].raw_samples); | |
1233 | ✗ | zero_remaining(b, ctx->num_blocks, div_blocks, bd[1].raw_samples); | |
1234 | ✗ | return ret; | |
1235 | } | ||
1236 | |||
1237 | 5721 | static inline int als_weighting(GetBitContext *gb, int k, int off) | |
1238 | { | ||
1239 | 5721 | int idx = av_clip(decode_rice(gb, k) + off, | |
1240 | 0, FF_ARRAY_ELEMS(mcc_weightings) - 1); | ||
1241 | 5721 | return mcc_weightings[idx]; | |
1242 | } | ||
1243 | |||
1244 | /** Read the channel data. | ||
1245 | */ | ||
1246 | 1722 | static int read_channel_data(ALSDecContext *ctx, ALSChannelData *cd, int c) | |
1247 | { | ||
1248 | 1722 | GetBitContext *gb = &ctx->gb; | |
1249 | 1722 | ALSChannelData *current = cd; | |
1250 | 1722 | unsigned int channels = ctx->avctx->ch_layout.nb_channels; | |
1251 | 1722 | int entries = 0; | |
1252 | |||
1253 |
3/4✓ Branch 0 taken 2948 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 1226 times.
✓ Branch 4 taken 1722 times.
|
2948 | while (entries < channels && !(current->stop_flag = get_bits1(gb))) { |
1254 | 1226 | current->master_channel = get_bits_long(gb, av_ceil_log2(channels)); | |
1255 | |||
1256 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1226 times.
|
1226 | if (current->master_channel >= channels) { |
1257 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, "Invalid master channel.\n"); | |
1258 | ✗ | return AVERROR_INVALIDDATA; | |
1259 | } | ||
1260 | |||
1261 |
1/2✓ Branch 0 taken 1226 times.
✗ Branch 1 not taken.
|
1226 | if (current->master_channel != c) { |
1262 | 1226 | current->time_diff_flag = get_bits1(gb); | |
1263 | 1226 | current->weighting[0] = als_weighting(gb, 1, 16); | |
1264 | 1226 | current->weighting[1] = als_weighting(gb, 2, 14); | |
1265 | 1226 | current->weighting[2] = als_weighting(gb, 1, 16); | |
1266 | |||
1267 |
2/2✓ Branch 0 taken 681 times.
✓ Branch 1 taken 545 times.
|
1226 | if (current->time_diff_flag) { |
1268 | 681 | current->weighting[3] = als_weighting(gb, 1, 16); | |
1269 | 681 | current->weighting[4] = als_weighting(gb, 1, 16); | |
1270 | 681 | current->weighting[5] = als_weighting(gb, 1, 16); | |
1271 | |||
1272 | 681 | current->time_diff_sign = get_bits1(gb); | |
1273 | 681 | current->time_diff_index = get_bits(gb, ctx->ltp_lag_length - 3) + 3; | |
1274 | } | ||
1275 | } | ||
1276 | |||
1277 | 1226 | current++; | |
1278 | 1226 | entries++; | |
1279 | } | ||
1280 | |||
1281 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1722 times.
|
1722 | if (entries == channels) { |
1282 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, "Damaged channel data.\n"); | |
1283 | ✗ | return AVERROR_INVALIDDATA; | |
1284 | } | ||
1285 | |||
1286 | 1722 | align_get_bits(gb); | |
1287 | 1722 | return 0; | |
1288 | } | ||
1289 | |||
1290 | |||
1291 | /** Recursively reverts the inter-channel correlation for a block. | ||
1292 | */ | ||
1293 | 2948 | static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd, | |
1294 | ALSChannelData **cd, int *reverted, | ||
1295 | unsigned int offset, int c) | ||
1296 | { | ||
1297 | 2948 | ALSChannelData *ch = cd[c]; | |
1298 | 2948 | unsigned int dep = 0; | |
1299 | 2948 | unsigned int channels = ctx->avctx->ch_layout.nb_channels; | |
1300 | 2948 | unsigned int channel_size = ctx->sconf.frame_length + ctx->sconf.max_order; | |
1301 | |||
1302 |
2/2✓ Branch 0 taken 1226 times.
✓ Branch 1 taken 1722 times.
|
2948 | if (reverted[c]) |
1303 | 1226 | return 0; | |
1304 | |||
1305 | 1722 | reverted[c] = 1; | |
1306 | |||
1307 |
3/4✓ Branch 0 taken 2948 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1226 times.
✓ Branch 3 taken 1722 times.
|
2948 | while (dep < channels && !ch[dep].stop_flag) { |
1308 | 1226 | revert_channel_correlation(ctx, bd, cd, reverted, offset, | |
1309 | 1226 | ch[dep].master_channel); | |
1310 | |||
1311 | 1226 | dep++; | |
1312 | } | ||
1313 | |||
1314 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1722 times.
|
1722 | if (dep == channels) { |
1315 | ✗ | av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation.\n"); | |
1316 | ✗ | return AVERROR_INVALIDDATA; | |
1317 | } | ||
1318 | |||
1319 | 1722 | bd->const_block = ctx->const_block + c; | |
1320 | 1722 | bd->shift_lsbs = ctx->shift_lsbs + c; | |
1321 | 1722 | bd->opt_order = ctx->opt_order + c; | |
1322 | 1722 | bd->store_prev_samples = ctx->store_prev_samples + c; | |
1323 | 1722 | bd->use_ltp = ctx->use_ltp + c; | |
1324 | 1722 | bd->ltp_lag = ctx->ltp_lag + c; | |
1325 | 1722 | bd->ltp_gain = ctx->ltp_gain[c]; | |
1326 | 1722 | bd->lpc_cof = ctx->lpc_cof[c]; | |
1327 | 1722 | bd->quant_cof = ctx->quant_cof[c]; | |
1328 | 1722 | bd->raw_samples = ctx->raw_samples[c] + offset; | |
1329 | |||
1330 |
2/2✓ Branch 0 taken 1226 times.
✓ Branch 1 taken 1722 times.
|
2948 | for (dep = 0; !ch[dep].stop_flag; dep++) { |
1331 | ptrdiff_t smp; | ||
1332 | 1226 | ptrdiff_t begin = 1; | |
1333 | 1226 | ptrdiff_t end = bd->block_length - 1; | |
1334 | int64_t y; | ||
1335 | 1226 | int32_t *master = ctx->raw_samples[ch[dep].master_channel] + offset; | |
1336 | |||
1337 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1226 times.
|
1226 | if (ch[dep].master_channel == c) |
1338 | ✗ | continue; | |
1339 | |||
1340 |
2/2✓ Branch 0 taken 681 times.
✓ Branch 1 taken 545 times.
|
1226 | if (ch[dep].time_diff_flag) { |
1341 | 681 | int t = ch[dep].time_diff_index; | |
1342 | |||
1343 |
2/2✓ Branch 0 taken 313 times.
✓ Branch 1 taken 368 times.
|
681 | if (ch[dep].time_diff_sign) { |
1344 | 313 | t = -t; | |
1345 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 313 times.
|
313 | if (begin < t) { |
1346 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, "begin %"PTRDIFF_SPECIFIER" smaller than time diff index %d.\n", begin, t); | |
1347 | ✗ | return AVERROR_INVALIDDATA; | |
1348 | } | ||
1349 | 313 | begin -= t; | |
1350 | } else { | ||
1351 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 368 times.
|
368 | if (end < t) { |
1352 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, "end %"PTRDIFF_SPECIFIER" smaller than time diff index %d.\n", end, t); | |
1353 | ✗ | return AVERROR_INVALIDDATA; | |
1354 | } | ||
1355 | 368 | end -= t; | |
1356 | } | ||
1357 | |||
1358 |
3/4✓ Branch 0 taken 313 times.
✓ Branch 1 taken 368 times.
✓ Branch 2 taken 681 times.
✗ Branch 3 not taken.
|
681 | if (FFMIN(begin - 1, begin - 1 + t) < ctx->raw_buffer - master || |
1359 |
3/4✓ Branch 0 taken 313 times.
✓ Branch 1 taken 368 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 681 times.
|
681 | FFMAX(end + 1, end + 1 + t) > ctx->raw_buffer + channels * channel_size - master) { |
1360 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, | |
1361 | "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n", | ||
1362 | ✗ | master + FFMIN(begin - 1, begin - 1 + t), master + FFMAX(end + 1, end + 1 + t), | |
1363 | ✗ | ctx->raw_buffer, ctx->raw_buffer + channels * channel_size); | |
1364 | ✗ | return AVERROR_INVALIDDATA; | |
1365 | } | ||
1366 | |||
1367 |
2/2✓ Branch 0 taken 1844962 times.
✓ Branch 1 taken 681 times.
|
1845643 | for (smp = begin; smp < end; smp++) { |
1368 | 1844962 | y = (1 << 6) + | |
1369 | 1844962 | MUL64(ch[dep].weighting[0], master[smp - 1 ]) + | |
1370 | 1844962 | MUL64(ch[dep].weighting[1], master[smp ]) + | |
1371 | 1844962 | MUL64(ch[dep].weighting[2], master[smp + 1 ]) + | |
1372 | 1844962 | MUL64(ch[dep].weighting[3], master[smp - 1 + t]) + | |
1373 | 1844962 | MUL64(ch[dep].weighting[4], master[smp + t]) + | |
1374 | 1844962 | MUL64(ch[dep].weighting[5], master[smp + 1 + t]); | |
1375 | |||
1376 | 1844962 | bd->raw_samples[smp] += y >> 7; | |
1377 | } | ||
1378 | } else { | ||
1379 | |||
1380 |
1/2✓ Branch 0 taken 545 times.
✗ Branch 1 not taken.
|
545 | if (begin - 1 < ctx->raw_buffer - master || |
1381 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 545 times.
|
545 | end + 1 > ctx->raw_buffer + channels * channel_size - master) { |
1382 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, | |
1383 | "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n", | ||
1384 | ✗ | master + begin - 1, master + end + 1, | |
1385 | ✗ | ctx->raw_buffer, ctx->raw_buffer + channels * channel_size); | |
1386 | ✗ | return AVERROR_INVALIDDATA; | |
1387 | } | ||
1388 | |||
1389 |
2/2✓ Branch 0 taken 1567524 times.
✓ Branch 1 taken 545 times.
|
1568069 | for (smp = begin; smp < end; smp++) { |
1390 | 1567524 | y = (1 << 6) + | |
1391 | 1567524 | MUL64(ch[dep].weighting[0], master[smp - 1]) + | |
1392 | 1567524 | MUL64(ch[dep].weighting[1], master[smp ]) + | |
1393 | 1567524 | MUL64(ch[dep].weighting[2], master[smp + 1]); | |
1394 | |||
1395 | 1567524 | bd->raw_samples[smp] += y >> 7; | |
1396 | } | ||
1397 | } | ||
1398 | } | ||
1399 | |||
1400 | 1722 | return 0; | |
1401 | } | ||
1402 | |||
1403 | |||
1404 | /** multiply two softfloats and handle the rounding off | ||
1405 | */ | ||
1406 | ✗ | static SoftFloat_IEEE754 multiply(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b) { | |
1407 | uint64_t mantissa_temp; | ||
1408 | uint64_t mask_64; | ||
1409 | int cutoff_bit_count; | ||
1410 | unsigned char last_2_bits; | ||
1411 | unsigned int mantissa; | ||
1412 | int32_t sign; | ||
1413 | ✗ | uint32_t return_val = 0; | |
1414 | ✗ | int bit_count = 48; | |
1415 | |||
1416 | ✗ | sign = a.sign ^ b.sign; | |
1417 | |||
1418 | // Multiply mantissa bits in a 64-bit register | ||
1419 | ✗ | mantissa_temp = (uint64_t)a.mant * (uint64_t)b.mant; | |
1420 | ✗ | mask_64 = (uint64_t)0x1 << 47; | |
1421 | |||
1422 | ✗ | if (!mantissa_temp) | |
1423 | ✗ | return FLOAT_0; | |
1424 | |||
1425 | // Count the valid bit count | ||
1426 | ✗ | while (!(mantissa_temp & mask_64) && mask_64) { | |
1427 | ✗ | bit_count--; | |
1428 | ✗ | mask_64 >>= 1; | |
1429 | } | ||
1430 | |||
1431 | // Round off | ||
1432 | ✗ | cutoff_bit_count = bit_count - 24; | |
1433 | ✗ | if (cutoff_bit_count > 0) { | |
1434 | ✗ | last_2_bits = (unsigned char)(((unsigned int)mantissa_temp >> (cutoff_bit_count - 1)) & 0x3 ); | |
1435 | ✗ | if ((last_2_bits == 0x3) || ((last_2_bits == 0x1) && ((unsigned int)mantissa_temp & ((0x1UL << (cutoff_bit_count - 1)) - 1)))) { | |
1436 | // Need to round up | ||
1437 | ✗ | mantissa_temp += (uint64_t)0x1 << cutoff_bit_count; | |
1438 | } | ||
1439 | } | ||
1440 | |||
1441 | ✗ | if (cutoff_bit_count >= 0) { | |
1442 | ✗ | mantissa = (unsigned int)(mantissa_temp >> cutoff_bit_count); | |
1443 | } else { | ||
1444 | ✗ | mantissa = (unsigned int)(mantissa_temp <<-cutoff_bit_count); | |
1445 | } | ||
1446 | |||
1447 | // Need one more shift? | ||
1448 | ✗ | if (mantissa & 0x01000000ul) { | |
1449 | ✗ | bit_count++; | |
1450 | ✗ | mantissa >>= 1; | |
1451 | } | ||
1452 | |||
1453 | ✗ | if (!sign) { | |
1454 | ✗ | return_val = 0x80000000U; | |
1455 | } | ||
1456 | |||
1457 | ✗ | return_val |= ((unsigned)av_clip(a.exp + b.exp + bit_count - 47, -126, 127) << 23) & 0x7F800000; | |
1458 | ✗ | return_val |= mantissa; | |
1459 | ✗ | return av_bits2sf_ieee754(return_val); | |
1460 | } | ||
1461 | |||
1462 | |||
1463 | /** Read and decode the floating point sample data | ||
1464 | */ | ||
1465 | ✗ | static int read_diff_float_data(ALSDecContext *ctx, unsigned int ra_frame) { | |
1466 | ✗ | AVCodecContext *avctx = ctx->avctx; | |
1467 | ✗ | GetBitContext *gb = &ctx->gb; | |
1468 | ✗ | SoftFloat_IEEE754 *acf = ctx->acf; | |
1469 | ✗ | int *shift_value = ctx->shift_value; | |
1470 | ✗ | int *last_shift_value = ctx->last_shift_value; | |
1471 | ✗ | int *last_acf_mantissa = ctx->last_acf_mantissa; | |
1472 | ✗ | int **raw_mantissa = ctx->raw_mantissa; | |
1473 | ✗ | int *nbits = ctx->nbits; | |
1474 | ✗ | unsigned char *larray = ctx->larray; | |
1475 | ✗ | int frame_length = ctx->cur_frame_length; | |
1476 | ✗ | SoftFloat_IEEE754 scale = av_int2sf_ieee754(0x1u, 23); | |
1477 | unsigned int partA_flag; | ||
1478 | unsigned int highest_byte; | ||
1479 | unsigned int shift_amp; | ||
1480 | uint32_t tmp_32; | ||
1481 | int use_acf; | ||
1482 | int nchars; | ||
1483 | int i; | ||
1484 | int c; | ||
1485 | long k; | ||
1486 | long nbits_aligned; | ||
1487 | unsigned long acc; | ||
1488 | unsigned long j; | ||
1489 | uint32_t sign; | ||
1490 | uint32_t e; | ||
1491 | uint32_t mantissa; | ||
1492 | |||
1493 | ✗ | skip_bits_long(gb, 32); //num_bytes_diff_float | |
1494 | ✗ | use_acf = get_bits1(gb); | |
1495 | |||
1496 | ✗ | if (ra_frame) { | |
1497 | ✗ | memset(last_acf_mantissa, 0, avctx->ch_layout.nb_channels * sizeof(*last_acf_mantissa)); | |
1498 | ✗ | memset(last_shift_value, 0, avctx->ch_layout.nb_channels * sizeof(*last_shift_value) ); | |
1499 | ✗ | ff_mlz_flush_dict(ctx->mlz); | |
1500 | } | ||
1501 | |||
1502 | ✗ | if (avctx->ch_layout.nb_channels * 8 > get_bits_left(gb)) | |
1503 | ✗ | return AVERROR_INVALIDDATA; | |
1504 | |||
1505 | ✗ | for (c = 0; c < avctx->ch_layout.nb_channels; ++c) { | |
1506 | ✗ | if (use_acf) { | |
1507 | //acf_flag | ||
1508 | ✗ | if (get_bits1(gb)) { | |
1509 | ✗ | tmp_32 = get_bits(gb, 23); | |
1510 | ✗ | last_acf_mantissa[c] = tmp_32; | |
1511 | } else { | ||
1512 | ✗ | tmp_32 = last_acf_mantissa[c]; | |
1513 | } | ||
1514 | ✗ | acf[c] = av_bits2sf_ieee754(tmp_32); | |
1515 | } else { | ||
1516 | ✗ | acf[c] = FLOAT_1; | |
1517 | } | ||
1518 | |||
1519 | ✗ | highest_byte = get_bits(gb, 2); | |
1520 | ✗ | partA_flag = get_bits1(gb); | |
1521 | ✗ | shift_amp = get_bits1(gb); | |
1522 | |||
1523 | ✗ | if (shift_amp) { | |
1524 | ✗ | shift_value[c] = get_bits(gb, 8); | |
1525 | ✗ | last_shift_value[c] = shift_value[c]; | |
1526 | } else { | ||
1527 | ✗ | shift_value[c] = last_shift_value[c]; | |
1528 | } | ||
1529 | |||
1530 | ✗ | if (partA_flag) { | |
1531 | ✗ | if (!get_bits1(gb)) { //uncompressed | |
1532 | ✗ | for (i = 0; i < frame_length; ++i) { | |
1533 | ✗ | if (ctx->raw_samples[c][i] == 0) { | |
1534 | ✗ | ctx->raw_mantissa[c][i] = get_bits_long(gb, 32); | |
1535 | } | ||
1536 | } | ||
1537 | } else { //compressed | ||
1538 | ✗ | nchars = 0; | |
1539 | ✗ | for (i = 0; i < frame_length; ++i) { | |
1540 | ✗ | if (ctx->raw_samples[c][i] == 0) { | |
1541 | ✗ | nchars += 4; | |
1542 | } | ||
1543 | } | ||
1544 | |||
1545 | ✗ | tmp_32 = ff_mlz_decompression(ctx->mlz, gb, nchars, larray); | |
1546 | ✗ | if(tmp_32 != nchars) { | |
1547 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%"PRId32", %d).\n", tmp_32, nchars); | |
1548 | ✗ | return AVERROR_INVALIDDATA; | |
1549 | } | ||
1550 | |||
1551 | ✗ | for (i = 0; i < frame_length; ++i) { | |
1552 | ✗ | ctx->raw_mantissa[c][i] = AV_RB32(larray); | |
1553 | } | ||
1554 | } | ||
1555 | } | ||
1556 | |||
1557 | //decode part B | ||
1558 | ✗ | if (highest_byte) { | |
1559 | ✗ | for (i = 0; i < frame_length; ++i) { | |
1560 | ✗ | if (ctx->raw_samples[c][i] != 0) { | |
1561 | //The following logic is taken from Tabel 14.45 and 14.46 from the ISO spec | ||
1562 | ✗ | if (av_cmp_sf_ieee754(acf[c], FLOAT_1)) { | |
1563 | ✗ | nbits[i] = 23 - av_log2(abs(ctx->raw_samples[c][i])); | |
1564 | } else { | ||
1565 | ✗ | nbits[i] = 23; | |
1566 | } | ||
1567 | ✗ | nbits[i] = FFMIN(nbits[i], highest_byte*8); | |
1568 | } | ||
1569 | } | ||
1570 | |||
1571 | ✗ | if (!get_bits1(gb)) { //uncompressed | |
1572 | ✗ | for (i = 0; i < frame_length; ++i) { | |
1573 | ✗ | if (ctx->raw_samples[c][i] != 0) { | |
1574 | ✗ | raw_mantissa[c][i] = get_bitsz(gb, nbits[i]); | |
1575 | } | ||
1576 | } | ||
1577 | } else { //compressed | ||
1578 | ✗ | nchars = 0; | |
1579 | ✗ | for (i = 0; i < frame_length; ++i) { | |
1580 | ✗ | if (ctx->raw_samples[c][i]) { | |
1581 | ✗ | nchars += (int) nbits[i] / 8; | |
1582 | ✗ | if (nbits[i] & 7) { | |
1583 | ✗ | ++nchars; | |
1584 | } | ||
1585 | } | ||
1586 | } | ||
1587 | |||
1588 | ✗ | tmp_32 = ff_mlz_decompression(ctx->mlz, gb, nchars, larray); | |
1589 | ✗ | if(tmp_32 != nchars) { | |
1590 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%"PRId32", %d).\n", tmp_32, nchars); | |
1591 | ✗ | return AVERROR_INVALIDDATA; | |
1592 | } | ||
1593 | |||
1594 | ✗ | j = 0; | |
1595 | ✗ | for (i = 0; i < frame_length; ++i) { | |
1596 | ✗ | if (ctx->raw_samples[c][i]) { | |
1597 | ✗ | if (nbits[i] & 7) { | |
1598 | ✗ | nbits_aligned = 8 * ((unsigned int)(nbits[i] / 8) + 1); | |
1599 | } else { | ||
1600 | ✗ | nbits_aligned = nbits[i]; | |
1601 | } | ||
1602 | ✗ | acc = 0; | |
1603 | ✗ | for (k = 0; k < nbits_aligned/8; ++k) { | |
1604 | ✗ | acc = (acc << 8) + larray[j++]; | |
1605 | } | ||
1606 | ✗ | acc >>= (nbits_aligned - nbits[i]); | |
1607 | ✗ | raw_mantissa[c][i] = acc; | |
1608 | } | ||
1609 | } | ||
1610 | } | ||
1611 | } | ||
1612 | |||
1613 | ✗ | for (i = 0; i < frame_length; ++i) { | |
1614 | ✗ | SoftFloat_IEEE754 pcm_sf = av_int2sf_ieee754(ctx->raw_samples[c][i], 0); | |
1615 | ✗ | pcm_sf = av_div_sf_ieee754(pcm_sf, scale); | |
1616 | |||
1617 | ✗ | if (ctx->raw_samples[c][i] != 0) { | |
1618 | ✗ | if (!av_cmp_sf_ieee754(acf[c], FLOAT_1)) { | |
1619 | ✗ | pcm_sf = multiply(acf[c], pcm_sf); | |
1620 | } | ||
1621 | |||
1622 | ✗ | sign = pcm_sf.sign; | |
1623 | ✗ | e = pcm_sf.exp; | |
1624 | ✗ | mantissa = (pcm_sf.mant | 0x800000) + raw_mantissa[c][i]; | |
1625 | |||
1626 | ✗ | while(mantissa >= 0x1000000) { | |
1627 | ✗ | e++; | |
1628 | ✗ | mantissa >>= 1; | |
1629 | } | ||
1630 | |||
1631 | ✗ | if (mantissa) e += (shift_value[c] - 127); | |
1632 | ✗ | mantissa &= 0x007fffffUL; | |
1633 | |||
1634 | ✗ | tmp_32 = (sign << 31) | ((e + EXP_BIAS) << 23) | (mantissa); | |
1635 | ✗ | ctx->raw_samples[c][i] = tmp_32; | |
1636 | } else { | ||
1637 | ✗ | ctx->raw_samples[c][i] = raw_mantissa[c][i] & 0x007fffffUL; | |
1638 | } | ||
1639 | } | ||
1640 | ✗ | align_get_bits(gb); | |
1641 | } | ||
1642 | ✗ | return 0; | |
1643 | } | ||
1644 | |||
1645 | |||
1646 | /** Read the frame data. | ||
1647 | */ | ||
1648 | 1835 | static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame) | |
1649 | { | ||
1650 | 1835 | ALSSpecificConfig *sconf = &ctx->sconf; | |
1651 | 1835 | AVCodecContext *avctx = ctx->avctx; | |
1652 | 1835 | GetBitContext *gb = &ctx->gb; | |
1653 | unsigned int div_blocks[32]; ///< block sizes. | ||
1654 | int c; | ||
1655 | unsigned int js_blocks[2]; | ||
1656 | 1835 | int channels = avctx->ch_layout.nb_channels; | |
1657 | 1835 | uint32_t bs_info = 0; | |
1658 | int ret; | ||
1659 | |||
1660 | // skip the size of the ra unit if present in the frame | ||
1661 |
3/4✓ Branch 0 taken 1486 times.
✓ Branch 1 taken 349 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1486 times.
|
1835 | if (sconf->ra_flag == RA_FLAG_FRAMES && ra_frame) |
1662 | ✗ | skip_bits_long(gb, 32); | |
1663 | |||
1664 |
4/4✓ Branch 0 taken 351 times.
✓ Branch 1 taken 1484 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 349 times.
|
1835 | if (sconf->mc_coding && sconf->joint_stereo) { |
1665 | 2 | ctx->js_switch = get_bits1(gb); | |
1666 | 2 | align_get_bits(gb); | |
1667 | } | ||
1668 | |||
1669 |
3/4✓ Branch 0 taken 351 times.
✓ Branch 1 taken 1484 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 351 times.
|
3319 | if (!sconf->mc_coding || ctx->js_switch) { |
1670 | 1484 | int independent_bs = !sconf->joint_stereo; | |
1671 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1484 times.
|
1484 | if (get_bits_left(gb) < 7*channels*ctx->num_blocks) |
1672 | ✗ | return AVERROR_INVALIDDATA; | |
1673 |
2/2✓ Branch 0 taken 2553 times.
✓ Branch 1 taken 1484 times.
|
4037 | for (c = 0; c < channels; c++) { |
1674 | 2553 | js_blocks[0] = 0; | |
1675 | 2553 | js_blocks[1] = 0; | |
1676 | |||
1677 | 2553 | get_block_sizes(ctx, div_blocks, &bs_info); | |
1678 | |||
1679 | // if joint_stereo and block_switching is set, independent decoding | ||
1680 | // is signaled via the first bit of bs_info | ||
1681 |
4/4✓ Branch 0 taken 459 times.
✓ Branch 1 taken 2094 times.
✓ Branch 2 taken 110 times.
✓ Branch 3 taken 349 times.
|
2553 | if (sconf->joint_stereo && sconf->block_switching) |
1682 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 88 times.
|
110 | if (bs_info >> 31) |
1683 | 22 | independent_bs = 2; | |
1684 | |||
1685 | // if this is the last channel, it has to be decoded independently | ||
1686 |
3/4✓ Branch 0 taken 1484 times.
✓ Branch 1 taken 1069 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1484 times.
|
2553 | if (c == channels - 1 || (c & 1)) |
1687 | 1069 | independent_bs = 1; | |
1688 | |||
1689 |
2/2✓ Branch 0 taken 2138 times.
✓ Branch 1 taken 415 times.
|
2553 | if (independent_bs) { |
1690 | 2138 | ret = decode_blocks_ind(ctx, ra_frame, c, | |
1691 | div_blocks, js_blocks); | ||
1692 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2138 times.
|
2138 | if (ret < 0) |
1693 | ✗ | return ret; | |
1694 | 2138 | independent_bs--; | |
1695 | } else { | ||
1696 | 415 | ret = decode_blocks(ctx, ra_frame, c, div_blocks, js_blocks); | |
1697 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 415 times.
|
415 | if (ret < 0) |
1698 | ✗ | return ret; | |
1699 | |||
1700 | 415 | c++; | |
1701 | } | ||
1702 | |||
1703 | // store carryover raw samples | ||
1704 | 2553 | memmove(ctx->raw_samples[c] - sconf->max_order, | |
1705 | 2553 | ctx->raw_samples[c] - sconf->max_order + sconf->frame_length, | |
1706 | 2553 | sizeof(*ctx->raw_samples[c]) * sconf->max_order); | |
1707 | 2553 | ctx->highest_decoded_channel = c; | |
1708 | } | ||
1709 | } else { // multi-channel coding | ||
1710 | 351 | ALSBlockData bd = { 0 }; | |
1711 | int b, ret; | ||
1712 | 351 | int *reverted_channels = ctx->reverted_channels; | |
1713 | 351 | unsigned int offset = 0; | |
1714 | |||
1715 |
2/2✓ Branch 0 taken 1722 times.
✓ Branch 1 taken 351 times.
|
2073 | for (c = 0; c < channels; c++) |
1716 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1722 times.
|
1722 | if (ctx->chan_data[c] < ctx->chan_data_buffer) { |
1717 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, "Invalid channel data.\n"); | |
1718 | ✗ | return AVERROR_INVALIDDATA; | |
1719 | } | ||
1720 | |||
1721 | 351 | memset(reverted_channels, 0, sizeof(*reverted_channels) * channels); | |
1722 | |||
1723 | 351 | bd.ra_block = ra_frame; | |
1724 | 351 | bd.prev_raw_samples = ctx->prev_raw_samples; | |
1725 | |||
1726 | 351 | get_block_sizes(ctx, div_blocks, &bs_info); | |
1727 | |||
1728 |
2/2✓ Branch 0 taken 351 times.
✓ Branch 1 taken 351 times.
|
702 | for (b = 0; b < ctx->num_blocks; b++) { |
1729 | 351 | bd.block_length = div_blocks[b]; | |
1730 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 351 times.
|
351 | if (bd.block_length <= 0) { |
1731 | ✗ | av_log(ctx->avctx, AV_LOG_WARNING, | |
1732 | "Invalid block length %u in channel data!\n", | ||
1733 | bd.block_length); | ||
1734 | ✗ | continue; | |
1735 | } | ||
1736 | |||
1737 |
2/2✓ Branch 0 taken 1722 times.
✓ Branch 1 taken 351 times.
|
2073 | for (c = 0; c < channels; c++) { |
1738 | 1722 | bd.const_block = ctx->const_block + c; | |
1739 | 1722 | bd.shift_lsbs = ctx->shift_lsbs + c; | |
1740 | 1722 | bd.opt_order = ctx->opt_order + c; | |
1741 | 1722 | bd.store_prev_samples = ctx->store_prev_samples + c; | |
1742 | 1722 | bd.use_ltp = ctx->use_ltp + c; | |
1743 | 1722 | bd.ltp_lag = ctx->ltp_lag + c; | |
1744 | 1722 | bd.ltp_gain = ctx->ltp_gain[c]; | |
1745 | 1722 | bd.lpc_cof = ctx->lpc_cof[c]; | |
1746 | 1722 | bd.quant_cof = ctx->quant_cof[c]; | |
1747 | 1722 | bd.raw_samples = ctx->raw_samples[c] + offset; | |
1748 | 1722 | bd.raw_other = NULL; | |
1749 | |||
1750 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1722 times.
|
1722 | if ((ret = read_block(ctx, &bd)) < 0) |
1751 | ✗ | return ret; | |
1752 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1722 times.
|
1722 | if ((ret = read_channel_data(ctx, ctx->chan_data[c], c)) < 0) |
1753 | ✗ | return ret; | |
1754 | } | ||
1755 | |||
1756 |
2/2✓ Branch 0 taken 1722 times.
✓ Branch 1 taken 351 times.
|
2073 | for (c = 0; c < channels; c++) { |
1757 | 1722 | ret = revert_channel_correlation(ctx, &bd, ctx->chan_data, | |
1758 | reverted_channels, offset, c); | ||
1759 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1722 times.
|
1722 | if (ret < 0) |
1760 | ✗ | return ret; | |
1761 | } | ||
1762 |
2/2✓ Branch 0 taken 1722 times.
✓ Branch 1 taken 351 times.
|
2073 | for (c = 0; c < channels; c++) { |
1763 | 1722 | bd.const_block = ctx->const_block + c; | |
1764 | 1722 | bd.shift_lsbs = ctx->shift_lsbs + c; | |
1765 | 1722 | bd.opt_order = ctx->opt_order + c; | |
1766 | 1722 | bd.store_prev_samples = ctx->store_prev_samples + c; | |
1767 | 1722 | bd.use_ltp = ctx->use_ltp + c; | |
1768 | 1722 | bd.ltp_lag = ctx->ltp_lag + c; | |
1769 | 1722 | bd.ltp_gain = ctx->ltp_gain[c]; | |
1770 | 1722 | bd.lpc_cof = ctx->lpc_cof[c]; | |
1771 | 1722 | bd.quant_cof = ctx->quant_cof[c]; | |
1772 | 1722 | bd.raw_samples = ctx->raw_samples[c] + offset; | |
1773 | |||
1774 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1722 times.
|
1722 | if ((ret = decode_block(ctx, &bd)) < 0) |
1775 | ✗ | return ret; | |
1776 | |||
1777 | 1722 | ctx->highest_decoded_channel = FFMAX(ctx->highest_decoded_channel, c); | |
1778 | } | ||
1779 | |||
1780 | 351 | memset(reverted_channels, 0, channels * sizeof(*reverted_channels)); | |
1781 | 351 | offset += div_blocks[b]; | |
1782 | 351 | bd.ra_block = 0; | |
1783 | } | ||
1784 | |||
1785 | // store carryover raw samples | ||
1786 |
2/2✓ Branch 0 taken 1722 times.
✓ Branch 1 taken 351 times.
|
2073 | for (c = 0; c < channels; c++) |
1787 | 1722 | memmove(ctx->raw_samples[c] - sconf->max_order, | |
1788 | 1722 | ctx->raw_samples[c] - sconf->max_order + sconf->frame_length, | |
1789 | 1722 | sizeof(*ctx->raw_samples[c]) * sconf->max_order); | |
1790 | } | ||
1791 | |||
1792 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1835 times.
|
1835 | if (sconf->floating) { |
1793 | ✗ | read_diff_float_data(ctx, ra_frame); | |
1794 | } | ||
1795 | |||
1796 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1835 times.
|
1835 | if (get_bits_left(gb) < 0) { |
1797 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, "Overread %d\n", -get_bits_left(gb)); | |
1798 | ✗ | return AVERROR_INVALIDDATA; | |
1799 | } | ||
1800 | |||
1801 | 1835 | return 0; | |
1802 | } | ||
1803 | |||
1804 | |||
1805 | /** Decode an ALS frame. | ||
1806 | */ | ||
1807 | 1835 | static int decode_frame(AVCodecContext *avctx, AVFrame *frame, | |
1808 | int *got_frame_ptr, AVPacket *avpkt) | ||
1809 | { | ||
1810 | 1835 | ALSDecContext *ctx = avctx->priv_data; | |
1811 | 1835 | ALSSpecificConfig *sconf = &ctx->sconf; | |
1812 | 1835 | const uint8_t *buffer = avpkt->data; | |
1813 | 1835 | int buffer_size = avpkt->size; | |
1814 | int invalid_frame, ret; | ||
1815 | 1835 | int channels = avctx->ch_layout.nb_channels; | |
1816 | unsigned int c, sample, ra_frame, bytes_read, shift; | ||
1817 | |||
1818 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1835 times.
|
1835 | if ((ret = init_get_bits8(&ctx->gb, buffer, buffer_size)) < 0) |
1819 | ✗ | return ret; | |
1820 | |||
1821 | // In the case that the distance between random access frames is set to zero | ||
1822 | // (sconf->ra_distance == 0) no frame is treated as a random access frame. | ||
1823 | // For the first frame, if prediction is used, all samples used from the | ||
1824 | // previous frame are assumed to be zero. | ||
1825 |
3/4✓ Branch 0 taken 349 times.
✓ Branch 1 taken 1486 times.
✓ Branch 2 taken 349 times.
✗ Branch 3 not taken.
|
1835 | ra_frame = sconf->ra_distance && !(ctx->frame_id % sconf->ra_distance); |
1826 | |||
1827 | // the last frame to decode might have a different length | ||
1828 |
1/2✓ Branch 0 taken 1835 times.
✗ Branch 1 not taken.
|
1835 | if (sconf->samples != 0xFFFFFFFF) |
1829 | 1835 | ctx->cur_frame_length = FFMIN(sconf->samples - ctx->frame_id * (uint64_t) sconf->frame_length, | |
1830 | sconf->frame_length); | ||
1831 | else | ||
1832 | ✗ | ctx->cur_frame_length = sconf->frame_length; | |
1833 | |||
1834 | 1835 | ctx->highest_decoded_channel = -1; | |
1835 | // decode the frame data | ||
1836 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1835 times.
|
1835 | if ((invalid_frame = read_frame_data(ctx, ra_frame)) < 0) |
1837 | ✗ | av_log(ctx->avctx, AV_LOG_WARNING, | |
1838 | "Reading frame data failed. Skipping RA unit.\n"); | ||
1839 | |||
1840 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1835 times.
|
1835 | if (ctx->highest_decoded_channel == -1) { |
1841 | ✗ | av_log(ctx->avctx, AV_LOG_WARNING, | |
1842 | "No channel data decoded.\n"); | ||
1843 | ✗ | return AVERROR_INVALIDDATA; | |
1844 | } | ||
1845 | |||
1846 | 1835 | ctx->frame_id++; | |
1847 | |||
1848 | /* get output buffer */ | ||
1849 | 1835 | frame->nb_samples = ctx->cur_frame_length; | |
1850 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1835 times.
|
1835 | if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
1851 | ✗ | return ret; | |
1852 | |||
1853 | // transform decoded frame into output format | ||
1854 | #define INTERLEAVE_OUTPUT(bps) \ | ||
1855 | { \ | ||
1856 | int##bps##_t *dest = (int##bps##_t*)frame->data[0]; \ | ||
1857 | int32_t *raw_samples = ctx->raw_samples[0]; \ | ||
1858 | int raw_step = channels > 1 ? ctx->raw_samples[1] - raw_samples : 1; \ | ||
1859 | shift = bps - ctx->avctx->bits_per_raw_sample; \ | ||
1860 | if (!ctx->cs_switch) { \ | ||
1861 | for (sample = 0; sample < ctx->cur_frame_length; sample++) \ | ||
1862 | for (c = 0; c < channels; c++) \ | ||
1863 | *dest++ = raw_samples[c*raw_step + sample] * (1U << shift); \ | ||
1864 | } else { \ | ||
1865 | for (sample = 0; sample < ctx->cur_frame_length; sample++) \ | ||
1866 | for (c = 0; c < channels; c++) \ | ||
1867 | *dest++ = raw_samples[sconf->chan_pos[c]*raw_step + sample] * (1U << shift);\ | ||
1868 | } \ | ||
1869 | } | ||
1870 | |||
1871 |
1/2✓ Branch 0 taken 1835 times.
✗ Branch 1 not taken.
|
1835 | if (ctx->avctx->bits_per_raw_sample <= 16) { |
1872 |
6/12✓ Branch 0 taken 1835 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1835 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11722716 times.
✓ Branch 5 taken 4290048 times.
✓ Branch 6 taken 4290048 times.
✓ Branch 7 taken 1835 times.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
16014599 | INTERLEAVE_OUTPUT(16) |
1873 | } else { | ||
1874 | ✗ | INTERLEAVE_OUTPUT(32) | |
1875 | } | ||
1876 | |||
1877 | // update CRC | ||
1878 |
2/4✓ Branch 0 taken 1835 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1835 times.
|
1835 | if (sconf->crc_enabled && (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) { |
1879 | ✗ | int swap = HAVE_BIGENDIAN != sconf->msb_first; | |
1880 | |||
1881 | ✗ | if (ctx->avctx->bits_per_raw_sample == 24) { | |
1882 | ✗ | int32_t *src = (int32_t *)frame->data[0]; | |
1883 | |||
1884 | ✗ | for (sample = 0; | |
1885 | ✗ | sample < ctx->cur_frame_length * channels; | |
1886 | ✗ | sample++) { | |
1887 | int32_t v; | ||
1888 | |||
1889 | ✗ | if (swap) | |
1890 | ✗ | v = av_bswap32(src[sample]); | |
1891 | else | ||
1892 | ✗ | v = src[sample]; | |
1893 | if (!HAVE_BIGENDIAN) | ||
1894 | ✗ | v >>= 8; | |
1895 | |||
1896 | ✗ | ctx->crc = av_crc(ctx->crc_table, ctx->crc, (uint8_t*)(&v), 3); | |
1897 | } | ||
1898 | } else { | ||
1899 | uint8_t *crc_source; | ||
1900 | |||
1901 | ✗ | if (swap) { | |
1902 | ✗ | if (ctx->avctx->bits_per_raw_sample <= 16) { | |
1903 | ✗ | int16_t *src = (int16_t*) frame->data[0]; | |
1904 | ✗ | int16_t *dest = (int16_t*) ctx->crc_buffer; | |
1905 | ✗ | for (sample = 0; | |
1906 | ✗ | sample < ctx->cur_frame_length * channels; | |
1907 | ✗ | sample++) | |
1908 | ✗ | *dest++ = av_bswap16(src[sample]); | |
1909 | } else { | ||
1910 | ✗ | ctx->bdsp.bswap_buf((uint32_t *) ctx->crc_buffer, | |
1911 | ✗ | (uint32_t *) frame->data[0], | |
1912 | ✗ | ctx->cur_frame_length * channels); | |
1913 | } | ||
1914 | ✗ | crc_source = ctx->crc_buffer; | |
1915 | } else { | ||
1916 | ✗ | crc_source = frame->data[0]; | |
1917 | } | ||
1918 | |||
1919 | ✗ | ctx->crc = av_crc(ctx->crc_table, ctx->crc, crc_source, | |
1920 | ✗ | ctx->cur_frame_length * channels * | |
1921 | ✗ | av_get_bytes_per_sample(avctx->sample_fmt)); | |
1922 | } | ||
1923 | |||
1924 | |||
1925 | // check CRC sums if this is the last frame | ||
1926 | ✗ | if (ctx->cur_frame_length != sconf->frame_length && | |
1927 | ✗ | ctx->crc_org != ctx->crc) { | |
1928 | ✗ | av_log(avctx, AV_LOG_ERROR, "CRC error.\n"); | |
1929 | ✗ | if (avctx->err_recognition & AV_EF_EXPLODE) | |
1930 | ✗ | return AVERROR_INVALIDDATA; | |
1931 | } | ||
1932 | } | ||
1933 | |||
1934 | 1835 | *got_frame_ptr = 1; | |
1935 | |||
1936 |
1/2✓ Branch 0 taken 1835 times.
✗ Branch 1 not taken.
|
1835 | bytes_read = invalid_frame ? buffer_size : |
1937 | 1835 | (get_bits_count(&ctx->gb) + 7) >> 3; | |
1938 | |||
1939 | 1835 | return bytes_read; | |
1940 | } | ||
1941 | |||
1942 | |||
1943 | /** Uninitialize the ALS decoder. | ||
1944 | */ | ||
1945 | 14 | static av_cold int decode_end(AVCodecContext *avctx) | |
1946 | { | ||
1947 | 14 | ALSDecContext *ctx = avctx->priv_data; | |
1948 | int i; | ||
1949 | |||
1950 | 14 | av_freep(&ctx->sconf.chan_pos); | |
1951 | |||
1952 | 14 | ff_bgmc_end(&ctx->bgmc_lut, &ctx->bgmc_lut_status); | |
1953 | |||
1954 | 14 | av_freep(&ctx->const_block); | |
1955 | 14 | av_freep(&ctx->shift_lsbs); | |
1956 | 14 | av_freep(&ctx->opt_order); | |
1957 | 14 | av_freep(&ctx->store_prev_samples); | |
1958 | 14 | av_freep(&ctx->use_ltp); | |
1959 | 14 | av_freep(&ctx->ltp_lag); | |
1960 | 14 | av_freep(&ctx->ltp_gain); | |
1961 | 14 | av_freep(&ctx->ltp_gain_buffer); | |
1962 | 14 | av_freep(&ctx->quant_cof); | |
1963 | 14 | av_freep(&ctx->lpc_cof); | |
1964 | 14 | av_freep(&ctx->quant_cof_buffer); | |
1965 | 14 | av_freep(&ctx->lpc_cof_buffer); | |
1966 | 14 | av_freep(&ctx->lpc_cof_reversed_buffer); | |
1967 | 14 | av_freep(&ctx->prev_raw_samples); | |
1968 | 14 | av_freep(&ctx->raw_samples); | |
1969 | 14 | av_freep(&ctx->raw_buffer); | |
1970 | 14 | av_freep(&ctx->chan_data); | |
1971 | 14 | av_freep(&ctx->chan_data_buffer); | |
1972 | 14 | av_freep(&ctx->reverted_channels); | |
1973 | 14 | av_freep(&ctx->crc_buffer); | |
1974 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (ctx->mlz) { |
1975 | ✗ | av_freep(&ctx->mlz->dict); | |
1976 | ✗ | av_freep(&ctx->mlz); | |
1977 | } | ||
1978 | 14 | av_freep(&ctx->acf); | |
1979 | 14 | av_freep(&ctx->last_acf_mantissa); | |
1980 | 14 | av_freep(&ctx->shift_value); | |
1981 | 14 | av_freep(&ctx->last_shift_value); | |
1982 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (ctx->raw_mantissa) { |
1983 | ✗ | for (i = 0; i < avctx->ch_layout.nb_channels; i++) { | |
1984 | ✗ | av_freep(&ctx->raw_mantissa[i]); | |
1985 | } | ||
1986 | ✗ | av_freep(&ctx->raw_mantissa); | |
1987 | } | ||
1988 | 14 | av_freep(&ctx->larray); | |
1989 | 14 | av_freep(&ctx->nbits); | |
1990 | |||
1991 | 14 | return 0; | |
1992 | } | ||
1993 | |||
1994 | |||
1995 | /** Initialize the ALS decoder. | ||
1996 | */ | ||
1997 | 14 | static av_cold int decode_init(AVCodecContext *avctx) | |
1998 | { | ||
1999 | unsigned int c; | ||
2000 | unsigned int channel_size; | ||
2001 | int num_buffers, ret; | ||
2002 | int channels; | ||
2003 | 14 | ALSDecContext *ctx = avctx->priv_data; | |
2004 | 14 | ALSSpecificConfig *sconf = &ctx->sconf; | |
2005 | 14 | ctx->avctx = avctx; | |
2006 | |||
2007 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (!avctx->extradata) { |
2008 | ✗ | av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata.\n"); | |
2009 | ✗ | return AVERROR_INVALIDDATA; | |
2010 | } | ||
2011 | |||
2012 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
|
14 | if ((ret = read_specific_config(ctx)) < 0) { |
2013 | ✗ | av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n"); | |
2014 | ✗ | return ret; | |
2015 | } | ||
2016 | 14 | channels = avctx->ch_layout.nb_channels; | |
2017 | |||
2018 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
|
14 | if ((ret = check_specific_config(ctx)) < 0) { |
2019 | ✗ | return ret; | |
2020 | } | ||
2021 | |||
2022 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 10 times.
|
14 | if (sconf->bgmc) { |
2023 | 4 | ret = ff_bgmc_init(avctx, &ctx->bgmc_lut, &ctx->bgmc_lut_status); | |
2024 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ret < 0) |
2025 | ✗ | return ret; | |
2026 | } | ||
2027 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (sconf->floating) { |
2028 | ✗ | avctx->sample_fmt = AV_SAMPLE_FMT_FLT; | |
2029 | ✗ | avctx->bits_per_raw_sample = 32; | |
2030 | } else { | ||
2031 | 28 | avctx->sample_fmt = sconf->resolution > 1 | |
2032 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | ? AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16; |
2033 | 14 | avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8; | |
2034 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (avctx->bits_per_raw_sample > 32) { |
2035 | ✗ | av_log(avctx, AV_LOG_ERROR, "Bits per raw sample %d larger than 32.\n", | |
2036 | avctx->bits_per_raw_sample); | ||
2037 | ✗ | return AVERROR_INVALIDDATA; | |
2038 | } | ||
2039 | } | ||
2040 | |||
2041 | // set maximum Rice parameter for progressive decoding based on resolution | ||
2042 | // This is not specified in 14496-3 but actually done by the reference | ||
2043 | // codec RM22 revision 2. | ||
2044 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | ctx->s_max = sconf->resolution > 1 ? 31 : 15; |
2045 | |||
2046 | // set lag value for long-term prediction | ||
2047 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | ctx->ltp_lag_length = 8 + (avctx->sample_rate >= 96000) + |
2048 | 14 | (avctx->sample_rate >= 192000); | |
2049 | |||
2050 | // allocate quantized parcor coefficient buffer | ||
2051 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 10 times.
|
14 | num_buffers = sconf->mc_coding ? channels : 1; |
2052 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (num_buffers * (uint64_t)num_buffers > INT_MAX) // protect chan_data_buffer allocation |
2053 | ✗ | return AVERROR_INVALIDDATA; | |
2054 | |||
2055 | 14 | ctx->quant_cof = av_malloc_array(num_buffers, sizeof(*ctx->quant_cof)); | |
2056 | 14 | ctx->lpc_cof = av_malloc_array(num_buffers, sizeof(*ctx->lpc_cof)); | |
2057 | 14 | ctx->quant_cof_buffer = av_malloc_array(num_buffers * sconf->max_order, | |
2058 | sizeof(*ctx->quant_cof_buffer)); | ||
2059 | 14 | ctx->lpc_cof_buffer = av_malloc_array(num_buffers * sconf->max_order, | |
2060 | sizeof(*ctx->lpc_cof_buffer)); | ||
2061 | 14 | ctx->lpc_cof_reversed_buffer = av_malloc_array(sconf->max_order, | |
2062 | sizeof(*ctx->lpc_cof_buffer)); | ||
2063 | |||
2064 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
|
14 | if (!ctx->quant_cof || !ctx->lpc_cof || |
2065 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
|
14 | !ctx->quant_cof_buffer || !ctx->lpc_cof_buffer || |
2066 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | !ctx->lpc_cof_reversed_buffer) { |
2067 | ✗ | av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); | |
2068 | ✗ | return AVERROR(ENOMEM); | |
2069 | } | ||
2070 | |||
2071 | // assign quantized parcor coefficient buffers | ||
2072 |
2/2✓ Branch 0 taken 1038 times.
✓ Branch 1 taken 14 times.
|
1052 | for (c = 0; c < num_buffers; c++) { |
2073 | 1038 | ctx->quant_cof[c] = ctx->quant_cof_buffer + c * sconf->max_order; | |
2074 | 1038 | ctx->lpc_cof[c] = ctx->lpc_cof_buffer + c * sconf->max_order; | |
2075 | } | ||
2076 | |||
2077 | // allocate and assign lag and gain data buffer for ltp mode | ||
2078 | 14 | ctx->const_block = av_malloc_array(num_buffers, sizeof(*ctx->const_block)); | |
2079 | 14 | ctx->shift_lsbs = av_malloc_array(num_buffers, sizeof(*ctx->shift_lsbs)); | |
2080 | 14 | ctx->opt_order = av_malloc_array(num_buffers, sizeof(*ctx->opt_order)); | |
2081 | 14 | ctx->store_prev_samples = av_malloc_array(num_buffers, sizeof(*ctx->store_prev_samples)); | |
2082 | 14 | ctx->use_ltp = av_calloc(num_buffers, sizeof(*ctx->use_ltp)); | |
2083 | 14 | ctx->ltp_lag = av_malloc_array(num_buffers, sizeof(*ctx->ltp_lag)); | |
2084 | 14 | ctx->ltp_gain = av_malloc_array(num_buffers, sizeof(*ctx->ltp_gain)); | |
2085 | 14 | ctx->ltp_gain_buffer = av_malloc_array(num_buffers * 5, sizeof(*ctx->ltp_gain_buffer)); | |
2086 | |||
2087 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
|
14 | if (!ctx->const_block || !ctx->shift_lsbs || |
2088 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
|
14 | !ctx->opt_order || !ctx->store_prev_samples || |
2089 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
|
14 | !ctx->use_ltp || !ctx->ltp_lag || |
2090 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14 times.
|
14 | !ctx->ltp_gain || !ctx->ltp_gain_buffer) { |
2091 | ✗ | av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); | |
2092 | ✗ | return AVERROR(ENOMEM); | |
2093 | } | ||
2094 | |||
2095 |
2/2✓ Branch 0 taken 1038 times.
✓ Branch 1 taken 14 times.
|
1052 | for (c = 0; c < num_buffers; c++) |
2096 | 1038 | ctx->ltp_gain[c] = ctx->ltp_gain_buffer + c * 5; | |
2097 | |||
2098 | // allocate and assign channel data buffer for mcc mode | ||
2099 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 10 times.
|
14 | if (sconf->mc_coding) { |
2100 | 4 | ctx->chan_data_buffer = av_calloc(num_buffers * num_buffers, | |
2101 | sizeof(*ctx->chan_data_buffer)); | ||
2102 | 4 | ctx->chan_data = av_calloc(num_buffers, sizeof(*ctx->chan_data)); | |
2103 | 4 | ctx->reverted_channels = av_malloc_array(num_buffers, | |
2104 | sizeof(*ctx->reverted_channels)); | ||
2105 | |||
2106 |
3/6✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4 times.
|
4 | if (!ctx->chan_data_buffer || !ctx->chan_data || !ctx->reverted_channels) { |
2107 | ✗ | av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); | |
2108 | ✗ | return AVERROR(ENOMEM); | |
2109 | } | ||
2110 | |||
2111 |
2/2✓ Branch 0 taken 1028 times.
✓ Branch 1 taken 4 times.
|
1032 | for (c = 0; c < num_buffers; c++) |
2112 | 1028 | ctx->chan_data[c] = ctx->chan_data_buffer + c * num_buffers; | |
2113 | } else { | ||
2114 | 10 | ctx->chan_data = NULL; | |
2115 | 10 | ctx->chan_data_buffer = NULL; | |
2116 | 10 | ctx->reverted_channels = NULL; | |
2117 | } | ||
2118 | |||
2119 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (sconf->floating) { |
2120 | ✗ | ctx->acf = av_malloc_array(channels, sizeof(*ctx->acf)); | |
2121 | ✗ | ctx->shift_value = av_calloc(channels, sizeof(*ctx->shift_value)); | |
2122 | ✗ | ctx->last_shift_value = av_calloc(channels, sizeof(*ctx->last_shift_value)); | |
2123 | ✗ | ctx->last_acf_mantissa = av_calloc(channels, sizeof(*ctx->last_acf_mantissa)); | |
2124 | ✗ | ctx->raw_mantissa = av_calloc(channels, sizeof(*ctx->raw_mantissa)); | |
2125 | |||
2126 | ✗ | ctx->larray = av_malloc_array(ctx->cur_frame_length * 4, sizeof(*ctx->larray)); | |
2127 | ✗ | ctx->nbits = av_malloc_array(ctx->cur_frame_length, sizeof(*ctx->nbits)); | |
2128 | ✗ | ctx->mlz = av_mallocz(sizeof(*ctx->mlz)); | |
2129 | |||
2130 | ✗ | if (!ctx->larray || !ctx->nbits || !ctx->mlz || !ctx->acf || !ctx->shift_value | |
2131 | ✗ | || !ctx->last_shift_value || !ctx->last_acf_mantissa || !ctx->raw_mantissa) { | |
2132 | ✗ | av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); | |
2133 | ✗ | return AVERROR(ENOMEM); | |
2134 | } | ||
2135 | |||
2136 | ✗ | ret = ff_mlz_init_dict(avctx, ctx->mlz); | |
2137 | ✗ | if (ret < 0) | |
2138 | ✗ | return ret; | |
2139 | ✗ | ff_mlz_flush_dict(ctx->mlz); | |
2140 | |||
2141 | ✗ | for (c = 0; c < channels; ++c) { | |
2142 | ✗ | ctx->raw_mantissa[c] = av_calloc(ctx->cur_frame_length, sizeof(**ctx->raw_mantissa)); | |
2143 | ✗ | if (!ctx->raw_mantissa[c]) { | |
2144 | ✗ | av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); | |
2145 | ✗ | return AVERROR(ENOMEM); | |
2146 | } | ||
2147 | } | ||
2148 | } | ||
2149 | |||
2150 | 14 | channel_size = sconf->frame_length + sconf->max_order; | |
2151 | |||
2152 | // allocate previous raw sample buffer | ||
2153 | 14 | ctx->prev_raw_samples = av_malloc_array(sconf->max_order, sizeof(*ctx->prev_raw_samples)); | |
2154 | 14 | ctx->raw_buffer = av_calloc(channels * channel_size, sizeof(*ctx->raw_buffer)); | |
2155 | 14 | ctx->raw_samples = av_malloc_array(channels, sizeof(*ctx->raw_samples)); | |
2156 |
3/6✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 14 times.
|
14 | if (!ctx->prev_raw_samples || !ctx->raw_buffer|| !ctx->raw_samples) { |
2157 | ✗ | av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); | |
2158 | ✗ | return AVERROR(ENOMEM); | |
2159 | } | ||
2160 | |||
2161 | // assign raw samples buffers | ||
2162 | 14 | ctx->raw_samples[0] = ctx->raw_buffer + sconf->max_order; | |
2163 |
2/2✓ Branch 0 taken 1034 times.
✓ Branch 1 taken 14 times.
|
1048 | for (c = 1; c < channels; c++) |
2164 | 1034 | ctx->raw_samples[c] = ctx->raw_samples[c - 1] + channel_size; | |
2165 | |||
2166 | // allocate crc buffer | ||
2167 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
14 | if (HAVE_BIGENDIAN != sconf->msb_first && sconf->crc_enabled && |
2168 | ✗ | (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) { | |
2169 | ✗ | ctx->crc_buffer = av_malloc_array(ctx->cur_frame_length * | |
2170 | ✗ | channels * | |
2171 | ✗ | av_get_bytes_per_sample(avctx->sample_fmt), | |
2172 | sizeof(*ctx->crc_buffer)); | ||
2173 | ✗ | if (!ctx->crc_buffer) { | |
2174 | ✗ | av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); | |
2175 | ✗ | return AVERROR(ENOMEM); | |
2176 | } | ||
2177 | } | ||
2178 | |||
2179 | 14 | ff_bswapdsp_init(&ctx->bdsp); | |
2180 | |||
2181 | 14 | return 0; | |
2182 | } | ||
2183 | |||
2184 | |||
2185 | /** Flush (reset) the frame ID after seeking. | ||
2186 | */ | ||
2187 | ✗ | static av_cold void flush(AVCodecContext *avctx) | |
2188 | { | ||
2189 | ✗ | ALSDecContext *ctx = avctx->priv_data; | |
2190 | |||
2191 | ✗ | ctx->frame_id = 0; | |
2192 | ✗ | } | |
2193 | |||
2194 | static const AVOption options[] = { | ||
2195 | { "max_order", "Sets the maximum order (ALS simple profile allows max 15)", offsetof(ALSDecContext, user_max_order), AV_OPT_TYPE_INT, { .i64 = 1023 }, 0, 1023, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM }, | ||
2196 | { NULL } | ||
2197 | }; | ||
2198 | |||
2199 | static const AVClass als_class = { | ||
2200 | .class_name = "als", | ||
2201 | .item_name = av_default_item_name, | ||
2202 | .option = options, | ||
2203 | .version = LIBAVUTIL_VERSION_INT, | ||
2204 | }; | ||
2205 | |||
2206 | const FFCodec ff_als_decoder = { | ||
2207 | .p.name = "als", | ||
2208 | CODEC_LONG_NAME("MPEG-4 Audio Lossless Coding (ALS)"), | ||
2209 | .p.type = AVMEDIA_TYPE_AUDIO, | ||
2210 | .p.id = AV_CODEC_ID_MP4ALS, | ||
2211 | .priv_data_size = sizeof(ALSDecContext), | ||
2212 | .init = decode_init, | ||
2213 | .close = decode_end, | ||
2214 | FF_CODEC_DECODE_CB(decode_frame), | ||
2215 | .p.priv_class = &als_class, | ||
2216 | .flush = flush, | ||
2217 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF, | ||
2218 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, | ||
2219 | }; | ||
2220 |