3 * Copyright (c) 2009 Thilo Borgmann <thilo.borgmann _at_ mail.de>
5 * This file is part of FFmpeg.
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.
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.
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
25 * @author Thilo Borgmann <thilo.borgmann _at_ mail.de>
33 #include "mpeg4audio.h"
34 #include "bytestream.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/crc.h"
43 /** Rice parameters and corresponding index offsets for decoding the
44 * indices of scaled PARCOR values. The table chosen is set globally
45 * by the encoder and stored in ALSSpecificConfig.
47 static const int8_t parcor_rice_table
[3][20][2] = {
48 { {-52, 4}, {-29, 5}, {-31, 4}, { 19, 4}, {-16, 4},
49 { 12, 3}, { -7, 3}, { 9, 3}, { -5, 3}, { 6, 3},
50 { -4, 3}, { 3, 3}, { -3, 2}, { 3, 2}, { -2, 2},
51 { 3, 2}, { -1, 2}, { 2, 2}, { -1, 2}, { 2, 2} },
52 { {-58, 3}, {-42, 4}, {-46, 4}, { 37, 5}, {-36, 4},
53 { 29, 4}, {-29, 4}, { 25, 4}, {-23, 4}, { 20, 4},
54 {-17, 4}, { 16, 4}, {-12, 4}, { 12, 3}, {-10, 4},
55 { 7, 3}, { -4, 4}, { 3, 3}, { -1, 3}, { 1, 3} },
56 { {-59, 3}, {-45, 5}, {-50, 4}, { 38, 4}, {-39, 4},
57 { 32, 4}, {-30, 4}, { 25, 3}, {-23, 3}, { 20, 3},
58 {-20, 3}, { 16, 3}, {-13, 3}, { 10, 3}, { -7, 3},
59 { 3, 3}, { 0, 3}, { -1, 3}, { 2, 3}, { -1, 2} }
63 /** Scaled PARCOR values used for the first two PARCOR coefficients.
64 * To be indexed by the Rice coded indices.
65 * Generated by: parcor_scaled_values[i] = 32 + ((i * (i+1)) << 7) - (1 << 20)
66 * Actual values are divided by 32 in order to be stored in 16 bits.
68 static const int16_t parcor_scaled_values
[] = {
69 -1048544 / 32, -1048288 / 32, -1047776 / 32, -1047008 / 32,
70 -1045984 / 32, -1044704 / 32, -1043168 / 32, -1041376 / 32,
71 -1039328 / 32, -1037024 / 32, -1034464 / 32, -1031648 / 32,
72 -1028576 / 32, -1025248 / 32, -1021664 / 32, -1017824 / 32,
73 -1013728 / 32, -1009376 / 32, -1004768 / 32, -999904 / 32,
74 -994784 / 32, -989408 / 32, -983776 / 32, -977888 / 32,
75 -971744 / 32, -965344 / 32, -958688 / 32, -951776 / 32,
76 -944608 / 32, -937184 / 32, -929504 / 32, -921568 / 32,
77 -913376 / 32, -904928 / 32, -896224 / 32, -887264 / 32,
78 -878048 / 32, -868576 / 32, -858848 / 32, -848864 / 32,
79 -838624 / 32, -828128 / 32, -817376 / 32, -806368 / 32,
80 -795104 / 32, -783584 / 32, -771808 / 32, -759776 / 32,
81 -747488 / 32, -734944 / 32, -722144 / 32, -709088 / 32,
82 -695776 / 32, -682208 / 32, -668384 / 32, -654304 / 32,
83 -639968 / 32, -625376 / 32, -610528 / 32, -595424 / 32,
84 -580064 / 32, -564448 / 32, -548576 / 32, -532448 / 32,
85 -516064 / 32, -499424 / 32, -482528 / 32, -465376 / 32,
86 -447968 / 32, -430304 / 32, -412384 / 32, -394208 / 32,
87 -375776 / 32, -357088 / 32, -338144 / 32, -318944 / 32,
88 -299488 / 32, -279776 / 32, -259808 / 32, -239584 / 32,
89 -219104 / 32, -198368 / 32, -177376 / 32, -156128 / 32,
90 -134624 / 32, -112864 / 32, -90848 / 32, -68576 / 32,
91 -46048 / 32, -23264 / 32, -224 / 32, 23072 / 32,
92 46624 / 32, 70432 / 32, 94496 / 32, 118816 / 32,
93 143392 / 32, 168224 / 32, 193312 / 32, 218656 / 32,
94 244256 / 32, 270112 / 32, 296224 / 32, 322592 / 32,
95 349216 / 32, 376096 / 32, 403232 / 32, 430624 / 32,
96 458272 / 32, 486176 / 32, 514336 / 32, 542752 / 32,
97 571424 / 32, 600352 / 32, 629536 / 32, 658976 / 32,
98 688672 / 32, 718624 / 32, 748832 / 32, 779296 / 32,
99 810016 / 32, 840992 / 32, 872224 / 32, 903712 / 32,
100 935456 / 32, 967456 / 32, 999712 / 32, 1032224 / 32
104 /** Gain values of p(0) for long-term prediction.
105 * To be indexed by the Rice coded indices.
107 static const uint8_t ltp_gain_values
[4][4] = {
115 /** Inter-channel weighting factors for multi-channel correlation.
116 * To be indexed by the Rice coded indices.
118 static const int16_t mcc_weightings
[] = {
119 204, 192, 179, 166, 153, 140, 128, 115,
120 102, 89, 76, 64, 51, 38, 25, 12,
121 0, -12, -25, -38, -51, -64, -76, -89,
122 -102, -115, -128, -140, -153, -166, -179, -192
126 /** Tail codes used in arithmetic coding using block Gilbert-Moore codes.
128 static const uint8_t tail_code
[16][6] = {
129 { 74, 44, 25, 13, 7, 3},
130 { 68, 42, 24, 13, 7, 3},
131 { 58, 39, 23, 13, 7, 3},
132 {126, 70, 37, 19, 10, 5},
133 {132, 70, 37, 20, 10, 5},
134 {124, 70, 38, 20, 10, 5},
135 {120, 69, 37, 20, 11, 5},
136 {116, 67, 37, 20, 11, 5},
137 {108, 66, 36, 20, 10, 5},
138 {102, 62, 36, 20, 10, 5},
139 { 88, 58, 34, 19, 10, 5},
140 {162, 89, 49, 25, 13, 7},
141 {156, 87, 49, 26, 14, 7},
142 {150, 86, 47, 26, 14, 7},
143 {142, 84, 47, 26, 14, 7},
144 {131, 79, 46, 26, 14, 7}
156 uint32_t samples
; ///< number of samples, 0xFFFFFFFF if unknown
157 int resolution
; ///< 000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
158 int floating
; ///< 1 = IEEE 32-bit floating-point, 0 = integer
159 int msb_first
; ///< 1 = original CRC calculated on big-endian system, 0 = little-endian
160 int frame_length
; ///< frame length for each frame (last frame may differ)
161 int ra_distance
; ///< distance between RA frames (in frames, 0...255)
162 enum RA_Flag ra_flag
; ///< indicates where the size of ra units is stored
163 int adapt_order
; ///< adaptive order: 1 = on, 0 = off
164 int coef_table
; ///< table index of Rice code parameters
165 int long_term_prediction
; ///< long term prediction (LTP): 1 = on, 0 = off
166 int max_order
; ///< maximum prediction order (0..1023)
167 int block_switching
; ///< number of block switching levels
168 int bgmc
; ///< "Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only)
169 int sb_part
; ///< sub-block partition
170 int joint_stereo
; ///< joint stereo: 1 = on, 0 = off
171 int mc_coding
; ///< extended inter-channel coding (multi channel coding): 1 = on, 0 = off
172 int chan_config
; ///< indicates that a chan_config_info field is present
173 int chan_sort
; ///< channel rearrangement: 1 = on, 0 = off
174 int rlslms
; ///< use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off
175 int chan_config_info
; ///< mapping of channels to loudspeaker locations. Unused until setting channel configuration is implemented.
176 int *chan_pos
; ///< original channel positions
177 int crc_enabled
; ///< enable Cyclic Redundancy Checksum
192 AVCodecContext
*avctx
;
193 ALSSpecificConfig sconf
;
195 BswapDSPContext bdsp
;
196 const AVCRC
*crc_table
;
197 uint32_t crc_org
; ///< CRC value of the original input data
198 uint32_t crc
; ///< CRC value calculated from decoded data
199 unsigned int cur_frame_length
; ///< length of the current frame to decode
200 unsigned int frame_id
; ///< the frame ID / number of the current frame
201 unsigned int js_switch
; ///< if true, joint-stereo decoding is enforced
202 unsigned int cs_switch
; ///< if true, channel rearrangement is done
203 unsigned int num_blocks
; ///< number of blocks used in the current frame
204 unsigned int s_max
; ///< maximum Rice parameter allowed in entropy coding
205 uint8_t *bgmc_lut
; ///< pointer at lookup tables used for BGMC
206 int *bgmc_lut_status
; ///< pointer at lookup table status flags used for BGMC
207 int ltp_lag_length
; ///< number of bits used for ltp lag value
208 int *const_block
; ///< contains const_block flags for all channels
209 unsigned int *shift_lsbs
; ///< contains shift_lsbs flags for all channels
210 unsigned int *opt_order
; ///< contains opt_order flags for all channels
211 int *store_prev_samples
; ///< contains store_prev_samples flags for all channels
212 int *use_ltp
; ///< contains use_ltp flags for all channels
213 int *ltp_lag
; ///< contains ltp lag values for all channels
214 int **ltp_gain
; ///< gain values for ltp 5-tap filter for a channel
215 int *ltp_gain_buffer
; ///< contains all gain values for ltp 5-tap filter
216 int32_t **quant_cof
; ///< quantized parcor coefficients for a channel
217 int32_t *quant_cof_buffer
; ///< contains all quantized parcor coefficients
218 int32_t **lpc_cof
; ///< coefficients of the direct form prediction filter for a channel
219 int32_t *lpc_cof_buffer
; ///< contains all coefficients of the direct form prediction filter
220 int32_t *lpc_cof_reversed_buffer
; ///< temporary buffer to set up a reversed versio of lpc_cof_buffer
221 ALSChannelData
**chan_data
; ///< channel data for multi-channel correlation
222 ALSChannelData
*chan_data_buffer
; ///< contains channel data for all channels
223 int *reverted_channels
; ///< stores a flag for each reverted channel
224 int32_t *prev_raw_samples
; ///< contains unshifted raw samples from the previous block
225 int32_t **raw_samples
; ///< decoded raw samples for each channel
226 int32_t *raw_buffer
; ///< contains all decoded raw samples including carryover samples
227 uint8_t *crc_buffer
; ///< buffer of byte order corrected samples used for CRC check
232 unsigned int block_length
; ///< number of samples within the block
233 unsigned int ra_block
; ///< if true, this is a random access block
234 int *const_block
; ///< if true, this is a constant value block
235 int js_blocks
; ///< true if this block contains a difference signal
236 unsigned int *shift_lsbs
; ///< shift of values for this block
237 unsigned int *opt_order
; ///< prediction order of this block
238 int *store_prev_samples
;///< if true, carryover samples have to be stored
239 int *use_ltp
; ///< if true, long-term prediction is used
240 int *ltp_lag
; ///< lag value for long-term prediction
241 int *ltp_gain
; ///< gain values for ltp 5-tap filter
242 int32_t *quant_cof
; ///< quantized parcor coefficients
243 int32_t *lpc_cof
; ///< coefficients of the direct form prediction
244 int32_t *raw_samples
; ///< decoded raw samples / residuals for this block
245 int32_t *prev_raw_samples
; ///< contains unshifted raw samples from the previous block
246 int32_t *raw_other
; ///< decoded raw samples of the other channel of a channel pair
250 static av_cold
void dprint_specific_config(ALSDecContext
*ctx
)
253 AVCodecContext
*avctx
= ctx
->avctx
;
254 ALSSpecificConfig
*sconf
= &ctx
->sconf
;
256 av_dlog(avctx
, "resolution = %i\n", sconf
->resolution
);
257 av_dlog(avctx
, "floating = %i\n", sconf
->floating
);
258 av_dlog(avctx
, "frame_length = %i\n", sconf
->frame_length
);
259 av_dlog(avctx
, "ra_distance = %i\n", sconf
->ra_distance
);
260 av_dlog(avctx
, "ra_flag = %i\n", sconf
->ra_flag
);
261 av_dlog(avctx
, "adapt_order = %i\n", sconf
->adapt_order
);
262 av_dlog(avctx
, "coef_table = %i\n", sconf
->coef_table
);
263 av_dlog(avctx
, "long_term_prediction = %i\n", sconf
->long_term_prediction
);
264 av_dlog(avctx
, "max_order = %i\n", sconf
->max_order
);
265 av_dlog(avctx
, "block_switching = %i\n", sconf
->block_switching
);
266 av_dlog(avctx
, "bgmc = %i\n", sconf
->bgmc
);
267 av_dlog(avctx
, "sb_part = %i\n", sconf
->sb_part
);
268 av_dlog(avctx
, "joint_stereo = %i\n", sconf
->joint_stereo
);
269 av_dlog(avctx
, "mc_coding = %i\n", sconf
->mc_coding
);
270 av_dlog(avctx
, "chan_config = %i\n", sconf
->chan_config
);
271 av_dlog(avctx
, "chan_sort = %i\n", sconf
->chan_sort
);
272 av_dlog(avctx
, "RLSLMS = %i\n", sconf
->rlslms
);
273 av_dlog(avctx
, "chan_config_info = %i\n", sconf
->chan_config_info
);
278 /** Read an ALSSpecificConfig from a buffer into the output struct.
280 static av_cold
int read_specific_config(ALSDecContext
*ctx
)
284 int i
, config_offset
;
285 MPEG4AudioConfig m4ac
= {0};
286 ALSSpecificConfig
*sconf
= &ctx
->sconf
;
287 AVCodecContext
*avctx
= ctx
->avctx
;
288 uint32_t als_id
, header_size
, trailer_size
;
291 if ((ret
= init_get_bits8(&gb
, avctx
->extradata
, avctx
->extradata_size
)) < 0)
294 config_offset
= avpriv_mpeg4audio_get_config(&m4ac
, avctx
->extradata
,
295 avctx
->extradata_size
* 8, 1);
297 if (config_offset
< 0)
298 return AVERROR_INVALIDDATA
;
300 skip_bits_long(&gb
, config_offset
);
302 if (get_bits_left(&gb
) < (30 << 3))
303 return AVERROR_INVALIDDATA
;
305 // read the fixed items
306 als_id
= get_bits_long(&gb
, 32);
307 avctx
->sample_rate
= m4ac
.sample_rate
;
308 skip_bits_long(&gb
, 32); // sample rate already known
309 sconf
->samples
= get_bits_long(&gb
, 32);
310 avctx
->channels
= m4ac
.channels
;
311 skip_bits(&gb
, 16); // number of channels already known
312 skip_bits(&gb
, 3); // skip file_type
313 sconf
->resolution
= get_bits(&gb
, 3);
314 sconf
->floating
= get_bits1(&gb
);
315 sconf
->msb_first
= get_bits1(&gb
);
316 sconf
->frame_length
= get_bits(&gb
, 16) + 1;
317 sconf
->ra_distance
= get_bits(&gb
, 8);
318 sconf
->ra_flag
= get_bits(&gb
, 2);
319 sconf
->adapt_order
= get_bits1(&gb
);
320 sconf
->coef_table
= get_bits(&gb
, 2);
321 sconf
->long_term_prediction
= get_bits1(&gb
);
322 sconf
->max_order
= get_bits(&gb
, 10);
323 sconf
->block_switching
= get_bits(&gb
, 2);
324 sconf
->bgmc
= get_bits1(&gb
);
325 sconf
->sb_part
= get_bits1(&gb
);
326 sconf
->joint_stereo
= get_bits1(&gb
);
327 sconf
->mc_coding
= get_bits1(&gb
);
328 sconf
->chan_config
= get_bits1(&gb
);
329 sconf
->chan_sort
= get_bits1(&gb
);
330 sconf
->crc_enabled
= get_bits1(&gb
);
331 sconf
->rlslms
= get_bits1(&gb
);
332 skip_bits(&gb
, 5); // skip 5 reserved bits
333 skip_bits1(&gb
); // skip aux_data_enabled
336 // check for ALSSpecificConfig struct
337 if (als_id
!= MKBETAG('A','L','S','\0'))
338 return AVERROR_INVALIDDATA
;
340 ctx
->cur_frame_length
= sconf
->frame_length
;
342 // read channel config
343 if (sconf
->chan_config
)
344 sconf
->chan_config_info
= get_bits(&gb
, 16);
345 // TODO: use this to set avctx->channel_layout
348 // read channel sorting
349 if (sconf
->chan_sort
&& avctx
->channels
> 1) {
350 int chan_pos_bits
= av_ceil_log2(avctx
->channels
);
351 int bits_needed
= avctx
->channels
* chan_pos_bits
+ 7;
352 if (get_bits_left(&gb
) < bits_needed
)
353 return AVERROR_INVALIDDATA
;
355 if (!(sconf
->chan_pos
= av_malloc(avctx
->channels
* sizeof(*sconf
->chan_pos
))))
356 return AVERROR(ENOMEM
);
360 for (i
= 0; i
< avctx
->channels
; i
++) {
363 idx
= get_bits(&gb
, chan_pos_bits
);
364 if (idx
>= avctx
->channels
) {
365 av_log(avctx
, AV_LOG_WARNING
, "Invalid channel reordering.\n");
369 sconf
->chan_pos
[idx
] = i
;
376 // read fixed header and trailer sizes,
377 // if size = 0xFFFFFFFF then there is no data field!
378 if (get_bits_left(&gb
) < 64)
379 return AVERROR_INVALIDDATA
;
381 header_size
= get_bits_long(&gb
, 32);
382 trailer_size
= get_bits_long(&gb
, 32);
383 if (header_size
== 0xFFFFFFFF)
385 if (trailer_size
== 0xFFFFFFFF)
388 ht_size
= ((int64_t)(header_size
) + (int64_t)(trailer_size
)) << 3;
391 // skip the header and trailer data
392 if (get_bits_left(&gb
) < ht_size
)
393 return AVERROR_INVALIDDATA
;
395 if (ht_size
> INT32_MAX
)
396 return AVERROR_PATCHWELCOME
;
398 skip_bits_long(&gb
, ht_size
);
401 // initialize CRC calculation
402 if (sconf
->crc_enabled
) {
403 if (get_bits_left(&gb
) < 32)
404 return AVERROR_INVALIDDATA
;
406 if (avctx
->err_recognition
& (AV_EF_CRCCHECK
|AV_EF_CAREFUL
)) {
407 ctx
->crc_table
= av_crc_get_table(AV_CRC_32_IEEE_LE
);
408 ctx
->crc
= 0xFFFFFFFF;
409 ctx
->crc_org
= ~get_bits_long(&gb
, 32);
411 skip_bits_long(&gb
, 32);
415 // no need to read the rest of ALSSpecificConfig (ra_unit_size & aux data)
417 dprint_specific_config(ctx
);
423 /** Check the ALSSpecificConfig for unsupported features.
425 static int check_specific_config(ALSDecContext
*ctx
)
427 ALSSpecificConfig
*sconf
= &ctx
->sconf
;
430 // report unsupported feature and set error value
431 #define MISSING_ERR(cond, str, errval) \
434 avpriv_report_missing_feature(ctx->avctx, \
440 MISSING_ERR(sconf
->floating
, "Floating point decoding", AVERROR_PATCHWELCOME
);
441 MISSING_ERR(sconf
->rlslms
, "Adaptive RLS-LMS prediction", AVERROR_PATCHWELCOME
);
447 /** Parse the bs_info field to extract the block partitioning used in
448 * block switching mode, refer to ISO/IEC 14496-3, section 11.6.2.
450 static void parse_bs_info(const uint32_t bs_info
, unsigned int n
,
451 unsigned int div
, unsigned int **div_blocks
,
452 unsigned int *num_blocks
)
454 if (n
< 31 && ((bs_info
<< n
) & 0x40000000)) {
455 // if the level is valid and the investigated bit n is set
456 // then recursively check both children at bits (2n+1) and (2n+2)
459 parse_bs_info(bs_info
, n
+ 1, div
, div_blocks
, num_blocks
);
460 parse_bs_info(bs_info
, n
+ 2, div
, div_blocks
, num_blocks
);
462 // else the bit is not set or the last level has been reached
463 // (bit implicitly not set)
471 /** Read and decode a Rice codeword.
473 static int32_t decode_rice(GetBitContext
*gb
, unsigned int k
)
475 int max
= get_bits_left(gb
) - k
;
476 int q
= get_unary(gb
, 0, max
);
477 int r
= k
? get_bits1(gb
) : !(q
& 1);
481 q
+= get_bits_long(gb
, k
- 1);
489 /** Convert PARCOR coefficient k to direct filter coefficient.
491 static void parcor_to_lpc(unsigned int k
, const int32_t *par
, int32_t *cof
)
495 for (i
= 0, j
= k
- 1; i
< j
; i
++, j
--) {
496 int tmp1
= ((MUL64(par
[k
], cof
[j
]) + (1 << 19)) >> 20);
497 cof
[j
] += ((MUL64(par
[k
], cof
[i
]) + (1 << 19)) >> 20);
501 cof
[i
] += ((MUL64(par
[k
], cof
[j
]) + (1 << 19)) >> 20);
507 /** Read block switching field if necessary and set actual block sizes.
508 * Also assure that the block sizes of the last frame correspond to the
509 * actual number of samples.
511 static void get_block_sizes(ALSDecContext
*ctx
, unsigned int *div_blocks
,
514 ALSSpecificConfig
*sconf
= &ctx
->sconf
;
515 GetBitContext
*gb
= &ctx
->gb
;
516 unsigned int *ptr_div_blocks
= div_blocks
;
519 if (sconf
->block_switching
) {
520 unsigned int bs_info_len
= 1 << (sconf
->block_switching
+ 2);
521 *bs_info
= get_bits_long(gb
, bs_info_len
);
522 *bs_info
<<= (32 - bs_info_len
);
526 parse_bs_info(*bs_info
, 0, 0, &ptr_div_blocks
, &ctx
->num_blocks
);
528 // The last frame may have an overdetermined block structure given in
529 // the bitstream. In that case the defined block structure would need
530 // more samples than available to be consistent.
531 // The block structure is actually used but the block sizes are adapted
532 // to fit the actual number of available samples.
533 // Example: 5 samples, 2nd level block sizes: 2 2 2 2.
534 // This results in the actual block sizes: 2 2 1 0.
535 // This is not specified in 14496-3 but actually done by the reference
536 // codec RM22 revision 2.
537 // This appears to happen in case of an odd number of samples in the last
538 // frame which is actually not allowed by the block length switching part
540 // The ALS conformance files feature an odd number of samples in the last
543 for (b
= 0; b
< ctx
->num_blocks
; b
++)
544 div_blocks
[b
] = ctx
->sconf
.frame_length
>> div_blocks
[b
];
546 if (ctx
->cur_frame_length
!= ctx
->sconf
.frame_length
) {
547 unsigned int remaining
= ctx
->cur_frame_length
;
549 for (b
= 0; b
< ctx
->num_blocks
; b
++) {
550 if (remaining
<= div_blocks
[b
]) {
551 div_blocks
[b
] = remaining
;
552 ctx
->num_blocks
= b
+ 1;
556 remaining
-= div_blocks
[b
];
562 /** Read the block data for a constant block
564 static int read_const_block_data(ALSDecContext
*ctx
, ALSBlockData
*bd
)
566 ALSSpecificConfig
*sconf
= &ctx
->sconf
;
567 AVCodecContext
*avctx
= ctx
->avctx
;
568 GetBitContext
*gb
= &ctx
->gb
;
570 if (bd
->block_length
<= 0)
571 return AVERROR_INVALIDDATA
;
573 *bd
->raw_samples
= 0;
574 *bd
->const_block
= get_bits1(gb
); // 1 = constant value, 0 = zero block (silence)
575 bd
->js_blocks
= get_bits1(gb
);
577 // skip 5 reserved bits
580 if (*bd
->const_block
) {
581 unsigned int const_val_bits
= sconf
->floating
? 24 : avctx
->bits_per_raw_sample
;
582 *bd
->raw_samples
= get_sbits_long(gb
, const_val_bits
);
585 // ensure constant block decoding by reusing this field
586 *bd
->const_block
= 1;
592 /** Decode the block data for a constant block
594 static void decode_const_block_data(ALSDecContext
*ctx
, ALSBlockData
*bd
)
596 int smp
= bd
->block_length
- 1;
597 int32_t val
= *bd
->raw_samples
;
598 int32_t *dst
= bd
->raw_samples
+ 1;
600 // write raw samples into buffer
606 /** Read the block data for a non-constant block
608 static int read_var_block_data(ALSDecContext
*ctx
, ALSBlockData
*bd
)
610 ALSSpecificConfig
*sconf
= &ctx
->sconf
;
611 AVCodecContext
*avctx
= ctx
->avctx
;
612 GetBitContext
*gb
= &ctx
->gb
;
616 unsigned int sub_blocks
, log2_sub_blocks
, sb_length
;
617 unsigned int start
= 0;
618 unsigned int opt_order
;
620 int32_t *quant_cof
= bd
->quant_cof
;
621 int32_t *current_res
;
624 // ensure variable block decoding by reusing this field
625 *bd
->const_block
= 0;
628 bd
->js_blocks
= get_bits1(gb
);
630 opt_order
= *bd
->opt_order
;
632 // determine the number of subblocks for entropy decoding
633 if (!sconf
->bgmc
&& !sconf
->sb_part
) {
636 if (sconf
->bgmc
&& sconf
->sb_part
)
637 log2_sub_blocks
= get_bits(gb
, 2);
639 log2_sub_blocks
= 2 * get_bits1(gb
);
642 sub_blocks
= 1 << log2_sub_blocks
;
644 // do not continue in case of a damaged stream since
645 // block_length must be evenly divisible by sub_blocks
646 if (bd
->block_length
& (sub_blocks
- 1)) {
647 av_log(avctx
, AV_LOG_WARNING
,
648 "Block length is not evenly divisible by the number of subblocks.\n");
649 return AVERROR_INVALIDDATA
;
652 sb_length
= bd
->block_length
>> log2_sub_blocks
;
655 s
[0] = get_bits(gb
, 8 + (sconf
->resolution
> 1));
656 for (k
= 1; k
< sub_blocks
; k
++)
657 s
[k
] = s
[k
- 1] + decode_rice(gb
, 2);
659 for (k
= 0; k
< sub_blocks
; k
++) {
664 s
[0] = get_bits(gb
, 4 + (sconf
->resolution
> 1));
665 for (k
= 1; k
< sub_blocks
; k
++)
666 s
[k
] = s
[k
- 1] + decode_rice(gb
, 0);
668 for (k
= 1; k
< sub_blocks
; k
++)
670 av_log(avctx
, AV_LOG_ERROR
, "k invalid for rice code.\n");
671 return AVERROR_INVALIDDATA
;
675 *bd
->shift_lsbs
= get_bits(gb
, 4) + 1;
677 *bd
->store_prev_samples
= (bd
->js_blocks
&& bd
->raw_other
) || *bd
->shift_lsbs
;
680 if (!sconf
->rlslms
) {
681 if (sconf
->adapt_order
) {
682 int opt_order_length
= av_ceil_log2(av_clip((bd
->block_length
>> 3) - 1,
683 2, sconf
->max_order
+ 1));
684 *bd
->opt_order
= get_bits(gb
, opt_order_length
);
685 if (*bd
->opt_order
> sconf
->max_order
) {
686 *bd
->opt_order
= sconf
->max_order
;
687 av_log(avctx
, AV_LOG_ERROR
, "Predictor order too large.\n");
688 return AVERROR_INVALIDDATA
;
691 *bd
->opt_order
= sconf
->max_order
;
693 if (*bd
->opt_order
> bd
->block_length
) {
694 *bd
->opt_order
= bd
->block_length
;
695 av_log(avctx
, AV_LOG_ERROR
, "Predictor order too large.\n");
696 return AVERROR_INVALIDDATA
;
698 opt_order
= *bd
->opt_order
;
703 if (sconf
->coef_table
== 3) {
706 // read coefficient 0
707 quant_cof
[0] = 32 * parcor_scaled_values
[get_bits(gb
, 7)];
709 // read coefficient 1
711 quant_cof
[1] = -32 * parcor_scaled_values
[get_bits(gb
, 7)];
713 // read coefficients 2 to opt_order
714 for (k
= 2; k
< opt_order
; k
++)
715 quant_cof
[k
] = get_bits(gb
, 7);
720 // read coefficient 0 to 19
721 k_max
= FFMIN(opt_order
, 20);
722 for (k
= 0; k
< k_max
; k
++) {
723 int rice_param
= parcor_rice_table
[sconf
->coef_table
][k
][1];
724 int offset
= parcor_rice_table
[sconf
->coef_table
][k
][0];
725 quant_cof
[k
] = decode_rice(gb
, rice_param
) + offset
;
726 if (quant_cof
[k
] < -64 || quant_cof
[k
] > 63) {
727 av_log(avctx
, AV_LOG_ERROR
,
728 "quant_cof %"PRIu32
" is out of range.\n",
730 return AVERROR_INVALIDDATA
;
734 // read coefficients 20 to 126
735 k_max
= FFMIN(opt_order
, 127);
736 for (; k
< k_max
; k
++)
737 quant_cof
[k
] = decode_rice(gb
, 2) + (k
& 1);
739 // read coefficients 127 to opt_order
740 for (; k
< opt_order
; k
++)
741 quant_cof
[k
] = decode_rice(gb
, 1);
743 quant_cof
[0] = 32 * parcor_scaled_values
[quant_cof
[0] + 64];
746 quant_cof
[1] = -32 * parcor_scaled_values
[quant_cof
[1] + 64];
749 for (k
= 2; k
< opt_order
; k
++)
750 quant_cof
[k
] = (quant_cof
[k
] << 14) + (add_base
<< 13);
754 // read LTP gain and lag values
755 if (sconf
->long_term_prediction
) {
756 *bd
->use_ltp
= get_bits1(gb
);
761 bd
->ltp_gain
[0] = decode_rice(gb
, 1) << 3;
762 bd
->ltp_gain
[1] = decode_rice(gb
, 2) << 3;
764 r
= get_unary(gb
, 0, 3);
766 bd
->ltp_gain
[2] = ltp_gain_values
[r
][c
];
768 bd
->ltp_gain
[3] = decode_rice(gb
, 2) << 3;
769 bd
->ltp_gain
[4] = decode_rice(gb
, 1) << 3;
771 *bd
->ltp_lag
= get_bits(gb
, ctx
->ltp_lag_length
);
772 *bd
->ltp_lag
+= FFMAX(4, opt_order
+ 1);
776 // read first value and residuals in case of a random access block
779 bd
->raw_samples
[0] = decode_rice(gb
, avctx
->bits_per_raw_sample
- 4);
781 bd
->raw_samples
[1] = decode_rice(gb
, FFMIN(s
[0] + 3, ctx
->s_max
));
783 bd
->raw_samples
[2] = decode_rice(gb
, FFMIN(s
[0] + 1, ctx
->s_max
));
785 start
= FFMIN(opt_order
, 3);
788 // read all residuals
792 unsigned int b
= av_clip((av_ceil_log2(bd
->block_length
) - 3) >> 1, 0, 5);
794 // read most significant bits
799 ff_bgmc_decode_init(gb
, &high
, &low
, &value
);
801 current_res
= bd
->raw_samples
+ start
;
803 for (sb
= 0; sb
< sub_blocks
; sb
++) {
804 unsigned int sb_len
= sb_length
- (sb
? 0 : start
);
806 k
[sb
] = s
[sb
] > b
? s
[sb
] - b
: 0;
807 delta
[sb
] = 5 - s
[sb
] + k
[sb
];
809 ff_bgmc_decode(gb
, sb_len
, current_res
,
810 delta
[sb
], sx
[sb
], &high
, &low
, &value
, ctx
->bgmc_lut
, ctx
->bgmc_lut_status
);
812 current_res
+= sb_len
;
815 ff_bgmc_decode_end(gb
);
818 // read least significant bits and tails
819 current_res
= bd
->raw_samples
+ start
;
821 for (sb
= 0; sb
< sub_blocks
; sb
++, start
= 0) {
822 unsigned int cur_tail_code
= tail_code
[sx
[sb
]][delta
[sb
]];
823 unsigned int cur_k
= k
[sb
];
824 unsigned int cur_s
= s
[sb
];
826 for (; start
< sb_length
; start
++) {
827 int32_t res
= *current_res
;
829 if (res
== cur_tail_code
) {
830 unsigned int max_msb
= (2 + (sx
[sb
] > 2) + (sx
[sb
] > 10))
833 res
= decode_rice(gb
, cur_s
);
836 res
+= (max_msb
) << cur_k
;
838 res
-= (max_msb
- 1) << cur_k
;
841 if (res
> cur_tail_code
)
851 res
|= get_bits_long(gb
, cur_k
);
855 *current_res
++ = res
;
859 current_res
= bd
->raw_samples
+ start
;
861 for (sb
= 0; sb
< sub_blocks
; sb
++, start
= 0)
862 for (; start
< sb_length
; start
++)
863 *current_res
++ = decode_rice(gb
, s
[sb
]);
866 if (!sconf
->mc_coding
|| ctx
->js_switch
)
873 /** Decode the block data for a non-constant block
875 static int decode_var_block_data(ALSDecContext
*ctx
, ALSBlockData
*bd
)
877 ALSSpecificConfig
*sconf
= &ctx
->sconf
;
878 unsigned int block_length
= bd
->block_length
;
879 unsigned int smp
= 0;
881 int opt_order
= *bd
->opt_order
;
884 int32_t *quant_cof
= bd
->quant_cof
;
885 int32_t *lpc_cof
= bd
->lpc_cof
;
886 int32_t *raw_samples
= bd
->raw_samples
;
887 int32_t *raw_samples_end
= bd
->raw_samples
+ bd
->block_length
;
888 int32_t *lpc_cof_reversed
= ctx
->lpc_cof_reversed_buffer
;
890 // reverse long-term prediction
894 for (ltp_smp
= FFMAX(*bd
->ltp_lag
- 2, 0); ltp_smp
< block_length
; ltp_smp
++) {
895 int center
= ltp_smp
- *bd
->ltp_lag
;
896 int begin
= FFMAX(0, center
- 2);
897 int end
= center
+ 3;
898 int tab
= 5 - (end
- begin
);
903 for (base
= begin
; base
< end
; base
++, tab
++)
904 y
+= MUL64(bd
->ltp_gain
[tab
], raw_samples
[base
]);
906 raw_samples
[ltp_smp
] += y
>> 7;
910 // reconstruct all samples from residuals
912 for (smp
= 0; smp
< opt_order
; smp
++) {
915 for (sb
= 0; sb
< smp
; sb
++)
916 y
+= MUL64(lpc_cof
[sb
], raw_samples
[-(sb
+ 1)]);
918 *raw_samples
++ -= y
>> 20;
919 parcor_to_lpc(smp
, quant_cof
, lpc_cof
);
922 for (k
= 0; k
< opt_order
; k
++)
923 parcor_to_lpc(k
, quant_cof
, lpc_cof
);
925 // store previous samples in case that they have to be altered
926 if (*bd
->store_prev_samples
)
927 memcpy(bd
->prev_raw_samples
, raw_samples
- sconf
->max_order
,
928 sizeof(*bd
->prev_raw_samples
) * sconf
->max_order
);
930 // reconstruct difference signal for prediction (joint-stereo)
931 if (bd
->js_blocks
&& bd
->raw_other
) {
932 int32_t *left
, *right
;
934 if (bd
->raw_other
> raw_samples
) { // D = R - L
936 right
= bd
->raw_other
;
937 } else { // D = R - L
938 left
= bd
->raw_other
;
942 for (sb
= -1; sb
>= -sconf
->max_order
; sb
--)
943 raw_samples
[sb
] = right
[sb
] - left
[sb
];
946 // reconstruct shifted signal
948 for (sb
= -1; sb
>= -sconf
->max_order
; sb
--)
949 raw_samples
[sb
] >>= *bd
->shift_lsbs
;
952 // reverse linear prediction coefficients for efficiency
953 lpc_cof
= lpc_cof
+ opt_order
;
955 for (sb
= 0; sb
< opt_order
; sb
++)
956 lpc_cof_reversed
[sb
] = lpc_cof
[-(sb
+ 1)];
958 // reconstruct raw samples
959 raw_samples
= bd
->raw_samples
+ smp
;
960 lpc_cof
= lpc_cof_reversed
+ opt_order
;
962 for (; raw_samples
< raw_samples_end
; raw_samples
++) {
965 for (sb
= -opt_order
; sb
< 0; sb
++)
966 y
+= MUL64(lpc_cof
[sb
], raw_samples
[sb
]);
968 *raw_samples
-= y
>> 20;
971 raw_samples
= bd
->raw_samples
;
973 // restore previous samples in case that they have been altered
974 if (*bd
->store_prev_samples
)
975 memcpy(raw_samples
- sconf
->max_order
, bd
->prev_raw_samples
,
976 sizeof(*raw_samples
) * sconf
->max_order
);
982 /** Read the block data.
984 static int read_block(ALSDecContext
*ctx
, ALSBlockData
*bd
)
987 GetBitContext
*gb
= &ctx
->gb
;
990 // read block type flag and read the samples accordingly
992 ret
= read_var_block_data(ctx
, bd
);
994 ret
= read_const_block_data(ctx
, bd
);
1001 /** Decode the block data.
1003 static int decode_block(ALSDecContext
*ctx
, ALSBlockData
*bd
)
1008 // read block type flag and read the samples accordingly
1009 if (*bd
->const_block
)
1010 decode_const_block_data(ctx
, bd
);
1012 ret
= decode_var_block_data(ctx
, bd
); // always return 0
1017 // TODO: read RLSLMS extension data
1019 if (*bd
->shift_lsbs
)
1020 for (smp
= 0; smp
< bd
->block_length
; smp
++)
1021 bd
->raw_samples
[smp
] <<= *bd
->shift_lsbs
;
1027 /** Read and decode block data successively.
1029 static int read_decode_block(ALSDecContext
*ctx
, ALSBlockData
*bd
)
1033 if ((ret
= read_block(ctx
, bd
)) < 0)
1036 return decode_block(ctx
, bd
);
1040 /** Compute the number of samples left to decode for the current frame and
1041 * sets these samples to zero.
1043 static void zero_remaining(unsigned int b
, unsigned int b_max
,
1044 const unsigned int *div_blocks
, int32_t *buf
)
1046 unsigned int count
= 0;
1049 count
+= div_blocks
[b
++];
1052 memset(buf
, 0, sizeof(*buf
) * count
);
1056 /** Decode blocks independently.
1058 static int decode_blocks_ind(ALSDecContext
*ctx
, unsigned int ra_frame
,
1059 unsigned int c
, const unsigned int *div_blocks
,
1060 unsigned int *js_blocks
)
1064 ALSBlockData bd
= { 0 };
1066 bd
.ra_block
= ra_frame
;
1067 bd
.const_block
= ctx
->const_block
;
1068 bd
.shift_lsbs
= ctx
->shift_lsbs
;
1069 bd
.opt_order
= ctx
->opt_order
;
1070 bd
.store_prev_samples
= ctx
->store_prev_samples
;
1071 bd
.use_ltp
= ctx
->use_ltp
;
1072 bd
.ltp_lag
= ctx
->ltp_lag
;
1073 bd
.ltp_gain
= ctx
->ltp_gain
[0];
1074 bd
.quant_cof
= ctx
->quant_cof
[0];
1075 bd
.lpc_cof
= ctx
->lpc_cof
[0];
1076 bd
.prev_raw_samples
= ctx
->prev_raw_samples
;
1077 bd
.raw_samples
= ctx
->raw_samples
[c
];
1080 for (b
= 0; b
< ctx
->num_blocks
; b
++) {
1081 bd
.block_length
= div_blocks
[b
];
1083 if ((ret
= read_decode_block(ctx
, &bd
)) < 0) {
1084 // damaged block, write zero for the rest of the frame
1085 zero_remaining(b
, ctx
->num_blocks
, div_blocks
, bd
.raw_samples
);
1088 bd
.raw_samples
+= div_blocks
[b
];
1096 /** Decode blocks dependently.
1098 static int decode_blocks(ALSDecContext
*ctx
, unsigned int ra_frame
,
1099 unsigned int c
, const unsigned int *div_blocks
,
1100 unsigned int *js_blocks
)
1102 ALSSpecificConfig
*sconf
= &ctx
->sconf
;
1103 unsigned int offset
= 0;
1106 ALSBlockData bd
[2] = { { 0 } };
1108 bd
[0].ra_block
= ra_frame
;
1109 bd
[0].const_block
= ctx
->const_block
;
1110 bd
[0].shift_lsbs
= ctx
->shift_lsbs
;
1111 bd
[0].opt_order
= ctx
->opt_order
;
1112 bd
[0].store_prev_samples
= ctx
->store_prev_samples
;
1113 bd
[0].use_ltp
= ctx
->use_ltp
;
1114 bd
[0].ltp_lag
= ctx
->ltp_lag
;
1115 bd
[0].ltp_gain
= ctx
->ltp_gain
[0];
1116 bd
[0].quant_cof
= ctx
->quant_cof
[0];
1117 bd
[0].lpc_cof
= ctx
->lpc_cof
[0];
1118 bd
[0].prev_raw_samples
= ctx
->prev_raw_samples
;
1119 bd
[0].js_blocks
= *js_blocks
;
1121 bd
[1].ra_block
= ra_frame
;
1122 bd
[1].const_block
= ctx
->const_block
;
1123 bd
[1].shift_lsbs
= ctx
->shift_lsbs
;
1124 bd
[1].opt_order
= ctx
->opt_order
;
1125 bd
[1].store_prev_samples
= ctx
->store_prev_samples
;
1126 bd
[1].use_ltp
= ctx
->use_ltp
;
1127 bd
[1].ltp_lag
= ctx
->ltp_lag
;
1128 bd
[1].ltp_gain
= ctx
->ltp_gain
[0];
1129 bd
[1].quant_cof
= ctx
->quant_cof
[0];
1130 bd
[1].lpc_cof
= ctx
->lpc_cof
[0];
1131 bd
[1].prev_raw_samples
= ctx
->prev_raw_samples
;
1132 bd
[1].js_blocks
= *(js_blocks
+ 1);
1134 // decode all blocks
1135 for (b
= 0; b
< ctx
->num_blocks
; b
++) {
1138 bd
[0].block_length
= div_blocks
[b
];
1139 bd
[1].block_length
= div_blocks
[b
];
1141 bd
[0].raw_samples
= ctx
->raw_samples
[c
] + offset
;
1142 bd
[1].raw_samples
= ctx
->raw_samples
[c
+ 1] + offset
;
1144 bd
[0].raw_other
= bd
[1].raw_samples
;
1145 bd
[1].raw_other
= bd
[0].raw_samples
;
1147 if ((ret
= read_decode_block(ctx
, &bd
[0])) < 0 ||
1148 (ret
= read_decode_block(ctx
, &bd
[1])) < 0)
1151 // reconstruct joint-stereo blocks
1152 if (bd
[0].js_blocks
) {
1153 if (bd
[1].js_blocks
)
1154 av_log(ctx
->avctx
, AV_LOG_WARNING
, "Invalid channel pair.\n");
1156 for (s
= 0; s
< div_blocks
[b
]; s
++)
1157 bd
[0].raw_samples
[s
] = bd
[1].raw_samples
[s
] - bd
[0].raw_samples
[s
];
1158 } else if (bd
[1].js_blocks
) {
1159 for (s
= 0; s
< div_blocks
[b
]; s
++)
1160 bd
[1].raw_samples
[s
] = bd
[1].raw_samples
[s
] + bd
[0].raw_samples
[s
];
1163 offset
+= div_blocks
[b
];
1168 // store carryover raw samples,
1169 // the others channel raw samples are stored by the calling function.
1170 memmove(ctx
->raw_samples
[c
] - sconf
->max_order
,
1171 ctx
->raw_samples
[c
] - sconf
->max_order
+ sconf
->frame_length
,
1172 sizeof(*ctx
->raw_samples
[c
]) * sconf
->max_order
);
1176 // damaged block, write zero for the rest of the frame
1177 zero_remaining(b
, ctx
->num_blocks
, div_blocks
, bd
[0].raw_samples
);
1178 zero_remaining(b
, ctx
->num_blocks
, div_blocks
, bd
[1].raw_samples
);
1182 static inline int als_weighting(GetBitContext
*gb
, int k
, int off
)
1184 int idx
= av_clip(decode_rice(gb
, k
) + off
,
1185 0, FF_ARRAY_ELEMS(mcc_weightings
) - 1);
1186 return mcc_weightings
[idx
];
1189 /** Read the channel data.
1191 static int read_channel_data(ALSDecContext
*ctx
, ALSChannelData
*cd
, int c
)
1193 GetBitContext
*gb
= &ctx
->gb
;
1194 ALSChannelData
*current
= cd
;
1195 unsigned int channels
= ctx
->avctx
->channels
;
1198 while (entries
< channels
&& !(current
->stop_flag
= get_bits1(gb
))) {
1199 current
->master_channel
= get_bits_long(gb
, av_ceil_log2(channels
));
1201 if (current
->master_channel
>= channels
) {
1202 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Invalid master channel.\n");
1203 return AVERROR_INVALIDDATA
;
1206 if (current
->master_channel
!= c
) {
1207 current
->time_diff_flag
= get_bits1(gb
);
1208 current
->weighting
[0] = als_weighting(gb
, 1, 16);
1209 current
->weighting
[1] = als_weighting(gb
, 2, 14);
1210 current
->weighting
[2] = als_weighting(gb
, 1, 16);
1212 if (current
->time_diff_flag
) {
1213 current
->weighting
[3] = als_weighting(gb
, 1, 16);
1214 current
->weighting
[4] = als_weighting(gb
, 1, 16);
1215 current
->weighting
[5] = als_weighting(gb
, 1, 16);
1217 current
->time_diff_sign
= get_bits1(gb
);
1218 current
->time_diff_index
= get_bits(gb
, ctx
->ltp_lag_length
- 3) + 3;
1226 if (entries
== channels
) {
1227 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Damaged channel data.\n");
1228 return AVERROR_INVALIDDATA
;
1236 /** Recursively reverts the inter-channel correlation for a block.
1238 static int revert_channel_correlation(ALSDecContext
*ctx
, ALSBlockData
*bd
,
1239 ALSChannelData
**cd
, int *reverted
,
1240 unsigned int offset
, int c
)
1242 ALSChannelData
*ch
= cd
[c
];
1243 unsigned int dep
= 0;
1244 unsigned int channels
= ctx
->avctx
->channels
;
1251 while (dep
< channels
&& !ch
[dep
].stop_flag
) {
1252 revert_channel_correlation(ctx
, bd
, cd
, reverted
, offset
,
1253 ch
[dep
].master_channel
);
1258 if (dep
== channels
) {
1259 av_log(ctx
->avctx
, AV_LOG_WARNING
, "Invalid channel correlation.\n");
1260 return AVERROR_INVALIDDATA
;
1263 bd
->const_block
= ctx
->const_block
+ c
;
1264 bd
->shift_lsbs
= ctx
->shift_lsbs
+ c
;
1265 bd
->opt_order
= ctx
->opt_order
+ c
;
1266 bd
->store_prev_samples
= ctx
->store_prev_samples
+ c
;
1267 bd
->use_ltp
= ctx
->use_ltp
+ c
;
1268 bd
->ltp_lag
= ctx
->ltp_lag
+ c
;
1269 bd
->ltp_gain
= ctx
->ltp_gain
[c
];
1270 bd
->lpc_cof
= ctx
->lpc_cof
[c
];
1271 bd
->quant_cof
= ctx
->quant_cof
[c
];
1272 bd
->raw_samples
= ctx
->raw_samples
[c
] + offset
;
1274 for (dep
= 0; !ch
[dep
].stop_flag
; dep
++) {
1276 unsigned int begin
= 1;
1277 unsigned int end
= bd
->block_length
- 1;
1279 int32_t *master
= ctx
->raw_samples
[ch
[dep
].master_channel
] + offset
;
1281 if (ch
[dep
].master_channel
== c
)
1284 if (ch
[dep
].time_diff_flag
) {
1285 int t
= ch
[dep
].time_diff_index
;
1287 if (ch
[dep
].time_diff_sign
) {
1294 for (smp
= begin
; smp
< end
; smp
++) {
1296 MUL64(ch
[dep
].weighting
[0], master
[smp
- 1 ]) +
1297 MUL64(ch
[dep
].weighting
[1], master
[smp
]) +
1298 MUL64(ch
[dep
].weighting
[2], master
[smp
+ 1 ]) +
1299 MUL64(ch
[dep
].weighting
[3], master
[smp
- 1 + t
]) +
1300 MUL64(ch
[dep
].weighting
[4], master
[smp
+ t
]) +
1301 MUL64(ch
[dep
].weighting
[5], master
[smp
+ 1 + t
]);
1303 bd
->raw_samples
[smp
] += y
>> 7;
1306 for (smp
= begin
; smp
< end
; smp
++) {
1308 MUL64(ch
[dep
].weighting
[0], master
[smp
- 1]) +
1309 MUL64(ch
[dep
].weighting
[1], master
[smp
]) +
1310 MUL64(ch
[dep
].weighting
[2], master
[smp
+ 1]);
1312 bd
->raw_samples
[smp
] += y
>> 7;
1321 /** Read the frame data.
1323 static int read_frame_data(ALSDecContext
*ctx
, unsigned int ra_frame
)
1325 ALSSpecificConfig
*sconf
= &ctx
->sconf
;
1326 AVCodecContext
*avctx
= ctx
->avctx
;
1327 GetBitContext
*gb
= &ctx
->gb
;
1328 unsigned int div_blocks
[32]; ///< block sizes.
1330 unsigned int js_blocks
[2];
1331 uint32_t bs_info
= 0;
1334 // skip the size of the ra unit if present in the frame
1335 if (sconf
->ra_flag
== RA_FLAG_FRAMES
&& ra_frame
)
1336 skip_bits_long(gb
, 32);
1338 if (sconf
->mc_coding
&& sconf
->joint_stereo
) {
1339 ctx
->js_switch
= get_bits1(gb
);
1343 if (!sconf
->mc_coding
|| ctx
->js_switch
) {
1344 int independent_bs
= !sconf
->joint_stereo
;
1346 for (c
= 0; c
< avctx
->channels
; c
++) {
1350 get_block_sizes(ctx
, div_blocks
, &bs_info
);
1352 // if joint_stereo and block_switching is set, independent decoding
1353 // is signaled via the first bit of bs_info
1354 if (sconf
->joint_stereo
&& sconf
->block_switching
)
1358 // if this is the last channel, it has to be decoded independently
1359 if (c
== avctx
->channels
- 1)
1362 if (independent_bs
) {
1363 ret
= decode_blocks_ind(ctx
, ra_frame
, c
,
1364 div_blocks
, js_blocks
);
1369 ret
= decode_blocks(ctx
, ra_frame
, c
, div_blocks
, js_blocks
);
1376 // store carryover raw samples
1377 memmove(ctx
->raw_samples
[c
] - sconf
->max_order
,
1378 ctx
->raw_samples
[c
] - sconf
->max_order
+ sconf
->frame_length
,
1379 sizeof(*ctx
->raw_samples
[c
]) * sconf
->max_order
);
1381 } else { // multi-channel coding
1382 ALSBlockData bd
= { 0 };
1384 int *reverted_channels
= ctx
->reverted_channels
;
1385 unsigned int offset
= 0;
1387 for (c
= 0; c
< avctx
->channels
; c
++)
1388 if (ctx
->chan_data
[c
] < ctx
->chan_data_buffer
) {
1389 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Invalid channel data.\n");
1390 return AVERROR_INVALIDDATA
;
1393 memset(reverted_channels
, 0, sizeof(*reverted_channels
) * avctx
->channels
);
1395 bd
.ra_block
= ra_frame
;
1396 bd
.prev_raw_samples
= ctx
->prev_raw_samples
;
1398 get_block_sizes(ctx
, div_blocks
, &bs_info
);
1400 for (b
= 0; b
< ctx
->num_blocks
; b
++) {
1401 bd
.block_length
= div_blocks
[b
];
1402 if (bd
.block_length
<= 0) {
1403 av_log(ctx
->avctx
, AV_LOG_WARNING
,
1404 "Invalid block length %u in channel data!\n",
1409 for (c
= 0; c
< avctx
->channels
; c
++) {
1410 bd
.const_block
= ctx
->const_block
+ c
;
1411 bd
.shift_lsbs
= ctx
->shift_lsbs
+ c
;
1412 bd
.opt_order
= ctx
->opt_order
+ c
;
1413 bd
.store_prev_samples
= ctx
->store_prev_samples
+ c
;
1414 bd
.use_ltp
= ctx
->use_ltp
+ c
;
1415 bd
.ltp_lag
= ctx
->ltp_lag
+ c
;
1416 bd
.ltp_gain
= ctx
->ltp_gain
[c
];
1417 bd
.lpc_cof
= ctx
->lpc_cof
[c
];
1418 bd
.quant_cof
= ctx
->quant_cof
[c
];
1419 bd
.raw_samples
= ctx
->raw_samples
[c
] + offset
;
1420 bd
.raw_other
= NULL
;
1422 if ((ret
= read_block(ctx
, &bd
)) < 0)
1424 if ((ret
= read_channel_data(ctx
, ctx
->chan_data
[c
], c
)) < 0)
1428 for (c
= 0; c
< avctx
->channels
; c
++) {
1429 ret
= revert_channel_correlation(ctx
, &bd
, ctx
->chan_data
,
1430 reverted_channels
, offset
, c
);
1434 for (c
= 0; c
< avctx
->channels
; c
++) {
1435 bd
.const_block
= ctx
->const_block
+ c
;
1436 bd
.shift_lsbs
= ctx
->shift_lsbs
+ c
;
1437 bd
.opt_order
= ctx
->opt_order
+ c
;
1438 bd
.store_prev_samples
= ctx
->store_prev_samples
+ c
;
1439 bd
.use_ltp
= ctx
->use_ltp
+ c
;
1440 bd
.ltp_lag
= ctx
->ltp_lag
+ c
;
1441 bd
.ltp_gain
= ctx
->ltp_gain
[c
];
1442 bd
.lpc_cof
= ctx
->lpc_cof
[c
];
1443 bd
.quant_cof
= ctx
->quant_cof
[c
];
1444 bd
.raw_samples
= ctx
->raw_samples
[c
] + offset
;
1446 if ((ret
= decode_block(ctx
, &bd
)) < 0)
1450 memset(reverted_channels
, 0, avctx
->channels
* sizeof(*reverted_channels
));
1451 offset
+= div_blocks
[b
];
1455 // store carryover raw samples
1456 for (c
= 0; c
< avctx
->channels
; c
++)
1457 memmove(ctx
->raw_samples
[c
] - sconf
->max_order
,
1458 ctx
->raw_samples
[c
] - sconf
->max_order
+ sconf
->frame_length
,
1459 sizeof(*ctx
->raw_samples
[c
]) * sconf
->max_order
);
1462 // TODO: read_diff_float_data
1468 /** Decode an ALS frame.
1470 static int decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame_ptr
,
1473 ALSDecContext
*ctx
= avctx
->priv_data
;
1474 AVFrame
*frame
= data
;
1475 ALSSpecificConfig
*sconf
= &ctx
->sconf
;
1476 const uint8_t *buffer
= avpkt
->data
;
1477 int buffer_size
= avpkt
->size
;
1478 int invalid_frame
, ret
;
1479 unsigned int c
, sample
, ra_frame
, bytes_read
, shift
;
1481 init_get_bits(&ctx
->gb
, buffer
, buffer_size
* 8);
1483 // In the case that the distance between random access frames is set to zero
1484 // (sconf->ra_distance == 0) no frame is treated as a random access frame.
1485 // For the first frame, if prediction is used, all samples used from the
1486 // previous frame are assumed to be zero.
1487 ra_frame
= sconf
->ra_distance
&& !(ctx
->frame_id
% sconf
->ra_distance
);
1489 // the last frame to decode might have a different length
1490 if (sconf
->samples
!= 0xFFFFFFFF)
1491 ctx
->cur_frame_length
= FFMIN(sconf
->samples
- ctx
->frame_id
* (uint64_t) sconf
->frame_length
,
1492 sconf
->frame_length
);
1494 ctx
->cur_frame_length
= sconf
->frame_length
;
1496 // decode the frame data
1497 if ((invalid_frame
= read_frame_data(ctx
, ra_frame
)) < 0)
1498 av_log(ctx
->avctx
, AV_LOG_WARNING
,
1499 "Reading frame data failed. Skipping RA unit.\n");
1503 /* get output buffer */
1504 frame
->nb_samples
= ctx
->cur_frame_length
;
1505 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
1508 // transform decoded frame into output format
1509 #define INTERLEAVE_OUTPUT(bps) \
1511 int##bps##_t *dest = (int##bps##_t*)frame->data[0]; \
1512 shift = bps - ctx->avctx->bits_per_raw_sample; \
1513 if (!ctx->cs_switch) { \
1514 for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1515 for (c = 0; c < avctx->channels; c++) \
1516 *dest++ = ctx->raw_samples[c][sample] << shift; \
1518 for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1519 for (c = 0; c < avctx->channels; c++) \
1520 *dest++ = ctx->raw_samples[sconf->chan_pos[c]][sample] << shift; \
1524 if (ctx
->avctx
->bits_per_raw_sample
<= 16) {
1525 INTERLEAVE_OUTPUT(16)
1527 INTERLEAVE_OUTPUT(32)
1531 if (sconf
->crc_enabled
&& (avctx
->err_recognition
& (AV_EF_CRCCHECK
|AV_EF_CAREFUL
))) {
1532 int swap
= HAVE_BIGENDIAN
!= sconf
->msb_first
;
1534 if (ctx
->avctx
->bits_per_raw_sample
== 24) {
1535 int32_t *src
= (int32_t *)frame
->data
[0];
1538 sample
< ctx
->cur_frame_length
* avctx
->channels
;
1543 v
= av_bswap32(src
[sample
]);
1546 if (!HAVE_BIGENDIAN
)
1549 ctx
->crc
= av_crc(ctx
->crc_table
, ctx
->crc
, (uint8_t*)(&v
), 3);
1552 uint8_t *crc_source
;
1555 if (ctx
->avctx
->bits_per_raw_sample
<= 16) {
1556 int16_t *src
= (int16_t*) frame
->data
[0];
1557 int16_t *dest
= (int16_t*) ctx
->crc_buffer
;
1559 sample
< ctx
->cur_frame_length
* avctx
->channels
;
1561 *dest
++ = av_bswap16(src
[sample
]);
1563 ctx
->bdsp
.bswap_buf((uint32_t *) ctx
->crc_buffer
,
1564 (uint32_t *) frame
->data
[0],
1565 ctx
->cur_frame_length
* avctx
->channels
);
1567 crc_source
= ctx
->crc_buffer
;
1569 crc_source
= frame
->data
[0];
1572 ctx
->crc
= av_crc(ctx
->crc_table
, ctx
->crc
, crc_source
,
1573 ctx
->cur_frame_length
* avctx
->channels
*
1574 av_get_bytes_per_sample(avctx
->sample_fmt
));
1578 // check CRC sums if this is the last frame
1579 if (ctx
->cur_frame_length
!= sconf
->frame_length
&&
1580 ctx
->crc_org
!= ctx
->crc
) {
1581 av_log(avctx
, AV_LOG_ERROR
, "CRC error.\n");
1582 if (avctx
->err_recognition
& AV_EF_EXPLODE
)
1583 return AVERROR_INVALIDDATA
;
1589 bytes_read
= invalid_frame
? buffer_size
:
1590 (get_bits_count(&ctx
->gb
) + 7) >> 3;
1596 /** Uninitialize the ALS decoder.
1598 static av_cold
int decode_end(AVCodecContext
*avctx
)
1600 ALSDecContext
*ctx
= avctx
->priv_data
;
1602 av_freep(&ctx
->sconf
.chan_pos
);
1604 ff_bgmc_end(&ctx
->bgmc_lut
, &ctx
->bgmc_lut_status
);
1606 av_freep(&ctx
->const_block
);
1607 av_freep(&ctx
->shift_lsbs
);
1608 av_freep(&ctx
->opt_order
);
1609 av_freep(&ctx
->store_prev_samples
);
1610 av_freep(&ctx
->use_ltp
);
1611 av_freep(&ctx
->ltp_lag
);
1612 av_freep(&ctx
->ltp_gain
);
1613 av_freep(&ctx
->ltp_gain_buffer
);
1614 av_freep(&ctx
->quant_cof
);
1615 av_freep(&ctx
->lpc_cof
);
1616 av_freep(&ctx
->quant_cof_buffer
);
1617 av_freep(&ctx
->lpc_cof_buffer
);
1618 av_freep(&ctx
->lpc_cof_reversed_buffer
);
1619 av_freep(&ctx
->prev_raw_samples
);
1620 av_freep(&ctx
->raw_samples
);
1621 av_freep(&ctx
->raw_buffer
);
1622 av_freep(&ctx
->chan_data
);
1623 av_freep(&ctx
->chan_data_buffer
);
1624 av_freep(&ctx
->reverted_channels
);
1625 av_freep(&ctx
->crc_buffer
);
1631 /** Initialize the ALS decoder.
1633 static av_cold
int decode_init(AVCodecContext
*avctx
)
1636 unsigned int channel_size
;
1637 int num_buffers
, ret
;
1638 ALSDecContext
*ctx
= avctx
->priv_data
;
1639 ALSSpecificConfig
*sconf
= &ctx
->sconf
;
1642 if (!avctx
->extradata
) {
1643 av_log(avctx
, AV_LOG_ERROR
, "Missing required ALS extradata.\n");
1644 return AVERROR_INVALIDDATA
;
1647 if ((ret
= read_specific_config(ctx
)) < 0) {
1648 av_log(avctx
, AV_LOG_ERROR
, "Reading ALSSpecificConfig failed.\n");
1652 if ((ret
= check_specific_config(ctx
)) < 0) {
1657 ret
= ff_bgmc_init(avctx
, &ctx
->bgmc_lut
, &ctx
->bgmc_lut_status
);
1661 if (sconf
->floating
) {
1662 avctx
->sample_fmt
= AV_SAMPLE_FMT_FLT
;
1663 avctx
->bits_per_raw_sample
= 32;
1665 avctx
->sample_fmt
= sconf
->resolution
> 1
1666 ? AV_SAMPLE_FMT_S32
: AV_SAMPLE_FMT_S16
;
1667 avctx
->bits_per_raw_sample
= (sconf
->resolution
+ 1) * 8;
1670 // set maximum Rice parameter for progressive decoding based on resolution
1671 // This is not specified in 14496-3 but actually done by the reference
1672 // codec RM22 revision 2.
1673 ctx
->s_max
= sconf
->resolution
> 1 ? 31 : 15;
1675 // set lag value for long-term prediction
1676 ctx
->ltp_lag_length
= 8 + (avctx
->sample_rate
>= 96000) +
1677 (avctx
->sample_rate
>= 192000);
1679 // allocate quantized parcor coefficient buffer
1680 num_buffers
= sconf
->mc_coding
? avctx
->channels
: 1;
1682 ctx
->quant_cof
= av_malloc(sizeof(*ctx
->quant_cof
) * num_buffers
);
1683 ctx
->lpc_cof
= av_malloc(sizeof(*ctx
->lpc_cof
) * num_buffers
);
1684 ctx
->quant_cof_buffer
= av_malloc(sizeof(*ctx
->quant_cof_buffer
) *
1685 num_buffers
* sconf
->max_order
);
1686 ctx
->lpc_cof_buffer
= av_malloc(sizeof(*ctx
->lpc_cof_buffer
) *
1687 num_buffers
* sconf
->max_order
);
1688 ctx
->lpc_cof_reversed_buffer
= av_malloc(sizeof(*ctx
->lpc_cof_buffer
) *
1691 if (!ctx
->quant_cof
|| !ctx
->lpc_cof
||
1692 !ctx
->quant_cof_buffer
|| !ctx
->lpc_cof_buffer
||
1693 !ctx
->lpc_cof_reversed_buffer
) {
1694 av_log(avctx
, AV_LOG_ERROR
, "Allocating buffer memory failed.\n");
1695 ret
= AVERROR(ENOMEM
);
1699 // assign quantized parcor coefficient buffers
1700 for (c
= 0; c
< num_buffers
; c
++) {
1701 ctx
->quant_cof
[c
] = ctx
->quant_cof_buffer
+ c
* sconf
->max_order
;
1702 ctx
->lpc_cof
[c
] = ctx
->lpc_cof_buffer
+ c
* sconf
->max_order
;
1705 // allocate and assign lag and gain data buffer for ltp mode
1706 ctx
->const_block
= av_malloc (sizeof(*ctx
->const_block
) * num_buffers
);
1707 ctx
->shift_lsbs
= av_malloc (sizeof(*ctx
->shift_lsbs
) * num_buffers
);
1708 ctx
->opt_order
= av_malloc (sizeof(*ctx
->opt_order
) * num_buffers
);
1709 ctx
->store_prev_samples
= av_malloc(sizeof(*ctx
->store_prev_samples
) * num_buffers
);
1710 ctx
->use_ltp
= av_mallocz(sizeof(*ctx
->use_ltp
) * num_buffers
);
1711 ctx
->ltp_lag
= av_malloc (sizeof(*ctx
->ltp_lag
) * num_buffers
);
1712 ctx
->ltp_gain
= av_malloc (sizeof(*ctx
->ltp_gain
) * num_buffers
);
1713 ctx
->ltp_gain_buffer
= av_malloc (sizeof(*ctx
->ltp_gain_buffer
) *
1716 if (!ctx
->const_block
|| !ctx
->shift_lsbs
||
1717 !ctx
->opt_order
|| !ctx
->store_prev_samples
||
1718 !ctx
->use_ltp
|| !ctx
->ltp_lag
||
1719 !ctx
->ltp_gain
|| !ctx
->ltp_gain_buffer
) {
1720 av_log(avctx
, AV_LOG_ERROR
, "Allocating buffer memory failed.\n");
1721 ret
= AVERROR(ENOMEM
);
1725 for (c
= 0; c
< num_buffers
; c
++)
1726 ctx
->ltp_gain
[c
] = ctx
->ltp_gain_buffer
+ c
* 5;
1728 // allocate and assign channel data buffer for mcc mode
1729 if (sconf
->mc_coding
) {
1730 ctx
->chan_data_buffer
= av_malloc(sizeof(*ctx
->chan_data_buffer
) *
1731 num_buffers
* num_buffers
);
1732 ctx
->chan_data
= av_malloc(sizeof(*ctx
->chan_data
) *
1734 ctx
->reverted_channels
= av_malloc(sizeof(*ctx
->reverted_channels
) *
1737 if (!ctx
->chan_data_buffer
|| !ctx
->chan_data
|| !ctx
->reverted_channels
) {
1738 av_log(avctx
, AV_LOG_ERROR
, "Allocating buffer memory failed.\n");
1739 ret
= AVERROR(ENOMEM
);
1743 for (c
= 0; c
< num_buffers
; c
++)
1744 ctx
->chan_data
[c
] = ctx
->chan_data_buffer
+ c
* num_buffers
;
1746 ctx
->chan_data
= NULL
;
1747 ctx
->chan_data_buffer
= NULL
;
1748 ctx
->reverted_channels
= NULL
;
1751 channel_size
= sconf
->frame_length
+ sconf
->max_order
;
1753 ctx
->prev_raw_samples
= av_malloc (sizeof(*ctx
->prev_raw_samples
) * sconf
->max_order
);
1754 ctx
->raw_buffer
= av_mallocz(sizeof(*ctx
-> raw_buffer
) * avctx
->channels
* channel_size
);
1755 ctx
->raw_samples
= av_malloc (sizeof(*ctx
-> raw_samples
) * avctx
->channels
);
1757 // allocate previous raw sample buffer
1758 if (!ctx
->prev_raw_samples
|| !ctx
->raw_buffer
|| !ctx
->raw_samples
) {
1759 av_log(avctx
, AV_LOG_ERROR
, "Allocating buffer memory failed.\n");
1760 ret
= AVERROR(ENOMEM
);
1764 // assign raw samples buffers
1765 ctx
->raw_samples
[0] = ctx
->raw_buffer
+ sconf
->max_order
;
1766 for (c
= 1; c
< avctx
->channels
; c
++)
1767 ctx
->raw_samples
[c
] = ctx
->raw_samples
[c
- 1] + channel_size
;
1769 // allocate crc buffer
1770 if (HAVE_BIGENDIAN
!= sconf
->msb_first
&& sconf
->crc_enabled
&&
1771 (avctx
->err_recognition
& (AV_EF_CRCCHECK
|AV_EF_CAREFUL
))) {
1772 ctx
->crc_buffer
= av_malloc(sizeof(*ctx
->crc_buffer
) *
1773 ctx
->cur_frame_length
*
1775 av_get_bytes_per_sample(avctx
->sample_fmt
));
1776 if (!ctx
->crc_buffer
) {
1777 av_log(avctx
, AV_LOG_ERROR
, "Allocating buffer memory failed.\n");
1778 ret
= AVERROR(ENOMEM
);
1783 ff_bswapdsp_init(&ctx
->bdsp
);
1793 /** Flush (reset) the frame ID after seeking.
1795 static av_cold
void flush(AVCodecContext
*avctx
)
1797 ALSDecContext
*ctx
= avctx
->priv_data
;
1803 AVCodec ff_als_decoder
= {
1805 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
1806 .type
= AVMEDIA_TYPE_AUDIO
,
1807 .id
= AV_CODEC_ID_MP4ALS
,
1808 .priv_data_size
= sizeof(ALSDecContext
),
1809 .init
= decode_init
,
1810 .close
= decode_end
,
1811 .decode
= decode_frame
,
1813 .capabilities
= CODEC_CAP_SUBFRAMES
| CODEC_CAP_DR1
,