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