FFmpeg
alsdec.c
Go to the documentation of this file.
1 /*
2  * MPEG-4 ALS decoder
3  * Copyright (c) 2009 Thilo Borgmann <thilo.borgmann _at_ mail.de>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * MPEG-4 ALS decoder
25  * @author Thilo Borgmann <thilo.borgmann _at_ mail.de>
26  */
27 
28 #include <inttypes.h>
29 
30 #include "avcodec.h"
31 #include "get_bits.h"
32 #include "unary.h"
33 #include "mpeg4audio.h"
34 #include "bgmc.h"
35 #include "bswapdsp.h"
36 #include "internal.h"
37 #include "mlz.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/crc.h"
40 #include "libavutil/softfloat_ieee754.h"
41 #include "libavutil/intfloat.h"
42 #include "libavutil/intreadwrite.h"
43 
44 #include <stdint.h>
45 
46 /** Rice parameters and corresponding index offsets for decoding the
47  * indices of scaled PARCOR values. The table chosen is set globally
48  * by the encoder and stored in ALSSpecificConfig.
49  */
50 static const int8_t parcor_rice_table[3][20][2] = {
51  { {-52, 4}, {-29, 5}, {-31, 4}, { 19, 4}, {-16, 4},
52  { 12, 3}, { -7, 3}, { 9, 3}, { -5, 3}, { 6, 3},
53  { -4, 3}, { 3, 3}, { -3, 2}, { 3, 2}, { -2, 2},
54  { 3, 2}, { -1, 2}, { 2, 2}, { -1, 2}, { 2, 2} },
55  { {-58, 3}, {-42, 4}, {-46, 4}, { 37, 5}, {-36, 4},
56  { 29, 4}, {-29, 4}, { 25, 4}, {-23, 4}, { 20, 4},
57  {-17, 4}, { 16, 4}, {-12, 4}, { 12, 3}, {-10, 4},
58  { 7, 3}, { -4, 4}, { 3, 3}, { -1, 3}, { 1, 3} },
59  { {-59, 3}, {-45, 5}, {-50, 4}, { 38, 4}, {-39, 4},
60  { 32, 4}, {-30, 4}, { 25, 3}, {-23, 3}, { 20, 3},
61  {-20, 3}, { 16, 3}, {-13, 3}, { 10, 3}, { -7, 3},
62  { 3, 3}, { 0, 3}, { -1, 3}, { 2, 3}, { -1, 2} }
63 };
64 
65 
66 /** Scaled PARCOR values used for the first two PARCOR coefficients.
67  * To be indexed by the Rice coded indices.
68  * Generated by: parcor_scaled_values[i] = 32 + ((i * (i+1)) << 7) - (1 << 20)
69  * Actual values are divided by 32 in order to be stored in 16 bits.
70  */
71 static const int16_t parcor_scaled_values[] = {
72  -1048544 / 32, -1048288 / 32, -1047776 / 32, -1047008 / 32,
73  -1045984 / 32, -1044704 / 32, -1043168 / 32, -1041376 / 32,
74  -1039328 / 32, -1037024 / 32, -1034464 / 32, -1031648 / 32,
75  -1028576 / 32, -1025248 / 32, -1021664 / 32, -1017824 / 32,
76  -1013728 / 32, -1009376 / 32, -1004768 / 32, -999904 / 32,
77  -994784 / 32, -989408 / 32, -983776 / 32, -977888 / 32,
78  -971744 / 32, -965344 / 32, -958688 / 32, -951776 / 32,
79  -944608 / 32, -937184 / 32, -929504 / 32, -921568 / 32,
80  -913376 / 32, -904928 / 32, -896224 / 32, -887264 / 32,
81  -878048 / 32, -868576 / 32, -858848 / 32, -848864 / 32,
82  -838624 / 32, -828128 / 32, -817376 / 32, -806368 / 32,
83  -795104 / 32, -783584 / 32, -771808 / 32, -759776 / 32,
84  -747488 / 32, -734944 / 32, -722144 / 32, -709088 / 32,
85  -695776 / 32, -682208 / 32, -668384 / 32, -654304 / 32,
86  -639968 / 32, -625376 / 32, -610528 / 32, -595424 / 32,
87  -580064 / 32, -564448 / 32, -548576 / 32, -532448 / 32,
88  -516064 / 32, -499424 / 32, -482528 / 32, -465376 / 32,
89  -447968 / 32, -430304 / 32, -412384 / 32, -394208 / 32,
90  -375776 / 32, -357088 / 32, -338144 / 32, -318944 / 32,
91  -299488 / 32, -279776 / 32, -259808 / 32, -239584 / 32,
92  -219104 / 32, -198368 / 32, -177376 / 32, -156128 / 32,
93  -134624 / 32, -112864 / 32, -90848 / 32, -68576 / 32,
94  -46048 / 32, -23264 / 32, -224 / 32, 23072 / 32,
95  46624 / 32, 70432 / 32, 94496 / 32, 118816 / 32,
96  143392 / 32, 168224 / 32, 193312 / 32, 218656 / 32,
97  244256 / 32, 270112 / 32, 296224 / 32, 322592 / 32,
98  349216 / 32, 376096 / 32, 403232 / 32, 430624 / 32,
99  458272 / 32, 486176 / 32, 514336 / 32, 542752 / 32,
100  571424 / 32, 600352 / 32, 629536 / 32, 658976 / 32,
101  688672 / 32, 718624 / 32, 748832 / 32, 779296 / 32,
102  810016 / 32, 840992 / 32, 872224 / 32, 903712 / 32,
103  935456 / 32, 967456 / 32, 999712 / 32, 1032224 / 32
104 };
105 
106 
107 /** Gain values of p(0) for long-term prediction.
108  * To be indexed by the Rice coded indices.
109  */
110 static const uint8_t ltp_gain_values [4][4] = {
111  { 0, 8, 16, 24},
112  {32, 40, 48, 56},
113  {64, 70, 76, 82},
114  {88, 92, 96, 100}
115 };
116 
117 
118 /** Inter-channel weighting factors for multi-channel correlation.
119  * To be indexed by the Rice coded indices.
120  */
121 static const int16_t mcc_weightings[] = {
122  204, 192, 179, 166, 153, 140, 128, 115,
123  102, 89, 76, 64, 51, 38, 25, 12,
124  0, -12, -25, -38, -51, -64, -76, -89,
125  -102, -115, -128, -140, -153, -166, -179, -192
126 };
127 
128 
129 /** Tail codes used in arithmetic coding using block Gilbert-Moore codes.
130  */
131 static const uint8_t tail_code[16][6] = {
132  { 74, 44, 25, 13, 7, 3},
133  { 68, 42, 24, 13, 7, 3},
134  { 58, 39, 23, 13, 7, 3},
135  {126, 70, 37, 19, 10, 5},
136  {132, 70, 37, 20, 10, 5},
137  {124, 70, 38, 20, 10, 5},
138  {120, 69, 37, 20, 11, 5},
139  {116, 67, 37, 20, 11, 5},
140  {108, 66, 36, 20, 10, 5},
141  {102, 62, 36, 20, 10, 5},
142  { 88, 58, 34, 19, 10, 5},
143  {162, 89, 49, 25, 13, 7},
144  {156, 87, 49, 26, 14, 7},
145  {150, 86, 47, 26, 14, 7},
146  {142, 84, 47, 26, 14, 7},
147  {131, 79, 46, 26, 14, 7}
148 };
149 
150 
151 enum RA_Flag {
152  RA_FLAG_NONE,
153  RA_FLAG_FRAMES,
154  RA_FLAG_HEADER
155 };
156 
157 
158 typedef struct ALSSpecificConfig {
159  uint32_t samples; ///< number of samples, 0xFFFFFFFF if unknown
160  int resolution; ///< 000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
161  int floating; ///< 1 = IEEE 32-bit floating-point, 0 = integer
162  int msb_first; ///< 1 = original CRC calculated on big-endian system, 0 = little-endian
163  int frame_length; ///< frame length for each frame (last frame may differ)
164  int ra_distance; ///< distance between RA frames (in frames, 0...255)
165  enum RA_Flag ra_flag; ///< indicates where the size of ra units is stored
166  int adapt_order; ///< adaptive order: 1 = on, 0 = off
167  int coef_table; ///< table index of Rice code parameters
168  int long_term_prediction; ///< long term prediction (LTP): 1 = on, 0 = off
169  int max_order; ///< maximum prediction order (0..1023)
170  int block_switching; ///< number of block switching levels
171  int bgmc; ///< "Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only)
172  int sb_part; ///< sub-block partition
173  int joint_stereo; ///< joint stereo: 1 = on, 0 = off
174  int mc_coding; ///< extended inter-channel coding (multi channel coding): 1 = on, 0 = off
175  int chan_config; ///< indicates that a chan_config_info field is present
176  int chan_sort; ///< channel rearrangement: 1 = on, 0 = off
177  int rlslms; ///< use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off
178  int chan_config_info; ///< mapping of channels to loudspeaker locations. Unused until setting channel configuration is implemented.
179  int *chan_pos; ///< original channel positions
180  int crc_enabled; ///< enable Cyclic Redundancy Checksum
181 } ALSSpecificConfig;
182 
183 
184 typedef struct ALSChannelData {
185  int stop_flag;
186  int master_channel;
187  int time_diff_flag;
188  int time_diff_sign;
189  int time_diff_index;
190  int weighting[6];
191 } ALSChannelData;
192 
193 
194 typedef struct ALSDecContext {
195  AVCodecContext *avctx;
196  ALSSpecificConfig sconf;
197  GetBitContext gb;
198  BswapDSPContext bdsp;
199  const AVCRC *crc_table;
200  uint32_t crc_org; ///< CRC value of the original input data
201  uint32_t crc; ///< CRC value calculated from decoded data
202  unsigned int cur_frame_length; ///< length of the current frame to decode
203  unsigned int frame_id; ///< the frame ID / number of the current frame
204  unsigned int js_switch; ///< if true, joint-stereo decoding is enforced
205  unsigned int cs_switch; ///< if true, channel rearrangement is done
206  unsigned int num_blocks; ///< number of blocks used in the current frame
207  unsigned int s_max; ///< maximum Rice parameter allowed in entropy coding
208  uint8_t *bgmc_lut; ///< pointer at lookup tables used for BGMC
209  int *bgmc_lut_status; ///< pointer at lookup table status flags used for BGMC
210  int ltp_lag_length; ///< number of bits used for ltp lag value
211  int *const_block; ///< contains const_block flags for all channels
212  unsigned int *shift_lsbs; ///< contains shift_lsbs flags for all channels
213  unsigned int *opt_order; ///< contains opt_order flags for all channels
214  int *store_prev_samples; ///< contains store_prev_samples flags for all channels
215  int *use_ltp; ///< contains use_ltp flags for all channels
216  int *ltp_lag; ///< contains ltp lag values for all channels
217  int **ltp_gain; ///< gain values for ltp 5-tap filter for a channel
218  int *ltp_gain_buffer; ///< contains all gain values for ltp 5-tap filter
219  int32_t **quant_cof; ///< quantized parcor coefficients for a channel
220  int32_t *quant_cof_buffer; ///< contains all quantized parcor coefficients
221  int32_t **lpc_cof; ///< coefficients of the direct form prediction filter for a channel
222  int32_t *lpc_cof_buffer; ///< contains all coefficients of the direct form prediction filter
223  int32_t *lpc_cof_reversed_buffer; ///< temporary buffer to set up a reversed versio of lpc_cof_buffer
224  ALSChannelData **chan_data; ///< channel data for multi-channel correlation
225  ALSChannelData *chan_data_buffer; ///< contains channel data for all channels
226  int *reverted_channels; ///< stores a flag for each reverted channel
227  int32_t *prev_raw_samples; ///< contains unshifted raw samples from the previous block
228  int32_t **raw_samples; ///< decoded raw samples for each channel
229  int32_t *raw_buffer; ///< contains all decoded raw samples including carryover samples
230  uint8_t *crc_buffer; ///< buffer of byte order corrected samples used for CRC check
231  MLZ* mlz; ///< masked lz decompression structure
232  SoftFloat_IEEE754 *acf; ///< contains common multiplier for all channels
233  int *last_acf_mantissa; ///< contains the last acf mantissa data of common multiplier for all channels
234  int *shift_value; ///< value by which the binary point is to be shifted for all channels
235  int *last_shift_value; ///< contains last shift value for all channels
236  int **raw_mantissa; ///< decoded mantissa bits of the difference signal
237  unsigned char *larray; ///< buffer to store the output of masked lz decompression
238  int *nbits; ///< contains the number of bits to read for masked lz decompression for all samples
239  int highest_decoded_channel;
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_config2(&m4ac, avctx->extradata,
307  avctx->extradata_size, 1, avctx);
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  if (avctx->channels > FF_SANE_NB_CHANNELS) {
353  avpriv_request_sample(avctx, "Huge number of channels");
354  return AVERROR_PATCHWELCOME;
355  }
356 
357  ctx->cur_frame_length = sconf->frame_length;
358 
359  // read channel config
360  if (sconf->chan_config)
361  sconf->chan_config_info = get_bits(&gb, 16);
362  // TODO: use this to set avctx->channel_layout
363 
364 
365  // read channel sorting
366  if (sconf->chan_sort && avctx->channels > 1) {
367  int chan_pos_bits = av_ceil_log2(avctx->channels);
368  int bits_needed = avctx->channels * chan_pos_bits + 7;
369  if (get_bits_left(&gb) < bits_needed)
370  return AVERROR_INVALIDDATA;
371 
372  if (!(sconf->chan_pos = av_malloc_array(avctx->channels, sizeof(*sconf->chan_pos))))
373  return AVERROR(ENOMEM);
374 
375  ctx->cs_switch = 1;
376 
377  for (i = 0; i < avctx->channels; i++) {
378  sconf->chan_pos[i] = -1;
379  }
380 
381  for (i = 0; i < avctx->channels; i++) {
382  int idx;
383 
384  idx = get_bits(&gb, chan_pos_bits);
385  if (idx >= avctx->channels || sconf->chan_pos[idx] != -1) {
386  av_log(avctx, AV_LOG_WARNING, "Invalid channel reordering.\n");
387  ctx->cs_switch = 0;
388  break;
389  }
390  sconf->chan_pos[idx] = i;
391  }
392 
393  align_get_bits(&gb);
394  }
395 
396 
397  // read fixed header and trailer sizes,
398  // if size = 0xFFFFFFFF then there is no data field!
399  if (get_bits_left(&gb) < 64)
400  return AVERROR_INVALIDDATA;
401 
402  header_size = get_bits_long(&gb, 32);
403  trailer_size = get_bits_long(&gb, 32);
404  if (header_size == 0xFFFFFFFF)
405  header_size = 0;
406  if (trailer_size == 0xFFFFFFFF)
407  trailer_size = 0;
408 
409  ht_size = ((int64_t)(header_size) + (int64_t)(trailer_size)) << 3;
410 
411 
412  // skip the header and trailer data
413  if (get_bits_left(&gb) < ht_size)
414  return AVERROR_INVALIDDATA;
415 
416  if (ht_size > INT32_MAX)
417  return AVERROR_PATCHWELCOME;
418 
419  skip_bits_long(&gb, ht_size);
420 
421 
422  // initialize CRC calculation
423  if (sconf->crc_enabled) {
424  if (get_bits_left(&gb) < 32)
425  return AVERROR_INVALIDDATA;
426 
427  if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
428  ctx->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE);
429  ctx->crc = 0xFFFFFFFF;
430  ctx->crc_org = ~get_bits_long(&gb, 32);
431  } else
432  skip_bits_long(&gb, 32);
433  }
434 
435 
436  // no need to read the rest of ALSSpecificConfig (ra_unit_size & aux data)
437 
438  dprint_specific_config(ctx);
439 
440  return 0;
441 }
442 
443 
444 /** Check the ALSSpecificConfig for unsupported features.
445  */
446 static int check_specific_config(ALSDecContext *ctx)
447 {
448  ALSSpecificConfig *sconf = &ctx->sconf;
449  int error = 0;
450 
451  // report unsupported feature and set error value
452  #define MISSING_ERR(cond, str, errval) \
453  { \
454  if (cond) { \
455  avpriv_report_missing_feature(ctx->avctx, \
456  str); \
457  error = errval; \
458  } \
459  }
460 
461  MISSING_ERR(sconf->rlslms, "Adaptive RLS-LMS prediction", AVERROR_PATCHWELCOME);
462 
463  return error;
464 }
465 
466 
467 /** Parse the bs_info field to extract the block partitioning used in
468  * block switching mode, refer to ISO/IEC 14496-3, section 11.6.2.
469  */
470 static void parse_bs_info(const uint32_t bs_info, unsigned int n,
471  unsigned int div, unsigned int **div_blocks,
472  unsigned int *num_blocks)
473 {
474  if (n < 31 && ((bs_info << n) & 0x40000000)) {
475  // if the level is valid and the investigated bit n is set
476  // then recursively check both children at bits (2n+1) and (2n+2)
477  n *= 2;
478  div += 1;
479  parse_bs_info(bs_info, n + 1, div, div_blocks, num_blocks);
480  parse_bs_info(bs_info, n + 2, div, div_blocks, num_blocks);
481  } else {
482  // else the bit is not set or the last level has been reached
483  // (bit implicitly not set)
484  **div_blocks = div;
485  (*div_blocks)++;
486  (*num_blocks)++;
487  }
488 }
489 
490 
491 /** Read and decode a Rice codeword.
492  */
493 static int32_t decode_rice(GetBitContext *gb, unsigned int k)
494 {
495  int max = get_bits_left(gb) - k;
496  unsigned q = get_unary(gb, 0, max);
497  int r = k ? get_bits1(gb) : !(q & 1);
498 
499  if (k > 1) {
500  q <<= (k - 1);
501  q += get_bits_long(gb, k - 1);
502  } else if (!k) {
503  q >>= 1;
504  }
505  return r ? q : ~q;
506 }
507 
508 
509 /** Convert PARCOR coefficient k to direct filter coefficient.
510  */
511 static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
512 {
513  int i, j;
514 
515  for (i = 0, j = k - 1; i < j; i++, j--) {
516  unsigned tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
517  cof[j] += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20);
518  cof[i] += tmp1;
519  }
520  if (i == j)
521  cof[i] += ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
522 
523  cof[k] = par[k];
524 }
525 
526 
527 /** Read block switching field if necessary and set actual block sizes.
528  * Also assure that the block sizes of the last frame correspond to the
529  * actual number of samples.
530  */
531 static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks,
532  uint32_t *bs_info)
533 {
534  ALSSpecificConfig *sconf = &ctx->sconf;
535  GetBitContext *gb = &ctx->gb;
536  unsigned int *ptr_div_blocks = div_blocks;
537  unsigned int b;
538 
539  if (sconf->block_switching) {
540  unsigned int bs_info_len = 1 << (sconf->block_switching + 2);
541  *bs_info = get_bits_long(gb, bs_info_len);
542  *bs_info <<= (32 - bs_info_len);
543  }
544 
545  ctx->num_blocks = 0;
546  parse_bs_info(*bs_info, 0, 0, &ptr_div_blocks, &ctx->num_blocks);
547 
548  // The last frame may have an overdetermined block structure given in
549  // the bitstream. In that case the defined block structure would need
550  // more samples than available to be consistent.
551  // The block structure is actually used but the block sizes are adapted
552  // to fit the actual number of available samples.
553  // Example: 5 samples, 2nd level block sizes: 2 2 2 2.
554  // This results in the actual block sizes: 2 2 1 0.
555  // This is not specified in 14496-3 but actually done by the reference
556  // codec RM22 revision 2.
557  // This appears to happen in case of an odd number of samples in the last
558  // frame which is actually not allowed by the block length switching part
559  // of 14496-3.
560  // The ALS conformance files feature an odd number of samples in the last
561  // frame.
562 
563  for (b = 0; b < ctx->num_blocks; b++)
564  div_blocks[b] = ctx->sconf.frame_length >> div_blocks[b];
565 
566  if (ctx->cur_frame_length != ctx->sconf.frame_length) {
567  unsigned int remaining = ctx->cur_frame_length;
568 
569  for (b = 0; b < ctx->num_blocks; b++) {
570  if (remaining <= div_blocks[b]) {
571  div_blocks[b] = remaining;
572  ctx->num_blocks = b + 1;
573  break;
574  }
575 
576  remaining -= div_blocks[b];
577  }
578  }
579 }
580 
581 
582 /** Read the block data for a constant block
583  */
584 static int read_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
585 {
586  ALSSpecificConfig *sconf = &ctx->sconf;
587  AVCodecContext *avctx = ctx->avctx;
588  GetBitContext *gb = &ctx->gb;
589 
590  if (bd->block_length <= 0)
591  return AVERROR_INVALIDDATA;
592 
593  *bd->raw_samples = 0;
594  *bd->const_block = get_bits1(gb); // 1 = constant value, 0 = zero block (silence)
595  bd->js_blocks = get_bits1(gb);
596 
597  // skip 5 reserved bits
598  skip_bits(gb, 5);
599 
600  if (*bd->const_block) {
601  unsigned int const_val_bits = sconf->floating ? 24 : avctx->bits_per_raw_sample;
602  *bd->raw_samples = get_sbits_long(gb, const_val_bits);
603  }
604 
605  // ensure constant block decoding by reusing this field
606  *bd->const_block = 1;
607 
608  return 0;
609 }
610 
611 
612 /** Decode the block data for a constant block
613  */
614 static void decode_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
615 {
616  int smp = bd->block_length - 1;
617  int32_t val = *bd->raw_samples;
618  int32_t *dst = bd->raw_samples + 1;
619 
620  // write raw samples into buffer
621  for (; smp; smp--)
622  *dst++ = val;
623 }
624 
625 
626 /** Read the block data for a non-constant block
627  */
628 static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
629 {
630  ALSSpecificConfig *sconf = &ctx->sconf;
631  AVCodecContext *avctx = ctx->avctx;
632  GetBitContext *gb = &ctx->gb;
633  unsigned int k;
634  unsigned int s[8];
635  unsigned int sx[8];
636  unsigned int sub_blocks, log2_sub_blocks, sb_length;
637  unsigned int start = 0;
638  unsigned int opt_order;
639  int sb;
640  int32_t *quant_cof = bd->quant_cof;
641  int32_t *current_res;
642 
643 
644  // ensure variable block decoding by reusing this field
645  *bd->const_block = 0;
646 
647  *bd->opt_order = 1;
648  bd->js_blocks = get_bits1(gb);
649 
650  opt_order = *bd->opt_order;
651 
652  // determine the number of subblocks for entropy decoding
653  if (!sconf->bgmc && !sconf->sb_part) {
654  log2_sub_blocks = 0;
655  } else {
656  if (sconf->bgmc && sconf->sb_part)
657  log2_sub_blocks = get_bits(gb, 2);
658  else
659  log2_sub_blocks = 2 * get_bits1(gb);
660  }
661 
662  sub_blocks = 1 << log2_sub_blocks;
663 
664  // do not continue in case of a damaged stream since
665  // block_length must be evenly divisible by sub_blocks
666  if (bd->block_length & (sub_blocks - 1) || bd->block_length <= 0) {
667  av_log(avctx, AV_LOG_WARNING,
668  "Block length is not evenly divisible by the number of subblocks.\n");
669  return AVERROR_INVALIDDATA;
670  }
671 
672  sb_length = bd->block_length >> log2_sub_blocks;
673 
674  if (sconf->bgmc) {
675  s[0] = get_bits(gb, 8 + (sconf->resolution > 1));
676  for (k = 1; k < sub_blocks; k++)
677  s[k] = s[k - 1] + decode_rice(gb, 2);
678 
679  for (k = 0; k < sub_blocks; k++) {
680  sx[k] = s[k] & 0x0F;
681  s [k] >>= 4;
682  }
683  } else {
684  s[0] = get_bits(gb, 4 + (sconf->resolution > 1));
685  for (k = 1; k < sub_blocks; k++)
686  s[k] = s[k - 1] + decode_rice(gb, 0);
687  }
688  for (k = 1; k < sub_blocks; k++)
689  if (s[k] > 32) {
690  av_log(avctx, AV_LOG_ERROR, "k invalid for rice code.\n");
691  return AVERROR_INVALIDDATA;
692  }
693 
694  if (get_bits1(gb))
695  *bd->shift_lsbs = get_bits(gb, 4) + 1;
696 
697  *bd->store_prev_samples = (bd->js_blocks && bd->raw_other) || *bd->shift_lsbs;
698 
699 
700  if (!sconf->rlslms) {
701  if (sconf->adapt_order && sconf->max_order) {
702  int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1,
703  2, sconf->max_order + 1));
704  *bd->opt_order = get_bits(gb, opt_order_length);
705  if (*bd->opt_order > sconf->max_order) {
706  *bd->opt_order = sconf->max_order;
707  av_log(avctx, AV_LOG_ERROR, "Predictor order too large.\n");
708  return AVERROR_INVALIDDATA;
709  }
710  } else {
711  *bd->opt_order = sconf->max_order;
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] * (1U << 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) * 8;
777  bd->ltp_gain[1] = decode_rice(gb, 2) * 8;
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) * 8;
789  bd->ltp_gain[4] = decode_rice(gb, 1) * 8;
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  start = FFMIN(opt_order, 3);
799  av_assert0(sb_length <= sconf->frame_length);
800  if (sb_length <= start) {
801  // opt_order or sb_length may be corrupted, either way this is unsupported and not well defined in the specification
802  av_log(avctx, AV_LOG_ERROR, "Sub block length smaller or equal start\n");
803  return AVERROR_PATCHWELCOME;
804  }
805 
806  if (opt_order)
807  bd->raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4);
808  if (opt_order > 1)
809  bd->raw_samples[1] = decode_rice(gb, FFMIN(s[0] + 3, ctx->s_max));
810  if (opt_order > 2)
811  bd->raw_samples[2] = decode_rice(gb, FFMIN(s[0] + 1, ctx->s_max));
812  }
813 
814  // read all residuals
815  if (sconf->bgmc) {
816  int delta[8];
817  unsigned int k [8];
818  unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5);
819 
820  // read most significant bits
821  unsigned int high;
822  unsigned int low;
823  unsigned int value;
824 
825  int ret = ff_bgmc_decode_init(gb, &high, &low, &value);
826  if (ret < 0)
827  return ret;
828 
829  current_res = bd->raw_samples + start;
830 
831  for (sb = 0; sb < sub_blocks; sb++) {
832  unsigned int sb_len = sb_length - (sb ? 0 : start);
833 
834  k [sb] = s[sb] > b ? s[sb] - b : 0;
835  delta[sb] = 5 - s[sb] + k[sb];
836 
837  if (k[sb] >= 32)
838  return AVERROR_INVALIDDATA;
839 
840  ff_bgmc_decode(gb, sb_len, current_res,
841  delta[sb], sx[sb], &high, &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);
842 
843  current_res += sb_len;
844  }
845 
846  ff_bgmc_decode_end(gb);
847 
848 
849  // read least significant bits and tails
850  current_res = bd->raw_samples + start;
851 
852  for (sb = 0; sb < sub_blocks; sb++, start = 0) {
853  unsigned int cur_tail_code = tail_code[sx[sb]][delta[sb]];
854  unsigned int cur_k = k[sb];
855  unsigned int cur_s = s[sb];
856 
857  for (; start < sb_length; start++) {
858  int32_t res = *current_res;
859 
860  if (res == cur_tail_code) {
861  unsigned int max_msb = (2 + (sx[sb] > 2) + (sx[sb] > 10))
862  << (5 - delta[sb]);
863 
864  res = decode_rice(gb, cur_s);
865 
866  if (res >= 0) {
867  res += (max_msb ) << cur_k;
868  } else {
869  res -= (max_msb - 1) << cur_k;
870  }
871  } else {
872  if (res > cur_tail_code)
873  res--;
874 
875  if (res & 1)
876  res = -res;
877 
878  res >>= 1;
879 
880  if (cur_k) {
881  res *= 1U << cur_k;
882  res |= get_bits_long(gb, cur_k);
883  }
884  }
885 
886  *current_res++ = res;
887  }
888  }
889  } else {
890  current_res = bd->raw_samples + start;
891 
892  for (sb = 0; sb < sub_blocks; sb++, start = 0)
893  for (; start < sb_length; start++)
894  *current_res++ = decode_rice(gb, s[sb]);
895  }
896 
897  return 0;
898 }
899 
900 
901 /** Decode the block data for a non-constant block
902  */
903 static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
904 {
905  ALSSpecificConfig *sconf = &ctx->sconf;
906  unsigned int block_length = bd->block_length;
907  unsigned int smp = 0;
908  unsigned int k;
909  int opt_order = *bd->opt_order;
910  int sb;
911  int64_t y;
912  int32_t *quant_cof = bd->quant_cof;
913  int32_t *lpc_cof = bd->lpc_cof;
914  int32_t *raw_samples = bd->raw_samples;
915  int32_t *raw_samples_end = bd->raw_samples + bd->block_length;
916  int32_t *lpc_cof_reversed = ctx->lpc_cof_reversed_buffer;
917 
918  // reverse long-term prediction
919  if (*bd->use_ltp) {
920  int ltp_smp;
921 
922  for (ltp_smp = FFMAX(*bd->ltp_lag - 2, 0); ltp_smp < block_length; ltp_smp++) {
923  int center = ltp_smp - *bd->ltp_lag;
924  int begin = FFMAX(0, center - 2);
925  int end = center + 3;
926  int tab = 5 - (end - begin);
927  int base;
928 
929  y = 1 << 6;
930 
931  for (base = begin; base < end; base++, tab++)
932  y += (uint64_t)MUL64(bd->ltp_gain[tab], raw_samples[base]);
933 
934  raw_samples[ltp_smp] += y >> 7;
935  }
936  }
937 
938  // reconstruct all samples from residuals
939  if (bd->ra_block) {
940  for (smp = 0; smp < FFMIN(opt_order, block_length); smp++) {
941  y = 1 << 19;
942 
943  for (sb = 0; sb < smp; sb++)
944  y += (uint64_t)MUL64(lpc_cof[sb], raw_samples[-(sb + 1)]);
945 
946  *raw_samples++ -= y >> 20;
947  parcor_to_lpc(smp, quant_cof, lpc_cof);
948  }
949  } else {
950  for (k = 0; k < opt_order; k++)
951  parcor_to_lpc(k, quant_cof, lpc_cof);
952 
953  // store previous samples in case that they have to be altered
954  if (*bd->store_prev_samples)
955  memcpy(bd->prev_raw_samples, raw_samples - sconf->max_order,
956  sizeof(*bd->prev_raw_samples) * sconf->max_order);
957 
958  // reconstruct difference signal for prediction (joint-stereo)
959  if (bd->js_blocks && bd->raw_other) {
960  uint32_t *left, *right;
961 
962  if (bd->raw_other > raw_samples) { // D = R - L
963  left = raw_samples;
964  right = bd->raw_other;
965  } else { // D = R - L
966  left = bd->raw_other;
967  right = raw_samples;
968  }
969 
970  for (sb = -1; sb >= -sconf->max_order; sb--)
971  raw_samples[sb] = right[sb] - left[sb];
972  }
973 
974  // reconstruct shifted signal
975  if (*bd->shift_lsbs)
976  for (sb = -1; sb >= -sconf->max_order; sb--)
977  raw_samples[sb] >>= *bd->shift_lsbs;
978  }
979 
980  // reverse linear prediction coefficients for efficiency
981  lpc_cof = lpc_cof + opt_order;
982 
983  for (sb = 0; sb < opt_order; sb++)
984  lpc_cof_reversed[sb] = lpc_cof[-(sb + 1)];
985 
986  // reconstruct raw samples
987  raw_samples = bd->raw_samples + smp;
988  lpc_cof = lpc_cof_reversed + opt_order;
989 
990  for (; raw_samples < raw_samples_end; raw_samples++) {
991  y = 1 << 19;
992 
993  for (sb = -opt_order; sb < 0; sb++)
994  y += (uint64_t)MUL64(lpc_cof[sb], raw_samples[sb]);
995 
996  *raw_samples -= y >> 20;
997  }
998 
999  raw_samples = bd->raw_samples;
1000 
1001  // restore previous samples in case that they have been altered
1002  if (*bd->store_prev_samples)
1003  memcpy(raw_samples - sconf->max_order, bd->prev_raw_samples,
1004  sizeof(*raw_samples) * sconf->max_order);
1005 
1006  return 0;
1007 }
1008 
1009 
1010 /** Read the block data.
1011  */
1012 static int read_block(ALSDecContext *ctx, ALSBlockData *bd)
1013 {
1014  int ret;
1015  GetBitContext *gb = &ctx->gb;
1016  ALSSpecificConfig *sconf = &ctx->sconf;
1017 
1018  *bd->shift_lsbs = 0;
1019 
1020  if (get_bits_left(gb) < 1)
1021  return AVERROR_INVALIDDATA;
1022 
1023  // read block type flag and read the samples accordingly
1024  if (get_bits1(gb)) {
1025  ret = read_var_block_data(ctx, bd);
1026  } else {
1027  ret = read_const_block_data(ctx, bd);
1028  }
1029 
1030  if (!sconf->mc_coding || ctx->js_switch)
1031  align_get_bits(gb);
1032 
1033  return ret;
1034 }
1035 
1036 
1037 /** Decode the block data.
1038  */
1039 static int decode_block(ALSDecContext *ctx, ALSBlockData *bd)
1040 {
1041  unsigned int smp;
1042  int ret = 0;
1043 
1044  // read block type flag and read the samples accordingly
1045  if (*bd->const_block)
1046  decode_const_block_data(ctx, bd);
1047  else
1048  ret = decode_var_block_data(ctx, bd); // always return 0
1049 
1050  if (ret < 0)
1051  return ret;
1052 
1053  // TODO: read RLSLMS extension data
1054 
1055  if (*bd->shift_lsbs)
1056  for (smp = 0; smp < bd->block_length; smp++)
1057  bd->raw_samples[smp] = (unsigned)bd->raw_samples[smp] << *bd->shift_lsbs;
1058 
1059  return 0;
1060 }
1061 
1062 
1063 /** Read and decode block data successively.
1064  */
1065 static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd)
1066 {
1067  int ret;
1068 
1069  if ((ret = read_block(ctx, bd)) < 0)
1070  return ret;
1071 
1072  return decode_block(ctx, bd);
1073 }
1074 
1075 
1076 /** Compute the number of samples left to decode for the current frame and
1077  * sets these samples to zero.
1078  */
1079 static void zero_remaining(unsigned int b, unsigned int b_max,
1080  const unsigned int *div_blocks, int32_t *buf)
1081 {
1082  unsigned int count = 0;
1083 
1084  while (b < b_max)
1085  count += div_blocks[b++];
1086 
1087  if (count)
1088  memset(buf, 0, sizeof(*buf) * count);
1089 }
1090 
1091 
1092 /** Decode blocks independently.
1093  */
1094 static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame,
1095  unsigned int c, const unsigned int *div_blocks,
1096  unsigned int *js_blocks)
1097 {
1098  int ret;
1099  unsigned int b;
1100  ALSBlockData bd = { 0 };
1101 
1102  bd.ra_block = ra_frame;
1103  bd.const_block = ctx->const_block;
1104  bd.shift_lsbs = ctx->shift_lsbs;
1105  bd.opt_order = ctx->opt_order;
1106  bd.store_prev_samples = ctx->store_prev_samples;
1107  bd.use_ltp = ctx->use_ltp;
1108  bd.ltp_lag = ctx->ltp_lag;
1109  bd.ltp_gain = ctx->ltp_gain[0];
1110  bd.quant_cof = ctx->quant_cof[0];
1111  bd.lpc_cof = ctx->lpc_cof[0];
1112  bd.prev_raw_samples = ctx->prev_raw_samples;
1113  bd.raw_samples = ctx->raw_samples[c];
1114 
1115 
1116  for (b = 0; b < ctx->num_blocks; b++) {
1117  bd.block_length = div_blocks[b];
1118 
1119  if ((ret = read_decode_block(ctx, &bd)) < 0) {
1120  // damaged block, write zero for the rest of the frame
1121  zero_remaining(b, ctx->num_blocks, div_blocks, bd.raw_samples);
1122  return ret;
1123  }
1124  bd.raw_samples += div_blocks[b];
1125  bd.ra_block = 0;
1126  }
1127 
1128  return 0;
1129 }
1130 
1131 
1132 /** Decode blocks dependently.
1133  */
1134 static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame,
1135  unsigned int c, const unsigned int *div_blocks,
1136  unsigned int *js_blocks)
1137 {
1138  ALSSpecificConfig *sconf = &ctx->sconf;
1139  unsigned int offset = 0;
1140  unsigned int b;
1141  int ret;
1142  ALSBlockData bd[2] = { { 0 } };
1143 
1144  bd[0].ra_block = ra_frame;
1145  bd[0].const_block = ctx->const_block;
1146  bd[0].shift_lsbs = ctx->shift_lsbs;
1147  bd[0].opt_order = ctx->opt_order;
1148  bd[0].store_prev_samples = ctx->store_prev_samples;
1149  bd[0].use_ltp = ctx->use_ltp;
1150  bd[0].ltp_lag = ctx->ltp_lag;
1151  bd[0].ltp_gain = ctx->ltp_gain[0];
1152  bd[0].quant_cof = ctx->quant_cof[0];
1153  bd[0].lpc_cof = ctx->lpc_cof[0];
1154  bd[0].prev_raw_samples = ctx->prev_raw_samples;
1155  bd[0].js_blocks = *js_blocks;
1156 
1157  bd[1].ra_block = ra_frame;
1158  bd[1].const_block = ctx->const_block;
1159  bd[1].shift_lsbs = ctx->shift_lsbs;
1160  bd[1].opt_order = ctx->opt_order;
1161  bd[1].store_prev_samples = ctx->store_prev_samples;
1162  bd[1].use_ltp = ctx->use_ltp;
1163  bd[1].ltp_lag = ctx->ltp_lag;
1164  bd[1].ltp_gain = ctx->ltp_gain[0];
1165  bd[1].quant_cof = ctx->quant_cof[0];
1166  bd[1].lpc_cof = ctx->lpc_cof[0];
1167  bd[1].prev_raw_samples = ctx->prev_raw_samples;
1168  bd[1].js_blocks = *(js_blocks + 1);
1169 
1170  // decode all blocks
1171  for (b = 0; b < ctx->num_blocks; b++) {
1172  unsigned int s;
1173 
1174  bd[0].block_length = div_blocks[b];
1175  bd[1].block_length = div_blocks[b];
1176 
1177  bd[0].raw_samples = ctx->raw_samples[c ] + offset;
1178  bd[1].raw_samples = ctx->raw_samples[c + 1] + offset;
1179 
1180  bd[0].raw_other = bd[1].raw_samples;
1181  bd[1].raw_other = bd[0].raw_samples;
1182 
1183  if ((ret = read_decode_block(ctx, &bd[0])) < 0 ||
1184  (ret = read_decode_block(ctx, &bd[1])) < 0)
1185  goto fail;
1186 
1187  // reconstruct joint-stereo blocks
1188  if (bd[0].js_blocks) {
1189  if (bd[1].js_blocks)
1190  av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair.\n");
1191 
1192  for (s = 0; s < div_blocks[b]; s++)
1193  bd[0].raw_samples[s] = bd[1].raw_samples[s] - (unsigned)bd[0].raw_samples[s];
1194  } else if (bd[1].js_blocks) {
1195  for (s = 0; s < div_blocks[b]; s++)
1196  bd[1].raw_samples[s] = bd[1].raw_samples[s] + (unsigned)bd[0].raw_samples[s];
1197  }
1198 
1199  offset += div_blocks[b];
1200  bd[0].ra_block = 0;
1201  bd[1].ra_block = 0;
1202  }
1203 
1204  // store carryover raw samples,
1205  // the others channel raw samples are stored by the calling function.
1206  memmove(ctx->raw_samples[c] - sconf->max_order,
1207  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1208  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1209 
1210  return 0;
1211 fail:
1212  // damaged block, write zero for the rest of the frame
1213  zero_remaining(b, ctx->num_blocks, div_blocks, bd[0].raw_samples);
1214  zero_remaining(b, ctx->num_blocks, div_blocks, bd[1].raw_samples);
1215  return ret;
1216 }
1217 
1218 static inline int als_weighting(GetBitContext *gb, int k, int off)
1219 {
1220  int idx = av_clip(decode_rice(gb, k) + off,
1221  0, FF_ARRAY_ELEMS(mcc_weightings) - 1);
1222  return mcc_weightings[idx];
1223 }
1224 
1225 /** Read the channel data.
1226  */
1227 static int read_channel_data(ALSDecContext *ctx, ALSChannelData *cd, int c)
1228 {
1229  GetBitContext *gb = &ctx->gb;
1230  ALSChannelData *current = cd;
1231  unsigned int channels = ctx->avctx->channels;
1232  int entries = 0;
1233 
1234  while (entries < channels && !(current->stop_flag = get_bits1(gb))) {
1235  current->master_channel = get_bits_long(gb, av_ceil_log2(channels));
1236 
1237  if (current->master_channel >= channels) {
1238  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid master channel.\n");
1239  return AVERROR_INVALIDDATA;
1240  }
1241 
1242  if (current->master_channel != c) {
1243  current->time_diff_flag = get_bits1(gb);
1244  current->weighting[0] = als_weighting(gb, 1, 16);
1245  current->weighting[1] = als_weighting(gb, 2, 14);
1246  current->weighting[2] = als_weighting(gb, 1, 16);
1247 
1248  if (current->time_diff_flag) {
1249  current->weighting[3] = als_weighting(gb, 1, 16);
1250  current->weighting[4] = als_weighting(gb, 1, 16);
1251  current->weighting[5] = als_weighting(gb, 1, 16);
1252 
1253  current->time_diff_sign = get_bits1(gb);
1254  current->time_diff_index = get_bits(gb, ctx->ltp_lag_length - 3) + 3;
1255  }
1256  }
1257 
1258  current++;
1259  entries++;
1260  }
1261 
1262  if (entries == channels) {
1263  av_log(ctx->avctx, AV_LOG_ERROR, "Damaged channel data.\n");
1264  return AVERROR_INVALIDDATA;
1265  }
1266 
1267  align_get_bits(gb);
1268  return 0;
1269 }
1270 
1271 
1272 /** Recursively reverts the inter-channel correlation for a block.
1273  */
1274 static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd,
1275  ALSChannelData **cd, int *reverted,
1276  unsigned int offset, int c)
1277 {
1278  ALSChannelData *ch = cd[c];
1279  unsigned int dep = 0;
1280  unsigned int channels = ctx->avctx->channels;
1281  unsigned int channel_size = ctx->sconf.frame_length + ctx->sconf.max_order;
1282 
1283  if (reverted[c])
1284  return 0;
1285 
1286  reverted[c] = 1;
1287 
1288  while (dep < channels && !ch[dep].stop_flag) {
1289  revert_channel_correlation(ctx, bd, cd, reverted, offset,
1290  ch[dep].master_channel);
1291 
1292  dep++;
1293  }
1294 
1295  if (dep == channels) {
1296  av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation.\n");
1297  return AVERROR_INVALIDDATA;
1298  }
1299 
1300  bd->const_block = ctx->const_block + c;
1301  bd->shift_lsbs = ctx->shift_lsbs + c;
1302  bd->opt_order = ctx->opt_order + c;
1303  bd->store_prev_samples = ctx->store_prev_samples + c;
1304  bd->use_ltp = ctx->use_ltp + c;
1305  bd->ltp_lag = ctx->ltp_lag + c;
1306  bd->ltp_gain = ctx->ltp_gain[c];
1307  bd->lpc_cof = ctx->lpc_cof[c];
1308  bd->quant_cof = ctx->quant_cof[c];
1309  bd->raw_samples = ctx->raw_samples[c] + offset;
1310 
1311  for (dep = 0; !ch[dep].stop_flag; dep++) {
1312  ptrdiff_t smp;
1313  ptrdiff_t begin = 1;
1314  ptrdiff_t end = bd->block_length - 1;
1315  int64_t y;
1316  int32_t *master = ctx->raw_samples[ch[dep].master_channel] + offset;
1317 
1318  if (ch[dep].master_channel == c)
1319  continue;
1320 
1321  if (ch[dep].time_diff_flag) {
1322  int t = ch[dep].time_diff_index;
1323 
1324  if (ch[dep].time_diff_sign) {
1325  t = -t;
1326  if (begin < t) {
1327  av_log(ctx->avctx, AV_LOG_ERROR, "begin %"PTRDIFF_SPECIFIER" smaller than time diff index %d.\n", begin, t);
1328  return AVERROR_INVALIDDATA;
1329  }
1330  begin -= t;
1331  } else {
1332  if (end < t) {
1333  av_log(ctx->avctx, AV_LOG_ERROR, "end %"PTRDIFF_SPECIFIER" smaller than time diff index %d.\n", end, t);
1334  return AVERROR_INVALIDDATA;
1335  }
1336  end -= t;
1337  }
1338 
1339  if (FFMIN(begin - 1, begin - 1 + t) < ctx->raw_buffer - master ||
1340  FFMAX(end + 1, end + 1 + t) > ctx->raw_buffer + channels * channel_size - master) {
1341  av_log(ctx->avctx, AV_LOG_ERROR,
1342  "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n",
1343  master + FFMIN(begin - 1, begin - 1 + t), master + FFMAX(end + 1, end + 1 + t),
1344  ctx->raw_buffer, ctx->raw_buffer + channels * channel_size);
1345  return AVERROR_INVALIDDATA;
1346  }
1347 
1348  for (smp = begin; smp < end; smp++) {
1349  y = (1 << 6) +
1350  MUL64(ch[dep].weighting[0], master[smp - 1 ]) +
1351  MUL64(ch[dep].weighting[1], master[smp ]) +
1352  MUL64(ch[dep].weighting[2], master[smp + 1 ]) +
1353  MUL64(ch[dep].weighting[3], master[smp - 1 + t]) +
1354  MUL64(ch[dep].weighting[4], master[smp + t]) +
1355  MUL64(ch[dep].weighting[5], master[smp + 1 + t]);
1356 
1357  bd->raw_samples[smp] += y >> 7;
1358  }
1359  } else {
1360 
1361  if (begin - 1 < ctx->raw_buffer - master ||
1362  end + 1 > ctx->raw_buffer + channels * channel_size - master) {
1363  av_log(ctx->avctx, AV_LOG_ERROR,
1364  "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n",
1365  master + begin - 1, master + end + 1,
1366  ctx->raw_buffer, ctx->raw_buffer + channels * channel_size);
1367  return AVERROR_INVALIDDATA;
1368  }
1369 
1370  for (smp = begin; smp < end; smp++) {
1371  y = (1 << 6) +
1372  MUL64(ch[dep].weighting[0], master[smp - 1]) +
1373  MUL64(ch[dep].weighting[1], master[smp ]) +
1374  MUL64(ch[dep].weighting[2], master[smp + 1]);
1375 
1376  bd->raw_samples[smp] += y >> 7;
1377  }
1378  }
1379  }
1380 
1381  return 0;
1382 }
1383 
1384 
1385 /** multiply two softfloats and handle the rounding off
1386  */
1387 static SoftFloat_IEEE754 multiply(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b) {
1388  uint64_t mantissa_temp;
1389  uint64_t mask_64;
1390  int cutoff_bit_count;
1391  unsigned char last_2_bits;
1392  unsigned int mantissa;
1393  int32_t sign;
1394  uint32_t return_val = 0;
1395  int bit_count = 48;
1396 
1397  sign = a.sign ^ b.sign;
1398 
1399  // Multiply mantissa bits in a 64-bit register
1400  mantissa_temp = (uint64_t)a.mant * (uint64_t)b.mant;
1401  mask_64 = (uint64_t)0x1 << 47;
1402 
1403  if (!mantissa_temp)
1404  return FLOAT_0;
1405 
1406  // Count the valid bit count
1407  while (!(mantissa_temp & mask_64) && mask_64) {
1408  bit_count--;
1409  mask_64 >>= 1;
1410  }
1411 
1412  // Round off
1413  cutoff_bit_count = bit_count - 24;
1414  if (cutoff_bit_count > 0) {
1415  last_2_bits = (unsigned char)(((unsigned int)mantissa_temp >> (cutoff_bit_count - 1)) & 0x3 );
1416  if ((last_2_bits == 0x3) || ((last_2_bits == 0x1) && ((unsigned int)mantissa_temp & ((0x1UL << (cutoff_bit_count - 1)) - 1)))) {
1417  // Need to round up
1418  mantissa_temp += (uint64_t)0x1 << cutoff_bit_count;
1419  }
1420  }
1421 
1422  if (cutoff_bit_count >= 0) {
1423  mantissa = (unsigned int)(mantissa_temp >> cutoff_bit_count);
1424  } else {
1425  mantissa = (unsigned int)(mantissa_temp <<-cutoff_bit_count);
1426  }
1427 
1428  // Need one more shift?
1429  if (mantissa & 0x01000000ul) {
1430  bit_count++;
1431  mantissa >>= 1;
1432  }
1433 
1434  if (!sign) {
1435  return_val = 0x80000000U;
1436  }
1437 
1438  return_val |= ((unsigned)av_clip(a.exp + b.exp + bit_count - 47, -126, 127) << 23) & 0x7F800000;
1439  return_val |= mantissa;
1440  return av_bits2sf_ieee754(return_val);
1441 }
1442 
1443 
1444 /** Read and decode the floating point sample data
1445  */
1446 static int read_diff_float_data(ALSDecContext *ctx, unsigned int ra_frame) {
1447  AVCodecContext *avctx = ctx->avctx;
1448  GetBitContext *gb = &ctx->gb;
1449  SoftFloat_IEEE754 *acf = ctx->acf;
1450  int *shift_value = ctx->shift_value;
1451  int *last_shift_value = ctx->last_shift_value;
1452  int *last_acf_mantissa = ctx->last_acf_mantissa;
1453  int **raw_mantissa = ctx->raw_mantissa;
1454  int *nbits = ctx->nbits;
1455  unsigned char *larray = ctx->larray;
1456  int frame_length = ctx->cur_frame_length;
1457  SoftFloat_IEEE754 scale = av_int2sf_ieee754(0x1u, 23);
1458  unsigned int partA_flag;
1459  unsigned int highest_byte;
1460  unsigned int shift_amp;
1461  uint32_t tmp_32;
1462  int use_acf;
1463  int nchars;
1464  int i;
1465  int c;
1466  long k;
1467  long nbits_aligned;
1468  unsigned long acc;
1469  unsigned long j;
1470  uint32_t sign;
1471  uint32_t e;
1472  uint32_t mantissa;
1473 
1474  skip_bits_long(gb, 32); //num_bytes_diff_float
1475  use_acf = get_bits1(gb);
1476 
1477  if (ra_frame) {
1478  memset(last_acf_mantissa, 0, avctx->channels * sizeof(*last_acf_mantissa));
1479  memset(last_shift_value, 0, avctx->channels * sizeof(*last_shift_value) );
1480  ff_mlz_flush_dict(ctx->mlz);
1481  }
1482 
1483  if (avctx->channels * 8 > get_bits_left(gb))
1484  return AVERROR_INVALIDDATA;
1485 
1486  for (c = 0; c < avctx->channels; ++c) {
1487  if (use_acf) {
1488  //acf_flag
1489  if (get_bits1(gb)) {
1490  tmp_32 = get_bits(gb, 23);
1491  last_acf_mantissa[c] = tmp_32;
1492  } else {
1493  tmp_32 = last_acf_mantissa[c];
1494  }
1495  acf[c] = av_bits2sf_ieee754(tmp_32);
1496  } else {
1497  acf[c] = FLOAT_1;
1498  }
1499 
1500  highest_byte = get_bits(gb, 2);
1501  partA_flag = get_bits1(gb);
1502  shift_amp = get_bits1(gb);
1503 
1504  if (shift_amp) {
1505  shift_value[c] = get_bits(gb, 8);
1506  last_shift_value[c] = shift_value[c];
1507  } else {
1508  shift_value[c] = last_shift_value[c];
1509  }
1510 
1511  if (partA_flag) {
1512  if (!get_bits1(gb)) { //uncompressed
1513  for (i = 0; i < frame_length; ++i) {
1514  if (ctx->raw_samples[c][i] == 0) {
1515  ctx->raw_mantissa[c][i] = get_bits_long(gb, 32);
1516  }
1517  }
1518  } else { //compressed
1519  nchars = 0;
1520  for (i = 0; i < frame_length; ++i) {
1521  if (ctx->raw_samples[c][i] == 0) {
1522  nchars += 4;
1523  }
1524  }
1525 
1526  tmp_32 = ff_mlz_decompression(ctx->mlz, gb, nchars, larray);
1527  if(tmp_32 != nchars) {
1528  av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%"PRId32", %d).\n", tmp_32, nchars);
1529  return AVERROR_INVALIDDATA;
1530  }
1531 
1532  for (i = 0; i < frame_length; ++i) {
1533  ctx->raw_mantissa[c][i] = AV_RB32(larray);
1534  }
1535  }
1536  }
1537 
1538  //decode part B
1539  if (highest_byte) {
1540  for (i = 0; i < frame_length; ++i) {
1541  if (ctx->raw_samples[c][i] != 0) {
1542  //The following logic is taken from Tabel 14.45 and 14.46 from the ISO spec
1543  if (av_cmp_sf_ieee754(acf[c], FLOAT_1)) {
1544  nbits[i] = 23 - av_log2(abs(ctx->raw_samples[c][i]));
1545  } else {
1546  nbits[i] = 23;
1547  }
1548  nbits[i] = FFMIN(nbits[i], highest_byte*8);
1549  }
1550  }
1551 
1552  if (!get_bits1(gb)) { //uncompressed
1553  for (i = 0; i < frame_length; ++i) {
1554  if (ctx->raw_samples[c][i] != 0) {
1555  raw_mantissa[c][i] = get_bitsz(gb, nbits[i]);
1556  }
1557  }
1558  } else { //compressed
1559  nchars = 0;
1560  for (i = 0; i < frame_length; ++i) {
1561  if (ctx->raw_samples[c][i]) {
1562  nchars += (int) nbits[i] / 8;
1563  if (nbits[i] & 7) {
1564  ++nchars;
1565  }
1566  }
1567  }
1568 
1569  tmp_32 = ff_mlz_decompression(ctx->mlz, gb, nchars, larray);
1570  if(tmp_32 != nchars) {
1571  av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%"PRId32", %d).\n", tmp_32, nchars);
1572  return AVERROR_INVALIDDATA;
1573  }
1574 
1575  j = 0;
1576  for (i = 0; i < frame_length; ++i) {
1577  if (ctx->raw_samples[c][i]) {
1578  if (nbits[i] & 7) {
1579  nbits_aligned = 8 * ((unsigned int)(nbits[i] / 8) + 1);
1580  } else {
1581  nbits_aligned = nbits[i];
1582  }
1583  acc = 0;
1584  for (k = 0; k < nbits_aligned/8; ++k) {
1585  acc = (acc << 8) + larray[j++];
1586  }
1587  acc >>= (nbits_aligned - nbits[i]);
1588  raw_mantissa[c][i] = acc;
1589  }
1590  }
1591  }
1592  }
1593 
1594  for (i = 0; i < frame_length; ++i) {
1595  SoftFloat_IEEE754 pcm_sf = av_int2sf_ieee754(ctx->raw_samples[c][i], 0);
1596  pcm_sf = av_div_sf_ieee754(pcm_sf, scale);
1597 
1598  if (ctx->raw_samples[c][i] != 0) {
1599  if (!av_cmp_sf_ieee754(acf[c], FLOAT_1)) {
1600  pcm_sf = multiply(acf[c], pcm_sf);
1601  }
1602 
1603  sign = pcm_sf.sign;
1604  e = pcm_sf.exp;
1605  mantissa = (pcm_sf.mant | 0x800000) + raw_mantissa[c][i];
1606 
1607  while(mantissa >= 0x1000000) {
1608  e++;
1609  mantissa >>= 1;
1610  }
1611 
1612  if (mantissa) e += (shift_value[c] - 127);
1613  mantissa &= 0x007fffffUL;
1614 
1615  tmp_32 = (sign << 31) | ((e + EXP_BIAS) << 23) | (mantissa);
1616  ctx->raw_samples[c][i] = tmp_32;
1617  } else {
1618  ctx->raw_samples[c][i] = raw_mantissa[c][i] & 0x007fffffUL;
1619  }
1620  }
1621  align_get_bits(gb);
1622  }
1623  return 0;
1624 }
1625 
1626 
1627 /** Read the frame data.
1628  */
1629 static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
1630 {
1631  ALSSpecificConfig *sconf = &ctx->sconf;
1632  AVCodecContext *avctx = ctx->avctx;
1633  GetBitContext *gb = &ctx->gb;
1634  unsigned int div_blocks[32]; ///< block sizes.
1635  int c;
1636  unsigned int js_blocks[2];
1637  uint32_t bs_info = 0;
1638  int ret;
1639 
1640  // skip the size of the ra unit if present in the frame
1641  if (sconf->ra_flag == RA_FLAG_FRAMES && ra_frame)
1642  skip_bits_long(gb, 32);
1643 
1644  if (sconf->mc_coding && sconf->joint_stereo) {
1645  ctx->js_switch = get_bits1(gb);
1646  align_get_bits(gb);
1647  }
1648 
1649  if (!sconf->mc_coding || ctx->js_switch) {
1650  int independent_bs = !sconf->joint_stereo;
1651 
1652  for (c = 0; c < avctx->channels; c++) {
1653  js_blocks[0] = 0;
1654  js_blocks[1] = 0;
1655 
1656  get_block_sizes(ctx, div_blocks, &bs_info);
1657 
1658  // if joint_stereo and block_switching is set, independent decoding
1659  // is signaled via the first bit of bs_info
1660  if (sconf->joint_stereo && sconf->block_switching)
1661  if (bs_info >> 31)
1662  independent_bs = 2;
1663 
1664  // if this is the last channel, it has to be decoded independently
1665  if (c == avctx->channels - 1 || (c & 1))
1666  independent_bs = 1;
1667 
1668  if (independent_bs) {
1669  ret = decode_blocks_ind(ctx, ra_frame, c,
1670  div_blocks, js_blocks);
1671  if (ret < 0)
1672  return ret;
1673  independent_bs--;
1674  } else {
1675  ret = decode_blocks(ctx, ra_frame, c, div_blocks, js_blocks);
1676  if (ret < 0)
1677  return ret;
1678 
1679  c++;
1680  }
1681 
1682  // store carryover raw samples
1683  memmove(ctx->raw_samples[c] - sconf->max_order,
1684  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1685  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1686  ctx->highest_decoded_channel = c;
1687  }
1688  } else { // multi-channel coding
1689  ALSBlockData bd = { 0 };
1690  int b, ret;
1691  int *reverted_channels = ctx->reverted_channels;
1692  unsigned int offset = 0;
1693 
1694  for (c = 0; c < avctx->channels; c++)
1695  if (ctx->chan_data[c] < ctx->chan_data_buffer) {
1696  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid channel data.\n");
1697  return AVERROR_INVALIDDATA;
1698  }
1699 
1700  memset(reverted_channels, 0, sizeof(*reverted_channels) * avctx->channels);
1701 
1702  bd.ra_block = ra_frame;
1703  bd.prev_raw_samples = ctx->prev_raw_samples;
1704 
1705  get_block_sizes(ctx, div_blocks, &bs_info);
1706 
1707  for (b = 0; b < ctx->num_blocks; b++) {
1708  bd.block_length = div_blocks[b];
1709  if (bd.block_length <= 0) {
1710  av_log(ctx->avctx, AV_LOG_WARNING,
1711  "Invalid block length %u in channel data!\n",
1712  bd.block_length);
1713  continue;
1714  }
1715 
1716  for (c = 0; c < avctx->channels; c++) {
1717  bd.const_block = ctx->const_block + c;
1718  bd.shift_lsbs = ctx->shift_lsbs + c;
1719  bd.opt_order = ctx->opt_order + c;
1720  bd.store_prev_samples = ctx->store_prev_samples + c;
1721  bd.use_ltp = ctx->use_ltp + c;
1722  bd.ltp_lag = ctx->ltp_lag + c;
1723  bd.ltp_gain = ctx->ltp_gain[c];
1724  bd.lpc_cof = ctx->lpc_cof[c];
1725  bd.quant_cof = ctx->quant_cof[c];
1726  bd.raw_samples = ctx->raw_samples[c] + offset;
1727  bd.raw_other = NULL;
1728 
1729  if ((ret = read_block(ctx, &bd)) < 0)
1730  return ret;
1731  if ((ret = read_channel_data(ctx, ctx->chan_data[c], c)) < 0)
1732  return ret;
1733  }
1734 
1735  for (c = 0; c < avctx->channels; c++) {
1736  ret = revert_channel_correlation(ctx, &bd, ctx->chan_data,
1737  reverted_channels, offset, c);
1738  if (ret < 0)
1739  return ret;
1740  }
1741  for (c = 0; c < avctx->channels; c++) {
1742  bd.const_block = ctx->const_block + c;
1743  bd.shift_lsbs = ctx->shift_lsbs + c;
1744  bd.opt_order = ctx->opt_order + c;
1745  bd.store_prev_samples = ctx->store_prev_samples + c;
1746  bd.use_ltp = ctx->use_ltp + c;
1747  bd.ltp_lag = ctx->ltp_lag + c;
1748  bd.ltp_gain = ctx->ltp_gain[c];
1749  bd.lpc_cof = ctx->lpc_cof[c];
1750  bd.quant_cof = ctx->quant_cof[c];
1751  bd.raw_samples = ctx->raw_samples[c] + offset;
1752 
1753  if ((ret = decode_block(ctx, &bd)) < 0)
1754  return ret;
1755 
1756  ctx->highest_decoded_channel = FFMAX(ctx->highest_decoded_channel, c);
1757  }
1758 
1759  memset(reverted_channels, 0, avctx->channels * sizeof(*reverted_channels));
1760  offset += div_blocks[b];
1761  bd.ra_block = 0;
1762  }
1763 
1764  // store carryover raw samples
1765  for (c = 0; c < avctx->channels; c++)
1766  memmove(ctx->raw_samples[c] - sconf->max_order,
1767  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1768  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1769  }
1770 
1771  if (sconf->floating) {
1772  read_diff_float_data(ctx, ra_frame);
1773  }
1774 
1775  if (get_bits_left(gb) < 0) {
1776  av_log(ctx->avctx, AV_LOG_ERROR, "Overread %d\n", -get_bits_left(gb));
1777  return AVERROR_INVALIDDATA;
1778  }
1779 
1780  return 0;
1781 }
1782 
1783 
1784 /** Decode an ALS frame.
1785  */
1786 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1787  AVPacket *avpkt)
1788 {
1789  ALSDecContext *ctx = avctx->priv_data;
1790  AVFrame *frame = data;
1791  ALSSpecificConfig *sconf = &ctx->sconf;
1792  const uint8_t *buffer = avpkt->data;
1793  int buffer_size = avpkt->size;
1794  int invalid_frame, ret;
1795  unsigned int c, sample, ra_frame, bytes_read, shift;
1796 
1797  if ((ret = init_get_bits8(&ctx->gb, buffer, buffer_size)) < 0)
1798  return ret;
1799 
1800  // In the case that the distance between random access frames is set to zero
1801  // (sconf->ra_distance == 0) no frame is treated as a random access frame.
1802  // For the first frame, if prediction is used, all samples used from the
1803  // previous frame are assumed to be zero.
1804  ra_frame = sconf->ra_distance && !(ctx->frame_id % sconf->ra_distance);
1805 
1806  // the last frame to decode might have a different length
1807  if (sconf->samples != 0xFFFFFFFF)
1808  ctx->cur_frame_length = FFMIN(sconf->samples - ctx->frame_id * (uint64_t) sconf->frame_length,
1809  sconf->frame_length);
1810  else
1811  ctx->cur_frame_length = sconf->frame_length;
1812 
1813  ctx->highest_decoded_channel = -1;
1814  // decode the frame data
1815  if ((invalid_frame = read_frame_data(ctx, ra_frame)) < 0)
1816  av_log(ctx->avctx, AV_LOG_WARNING,
1817  "Reading frame data failed. Skipping RA unit.\n");
1818 
1819  if (ctx->highest_decoded_channel == -1) {
1820  av_log(ctx->avctx, AV_LOG_WARNING,
1821  "No channel data decoded.\n");
1822  return AVERROR_INVALIDDATA;
1823  }
1824 
1825  ctx->frame_id++;
1826 
1827  /* get output buffer */
1828  frame->nb_samples = ctx->cur_frame_length;
1829  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1830  return ret;
1831 
1832  // transform decoded frame into output format
1833  #define INTERLEAVE_OUTPUT(bps) \
1834  { \
1835  int##bps##_t *dest = (int##bps##_t*)frame->data[0]; \
1836  int channels = avctx->channels; \
1837  int32_t *raw_samples = ctx->raw_samples[0]; \
1838  int raw_step = channels > 1 ? ctx->raw_samples[1] - raw_samples : 1; \
1839  shift = bps - ctx->avctx->bits_per_raw_sample; \
1840  if (!ctx->cs_switch) { \
1841  for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1842  for (c = 0; c < channels; c++) \
1843  *dest++ = raw_samples[c*raw_step + sample] * (1U << shift); \
1844  } else { \
1845  for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1846  for (c = 0; c < channels; c++) \
1847  *dest++ = raw_samples[sconf->chan_pos[c]*raw_step + sample] * (1U << shift);\
1848  } \
1849  }
1850 
1851  if (ctx->avctx->bits_per_raw_sample <= 16) {
1852  INTERLEAVE_OUTPUT(16)
1853  } else {
1854  INTERLEAVE_OUTPUT(32)
1855  }
1856 
1857  // update CRC
1858  if (sconf->crc_enabled && (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) {
1859  int swap = HAVE_BIGENDIAN != sconf->msb_first;
1860 
1861  if (ctx->avctx->bits_per_raw_sample == 24) {
1862  int32_t *src = (int32_t *)frame->data[0];
1863 
1864  for (sample = 0;
1865  sample < ctx->cur_frame_length * avctx->channels;
1866  sample++) {
1867  int32_t v;
1868 
1869  if (swap)
1870  v = av_bswap32(src[sample]);
1871  else
1872  v = src[sample];
1873  if (!HAVE_BIGENDIAN)
1874  v >>= 8;
1875 
1876  ctx->crc = av_crc(ctx->crc_table, ctx->crc, (uint8_t*)(&v), 3);
1877  }
1878  } else {
1879  uint8_t *crc_source;
1880 
1881  if (swap) {
1882  if (ctx->avctx->bits_per_raw_sample <= 16) {
1883  int16_t *src = (int16_t*) frame->data[0];
1884  int16_t *dest = (int16_t*) ctx->crc_buffer;
1885  for (sample = 0;
1886  sample < ctx->cur_frame_length * avctx->channels;
1887  sample++)
1888  *dest++ = av_bswap16(src[sample]);
1889  } else {
1890  ctx->bdsp.bswap_buf((uint32_t *) ctx->crc_buffer,
1891  (uint32_t *) frame->data[0],
1892  ctx->cur_frame_length * avctx->channels);
1893  }
1894  crc_source = ctx->crc_buffer;
1895  } else {
1896  crc_source = frame->data[0];
1897  }
1898 
1899  ctx->crc = av_crc(ctx->crc_table, ctx->crc, crc_source,
1900  ctx->cur_frame_length * avctx->channels *
1901  av_get_bytes_per_sample(avctx->sample_fmt));
1902  }
1903 
1904 
1905  // check CRC sums if this is the last frame
1906  if (ctx->cur_frame_length != sconf->frame_length &&
1907  ctx->crc_org != ctx->crc) {
1908  av_log(avctx, AV_LOG_ERROR, "CRC error.\n");
1909  if (avctx->err_recognition & AV_EF_EXPLODE)
1910  return AVERROR_INVALIDDATA;
1911  }
1912  }
1913 
1914  *got_frame_ptr = 1;
1915 
1916  bytes_read = invalid_frame ? buffer_size :
1917  (get_bits_count(&ctx->gb) + 7) >> 3;
1918 
1919  return bytes_read;
1920 }
1921 
1922 
1923 /** Uninitialize the ALS decoder.
1924  */
1925 static av_cold int decode_end(AVCodecContext *avctx)
1926 {
1927  ALSDecContext *ctx = avctx->priv_data;
1928  int i;
1929 
1930  av_freep(&ctx->sconf.chan_pos);
1931 
1932  ff_bgmc_end(&ctx->bgmc_lut, &ctx->bgmc_lut_status);
1933 
1934  av_freep(&ctx->const_block);
1935  av_freep(&ctx->shift_lsbs);
1936  av_freep(&ctx->opt_order);
1937  av_freep(&ctx->store_prev_samples);
1938  av_freep(&ctx->use_ltp);
1939  av_freep(&ctx->ltp_lag);
1940  av_freep(&ctx->ltp_gain);
1941  av_freep(&ctx->ltp_gain_buffer);
1942  av_freep(&ctx->quant_cof);
1943  av_freep(&ctx->lpc_cof);
1944  av_freep(&ctx->quant_cof_buffer);
1945  av_freep(&ctx->lpc_cof_buffer);
1946  av_freep(&ctx->lpc_cof_reversed_buffer);
1947  av_freep(&ctx->prev_raw_samples);
1948  av_freep(&ctx->raw_samples);
1949  av_freep(&ctx->raw_buffer);
1950  av_freep(&ctx->chan_data);
1951  av_freep(&ctx->chan_data_buffer);
1952  av_freep(&ctx->reverted_channels);
1953  av_freep(&ctx->crc_buffer);
1954  if (ctx->mlz) {
1955  av_freep(&ctx->mlz->dict);
1956  av_freep(&ctx->mlz);
1957  }
1958  av_freep(&ctx->acf);
1959  av_freep(&ctx->last_acf_mantissa);
1960  av_freep(&ctx->shift_value);
1961  av_freep(&ctx->last_shift_value);
1962  if (ctx->raw_mantissa) {
1963  for (i = 0; i < avctx->channels; i++) {
1964  av_freep(&ctx->raw_mantissa[i]);
1965  }
1966  av_freep(&ctx->raw_mantissa);
1967  }
1968  av_freep(&ctx->larray);
1969  av_freep(&ctx->nbits);
1970 
1971  return 0;
1972 }
1973 
1974 
1975 /** Initialize the ALS decoder.
1976  */
1977 static av_cold int decode_init(AVCodecContext *avctx)
1978 {
1979  unsigned int c;
1980  unsigned int channel_size;
1981  int num_buffers, ret;
1982  ALSDecContext *ctx = avctx->priv_data;
1983  ALSSpecificConfig *sconf = &ctx->sconf;
1984  ctx->avctx = avctx;
1985 
1986  if (!avctx->extradata) {
1987  av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata.\n");
1988  return AVERROR_INVALIDDATA;
1989  }
1990 
1991  if ((ret = read_specific_config(ctx)) < 0) {
1992  av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n");
1993  goto fail;
1994  }
1995 
1996  if ((ret = check_specific_config(ctx)) < 0) {
1997  goto fail;
1998  }
1999 
2000  if (sconf->bgmc) {
2001  ret = ff_bgmc_init(avctx, &ctx->bgmc_lut, &ctx->bgmc_lut_status);
2002  if (ret < 0)
2003  goto fail;
2004  }
2005  if (sconf->floating) {
2006  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
2007  avctx->bits_per_raw_sample = 32;
2008  } else {
2009  avctx->sample_fmt = sconf->resolution > 1
2010  ? AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16;
2011  avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8;
2012  if (avctx->bits_per_raw_sample > 32) {
2013  av_log(avctx, AV_LOG_ERROR, "Bits per raw sample %d larger than 32.\n",
2014  avctx->bits_per_raw_sample);
2015  ret = AVERROR_INVALIDDATA;
2016  goto fail;
2017  }
2018  }
2019 
2020  // set maximum Rice parameter for progressive decoding based on resolution
2021  // This is not specified in 14496-3 but actually done by the reference
2022  // codec RM22 revision 2.
2023  ctx->s_max = sconf->resolution > 1 ? 31 : 15;
2024 
2025  // set lag value for long-term prediction
2026  ctx->ltp_lag_length = 8 + (avctx->sample_rate >= 96000) +
2027  (avctx->sample_rate >= 192000);
2028 
2029  // allocate quantized parcor coefficient buffer
2030  num_buffers = sconf->mc_coding ? avctx->channels : 1;
2031  if (num_buffers * (uint64_t)num_buffers > INT_MAX) // protect chan_data_buffer allocation
2032  return AVERROR_INVALIDDATA;
2033 
2034  ctx->quant_cof = av_malloc_array(num_buffers, sizeof(*ctx->quant_cof));
2035  ctx->lpc_cof = av_malloc_array(num_buffers, sizeof(*ctx->lpc_cof));
2036  ctx->quant_cof_buffer = av_malloc_array(num_buffers * sconf->max_order,
2037  sizeof(*ctx->quant_cof_buffer));
2038  ctx->lpc_cof_buffer = av_malloc_array(num_buffers * sconf->max_order,
2039  sizeof(*ctx->lpc_cof_buffer));
2040  ctx->lpc_cof_reversed_buffer = av_malloc_array(sconf->max_order,
2041  sizeof(*ctx->lpc_cof_buffer));
2042 
2043  if (!ctx->quant_cof || !ctx->lpc_cof ||
2044  !ctx->quant_cof_buffer || !ctx->lpc_cof_buffer ||
2045  !ctx->lpc_cof_reversed_buffer) {
2046  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2047  ret = AVERROR(ENOMEM);
2048  goto fail;
2049  }
2050 
2051  // assign quantized parcor coefficient buffers
2052  for (c = 0; c < num_buffers; c++) {
2053  ctx->quant_cof[c] = ctx->quant_cof_buffer + c * sconf->max_order;
2054  ctx->lpc_cof[c] = ctx->lpc_cof_buffer + c * sconf->max_order;
2055  }
2056 
2057  // allocate and assign lag and gain data buffer for ltp mode
2058  ctx->const_block = av_malloc_array(num_buffers, sizeof(*ctx->const_block));
2059  ctx->shift_lsbs = av_malloc_array(num_buffers, sizeof(*ctx->shift_lsbs));
2060  ctx->opt_order = av_malloc_array(num_buffers, sizeof(*ctx->opt_order));
2061  ctx->store_prev_samples = av_malloc_array(num_buffers, sizeof(*ctx->store_prev_samples));
2062  ctx->use_ltp = av_mallocz_array(num_buffers, sizeof(*ctx->use_ltp));
2063  ctx->ltp_lag = av_malloc_array(num_buffers, sizeof(*ctx->ltp_lag));
2064  ctx->ltp_gain = av_malloc_array(num_buffers, sizeof(*ctx->ltp_gain));
2065  ctx->ltp_gain_buffer = av_malloc_array(num_buffers * 5, sizeof(*ctx->ltp_gain_buffer));
2066 
2067  if (!ctx->const_block || !ctx->shift_lsbs ||
2068  !ctx->opt_order || !ctx->store_prev_samples ||
2069  !ctx->use_ltp || !ctx->ltp_lag ||
2070  !ctx->ltp_gain || !ctx->ltp_gain_buffer) {
2071  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2072  ret = AVERROR(ENOMEM);
2073  goto fail;
2074  }
2075 
2076  for (c = 0; c < num_buffers; c++)
2077  ctx->ltp_gain[c] = ctx->ltp_gain_buffer + c * 5;
2078 
2079  // allocate and assign channel data buffer for mcc mode
2080  if (sconf->mc_coding) {
2081  ctx->chan_data_buffer = av_mallocz_array(num_buffers * num_buffers,
2082  sizeof(*ctx->chan_data_buffer));
2083  ctx->chan_data = av_mallocz_array(num_buffers,
2084  sizeof(*ctx->chan_data));
2085  ctx->reverted_channels = av_malloc_array(num_buffers,
2086  sizeof(*ctx->reverted_channels));
2087 
2088  if (!ctx->chan_data_buffer || !ctx->chan_data || !ctx->reverted_channels) {
2089  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2090  ret = AVERROR(ENOMEM);
2091  goto fail;
2092  }
2093 
2094  for (c = 0; c < num_buffers; c++)
2095  ctx->chan_data[c] = ctx->chan_data_buffer + c * num_buffers;
2096  } else {
2097  ctx->chan_data = NULL;
2098  ctx->chan_data_buffer = NULL;
2099  ctx->reverted_channels = NULL;
2100  }
2101 
2102  channel_size = sconf->frame_length + sconf->max_order;
2103 
2104  ctx->prev_raw_samples = av_malloc_array(sconf->max_order, sizeof(*ctx->prev_raw_samples));
2105  ctx->raw_buffer = av_mallocz_array(avctx->channels * channel_size, sizeof(*ctx->raw_buffer));
2106  ctx->raw_samples = av_malloc_array(avctx->channels, sizeof(*ctx->raw_samples));
2107 
2108  if (sconf->floating) {
2109  ctx->acf = av_malloc_array(avctx->channels, sizeof(*ctx->acf));
2110  ctx->shift_value = av_malloc_array(avctx->channels, sizeof(*ctx->shift_value));
2111  ctx->last_shift_value = av_malloc_array(avctx->channels, sizeof(*ctx->last_shift_value));
2112  ctx->last_acf_mantissa = av_malloc_array(avctx->channels, sizeof(*ctx->last_acf_mantissa));
2113  ctx->raw_mantissa = av_mallocz_array(avctx->channels, sizeof(*ctx->raw_mantissa));
2114 
2115  ctx->larray = av_malloc_array(ctx->cur_frame_length * 4, sizeof(*ctx->larray));
2116  ctx->nbits = av_malloc_array(ctx->cur_frame_length, sizeof(*ctx->nbits));
2117  ctx->mlz = av_mallocz(sizeof(*ctx->mlz));
2118 
2119  if (!ctx->mlz || !ctx->acf || !ctx->shift_value || !ctx->last_shift_value
2120  || !ctx->last_acf_mantissa || !ctx->raw_mantissa) {
2121  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2122  ret = AVERROR(ENOMEM);
2123  goto fail;
2124  }
2125 
2126  ff_mlz_init_dict(avctx, ctx->mlz);
2127  ff_mlz_flush_dict(ctx->mlz);
2128 
2129  for (c = 0; c < avctx->channels; ++c) {
2130  ctx->raw_mantissa[c] = av_mallocz_array(ctx->cur_frame_length, sizeof(**ctx->raw_mantissa));
2131  }
2132  }
2133 
2134  // allocate previous raw sample buffer
2135  if (!ctx->prev_raw_samples || !ctx->raw_buffer|| !ctx->raw_samples) {
2136  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2137  ret = AVERROR(ENOMEM);
2138  goto fail;
2139  }
2140 
2141  // assign raw samples buffers
2142  ctx->raw_samples[0] = ctx->raw_buffer + sconf->max_order;
2143  for (c = 1; c < avctx->channels; c++)
2144  ctx->raw_samples[c] = ctx->raw_samples[c - 1] + channel_size;
2145 
2146  // allocate crc buffer
2147  if (HAVE_BIGENDIAN != sconf->msb_first && sconf->crc_enabled &&
2148  (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) {
2149  ctx->crc_buffer = av_malloc_array(ctx->cur_frame_length *
2150  avctx->channels *
2151  av_get_bytes_per_sample(avctx->sample_fmt),
2152  sizeof(*ctx->crc_buffer));
2153  if (!ctx->crc_buffer) {
2154  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2155  ret = AVERROR(ENOMEM);
2156  goto fail;
2157  }
2158  }
2159 
2160  ff_bswapdsp_init(&ctx->bdsp);
2161 
2162  return 0;
2163 
2164 fail:
2165  return ret;
2166 }
2167 
2168 
2169 /** Flush (reset) the frame ID after seeking.
2170  */
2171 static av_cold void flush(AVCodecContext *avctx)
2172 {
2173  ALSDecContext *ctx = avctx->priv_data;
2174 
2175  ctx->frame_id = 0;
2176 }
2177 
2178 
2179 AVCodec ff_als_decoder = {
2180  .name = "als",
2181  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
2182  .type = AVMEDIA_TYPE_AUDIO,
2183  .id = AV_CODEC_ID_MP4ALS,
2184  .priv_data_size = sizeof(ALSDecContext),
2185  .init = decode_init,
2186  .close = decode_end,
2187  .decode = decode_frame,
2188  .flush = flush,
2189  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
2190  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2191 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:30
ALSDecContext::gb
GetBitContext gb
Definition: alsdec.c:197
ALSDecContext::mlz
MLZ * mlz
masked lz decompression structure
Definition: alsdec.c:231
ALSDecContext::avctx
AVCodecContext * avctx
Definition: alsdec.c:195
AVCodec
AVCodec.
Definition: codec.h:197
bswapdsp.h
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
ALSDecContext::opt_order
unsigned int * opt_order
contains opt_order flags for all channels
Definition: alsdec.c:213
ALSDecContext::cur_frame_length
unsigned int cur_frame_length
length of the current frame to decode
Definition: alsdec.c:202
ALSDecContext::lpc_cof
int32_t ** lpc_cof
coefficients of the direct form prediction filter for a channel
Definition: alsdec.c:221
av_clip
#define av_clip
Definition: common.h:122
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
r
const char * r
Definition: vf_curves.c:116
acc
int acc
Definition: yuv2rgb.c:555
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ALSDecContext::ltp_lag
int * ltp_lag
contains ltp lag values for all channels
Definition: alsdec.c:216
ALSDecContext::crc_org
uint32_t crc_org
CRC value of the original input data.
Definition: alsdec.c:200
ALSDecContext::reverted_channels
int * reverted_channels
stores a flag for each reverted channel
Definition: alsdec.c:226
ALSSpecificConfig::block_switching
int block_switching
number of block switching levels
Definition: alsdec.c:170
ff_bgmc_decode_init
int ff_bgmc_decode_init(GetBitContext *gb, unsigned int *h, unsigned int *l, unsigned int *v)
Initialize decoding and reads the first value.
Definition: bgmc.c:488
ALSDecContext::shift_value
int * shift_value
value by which the binary point is to be shifted for all channels
Definition: alsdec.c:234
ff_mlz_flush_dict
av_cold void ff_mlz_flush_dict(MLZ *mlz)
Flush the dictionary.
Definition: mlz.c:35
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1196
ALSSpecificConfig::msb_first
int msb_first
1 = original CRC calculated on big-endian system, 0 = little-endian
Definition: alsdec.c:162
ALSBlockData::raw_samples
int32_t * raw_samples
decoded raw samples / residuals for this block
Definition: alsdec.c:256
AVCRC
uint32_t AVCRC
Definition: crc.h:47
ALSDecContext::chan_data_buffer
ALSChannelData * chan_data_buffer
contains channel data for all channels
Definition: alsdec.c:225
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1645
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
decode_blocks
static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame, unsigned int c, const unsigned int *div_blocks, unsigned int *js_blocks)
Decode blocks dependently.
Definition: alsdec.c:1134
av_bits2sf_ieee754
static SoftFloat_IEEE754 av_bits2sf_ieee754(uint32_t n)
Make a softfloat out of the bitstream.
Definition: softfloat_ieee754.h:66
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Initialize the ALS decoder.
Definition: alsdec.c:1977
ALSBlockData::opt_order
unsigned int * opt_order
prediction order of this block
Definition: alsdec.c:249
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
ALSBlockData::ra_block
unsigned int ra_block
if true, this is a random access block
Definition: alsdec.c:245
mcc_weightings
static const int16_t mcc_weightings[]
Inter-channel weighting factors for multi-channel correlation.
Definition: alsdec.c:121
ALSDecContext::bgmc_lut
uint8_t * bgmc_lut
pointer at lookup tables used for BGMC
Definition: alsdec.c:208
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
ALSSpecificConfig::frame_length
int frame_length
frame length for each frame (last frame may differ)
Definition: alsdec.c:163
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:369
als_weighting
static int als_weighting(GetBitContext *gb, int k, int off)
Definition: alsdec.c:1218
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:142
read_decode_block
static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd)
Read and decode block data successively.
Definition: alsdec.c:1065
ALSSpecificConfig::resolution
int resolution
000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
Definition: alsdec.c:160
read_diff_float_data
static int read_diff_float_data(ALSDecContext *ctx, unsigned int ra_frame)
Read and decode the floating point sample data.
Definition: alsdec.c:1446
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
ALSDecContext::chan_data
ALSChannelData ** chan_data
channel data for multi-channel correlation
Definition: alsdec.c:224
base
uint8_t base
Definition: vp3data.h:141
ALSDecContext::larray
unsigned char * larray
buffer to store the output of masked lz decompression
Definition: alsdec.c:237
max
#define max(a, b)
Definition: cuda_runtime.h:33
ALSBlockData
Definition: alsdec.c:243
intfloat.h
ALSSpecificConfig::joint_stereo
int joint_stereo
joint stereo: 1 = on, 0 = off
Definition: alsdec.c:173
FLOAT_1
static const SoftFloat FLOAT_1
1.0
Definition: softfloat.h:41
ALSDecContext::cs_switch
unsigned int cs_switch
if true, channel rearrangement is done
Definition: alsdec.c:205
ALSDecContext::js_switch
unsigned int js_switch
if true, joint-stereo decoding is enforced
Definition: alsdec.c:204
ff_bgmc_end
av_cold void ff_bgmc_end(uint8_t **cf_lut, int **cf_lut_status)
Release the lookup table arrays.
Definition: bgmc.c:480
av_int2sf_ieee754
static SoftFloat_IEEE754 av_int2sf_ieee754(int64_t n, int e)
Convert integer to softfloat.
Definition: softfloat_ieee754.h:53
MPEG4AudioConfig
Definition: mpeg4audio.h:33
MLZ
MLZ data strucure.
Definition: mlz.h:47
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
ALSSpecificConfig::ra_distance
int ra_distance
distance between RA frames (in frames, 0...255)
Definition: alsdec.c:164
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
mpeg4audio.h
U
#define U(x)
Definition: vp56_arith.h:37
av_ceil_log2
#define av_ceil_log2
Definition: common.h:119
read_var_block_data
static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data for a non-constant block.
Definition: alsdec.c:628
fail
#define fail()
Definition: checkasm.h:133
ltp_gain_values
static const uint8_t ltp_gain_values[4][4]
Gain values of p(0) for long-term prediction.
Definition: alsdec.c:110
ALSBlockData::store_prev_samples
int * store_prev_samples
if true, carryover samples have to be stored
Definition: alsdec.c:250
GetBitContext
Definition: get_bits.h:61
samplefmt.h
ALSDecContext::const_block
int * const_block
contains const_block flags for all channels
Definition: alsdec.c:211
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
ALSDecContext::highest_decoded_channel
int highest_decoded_channel
Definition: alsdec.c:239
val
static double val(void *priv, double ch)
Definition: aeval.c:76
ff_als_decoder
AVCodec ff_als_decoder
Definition: alsdec.c:2179
ALSDecContext::raw_buffer
int32_t * raw_buffer
contains all decoded raw samples including carryover samples
Definition: alsdec.c:229
ALSChannelData::time_diff_sign
int time_diff_sign
Definition: alsdec.c:188
ALSBlockData::ltp_gain
int * ltp_gain
gain values for ltp 5-tap filter
Definition: alsdec.c:253
ALSBlockData::raw_other
int32_t * raw_other
decoded raw samples of the other channel of a channel pair
Definition: alsdec.c:258
ALSSpecificConfig::adapt_order
int adapt_order
adaptive order: 1 = on, 0 = off
Definition: alsdec.c:166
av_bswap32
#define av_bswap32
Definition: bswap.h:33
RA_FLAG_HEADER
@ RA_FLAG_HEADER
Definition: alsdec.c:154
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
ALSBlockData::shift_lsbs
unsigned int * shift_lsbs
shift of values for this block
Definition: alsdec.c:248
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
MISSING_ERR
#define MISSING_ERR(cond, str, errval)
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
revert_channel_correlation
static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd, ALSChannelData **cd, int *reverted, unsigned int offset, int c)
Recursively reverts the inter-channel correlation for a block.
Definition: alsdec.c:1274
ALSSpecificConfig::chan_sort
int chan_sort
channel rearrangement: 1 = on, 0 = off
Definition: alsdec.c:176
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:638
avpriv_mpeg4audio_get_config2
int avpriv_mpeg4audio_get_config2(MPEG4AudioConfig *c, const uint8_t *buf, int size, int sync_extension, void *logctx)
Parse MPEG-4 systems extradata from a raw buffer to retrieve audio configuration.
Definition: mpeg4audio.c:190
ALSChannelData
Definition: alsdec.c:184
intreadwrite.h
ALSDecContext::ltp_lag_length
int ltp_lag_length
number of bits used for ltp lag value
Definition: alsdec.c:210
s
#define s(width, name)
Definition: cbs_vp9.c:257
zero_remaining
static void zero_remaining(unsigned int b, unsigned int b_max, const unsigned int *div_blocks, int32_t *buf)
Compute the number of samples left to decode for the current frame and sets these samples to zero.
Definition: alsdec.c:1079
ff_bgmc_decode
void ff_bgmc_decode(GetBitContext *gb, unsigned int num, int32_t *dst, int delta, unsigned int sx, unsigned int *h, unsigned int *l, unsigned int *v, uint8_t *cf_lut, int *cf_lut_status)
Read and decode a block Gilbert-Moore coded symbol.
Definition: bgmc.c:510
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
decode_const_block_data
static void decode_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data for a constant block.
Definition: alsdec.c:614
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
parcor_to_lpc
static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
Convert PARCOR coefficient k to direct filter coefficient.
Definition: alsdec.c:511
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1747
av_cmp_sf_ieee754
static int av_cmp_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b)
Compare a with b strictly.
Definition: softfloat_ieee754.h:106
ctx
AVFormatContext * ctx
Definition: movenc.c:48
channels
channels
Definition: aptx.h:33
ALSDecContext::last_shift_value
int * last_shift_value
contains last shift value for all channels
Definition: alsdec.c:235
get_bits.h
ALSBlockData::ltp_lag
int * ltp_lag
lag value for long-term prediction
Definition: alsdec.c:252
multiply
static SoftFloat_IEEE754 multiply(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b)
multiply two softfloats and handle the rounding off
Definition: alsdec.c:1387
ALSSpecificConfig::bgmc
int bgmc
"Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only)
Definition: alsdec.c:171
ALSDecContext::ltp_gain_buffer
int * ltp_gain_buffer
contains all gain values for ltp 5-tap filter
Definition: alsdec.c:218
int32_t
int32_t
Definition: audio_convert.c:194
ALSDecContext::crc
uint32_t crc
CRC value calculated from decoded data.
Definition: alsdec.c:201
if
if(ret)
Definition: filter_design.txt:179
mlz.h
ALSChannelData::time_diff_flag
int time_diff_flag
Definition: alsdec.c:187
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Uninitialize the ALS decoder.
Definition: alsdec.c:1925
ALSBlockData::block_length
unsigned int block_length
number of samples within the block
Definition: alsdec.c:244
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:192
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
FLOAT_0
static const SoftFloat FLOAT_0
0.0
Definition: softfloat.h:39
ALSSpecificConfig::chan_config
int chan_config
indicates that a chan_config_info field is present
Definition: alsdec.c:175
check_specific_config
static int check_specific_config(ALSDecContext *ctx)
Check the ALSSpecificConfig for unsupported features.
Definition: alsdec.c:446
ALSDecContext::num_blocks
unsigned int num_blocks
number of blocks used in the current frame
Definition: alsdec.c:206
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
src
#define src
Definition: vp8dsp.c:255
ALSSpecificConfig::chan_pos
int * chan_pos
original channel positions
Definition: alsdec.c:179
abs
#define abs(x)
Definition: cuda_runtime.h:35
ALSDecContext::bgmc_lut_status
int * bgmc_lut_status
pointer at lookup table status flags used for BGMC
Definition: alsdec.c:209
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
ALSSpecificConfig::long_term_prediction
int long_term_prediction
long term prediction (LTP): 1 = on, 0 = off
Definition: alsdec.c:168
AV_CODEC_ID_MP4ALS
@ AV_CODEC_ID_MP4ALS
Definition: codec_id.h:469
ALSSpecificConfig::ra_flag
enum RA_Flag ra_flag
indicates where the size of ra units is stored
Definition: alsdec.c:165
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
AV_EF_CAREFUL
#define AV_EF_CAREFUL
consider things that violate the spec, are fast to calculate and have not been seen in the wild as er...
Definition: avcodec.h:1659
read_block
static int read_block(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data.
Definition: alsdec.c:1012
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
tail_code
static const uint8_t tail_code[16][6]
Tail codes used in arithmetic coding using block Gilbert-Moore codes.
Definition: alsdec.c:131
parcor_scaled_values
static const int16_t parcor_scaled_values[]
Scaled PARCOR values used for the first two PARCOR coefficients.
Definition: alsdec.c:71
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
ff_bgmc_init
av_cold int ff_bgmc_init(AVCodecContext *avctx, uint8_t **cf_lut, int **cf_lut_status)
Initialize the lookup table arrays.
Definition: bgmc.c:460
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode an ALS frame.
Definition: alsdec.c:1786
ALSDecContext::s_max
unsigned int s_max
maximum Rice parameter allowed in entropy coding
Definition: alsdec.c:207
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
ALSDecContext::ltp_gain
int ** ltp_gain
gain values for ltp 5-tap filter for a channel
Definition: alsdec.c:217
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
ALSDecContext::nbits
int * nbits
contains the number of bits to read for masked lz decompression for all samples
Definition: alsdec.c:238
AVPacket::size
int size
Definition: packet.h:370
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
master
const char * master
Definition: vf_curves.c:119
read_const_block_data
static int read_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data for a constant block.
Definition: alsdec.c:584
ALSSpecificConfig::chan_config_info
int chan_config_info
mapping of channels to loudspeaker locations. Unused until setting channel configuration is implement...
Definition: alsdec.c:178
ALSDecContext::lpc_cof_buffer
int32_t * lpc_cof_buffer
contains all coefficients of the direct form prediction filter
Definition: alsdec.c:222
RA_FLAG_NONE
@ RA_FLAG_NONE
Definition: alsdec.c:152
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
sample
#define sample
Definition: flacdsp_template.c:44
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
EXP_BIAS
#define EXP_BIAS
Definition: softfloat_ieee754.h:26
ALSChannelData::time_diff_index
int time_diff_index
Definition: alsdec.c:189
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: common.h:479
ALSDecContext::shift_lsbs
unsigned int * shift_lsbs
contains shift_lsbs flags for all channels
Definition: alsdec.c:212
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
av_bswap16
#define av_bswap16
Definition: bswap.h:31
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
ALSSpecificConfig::crc_enabled
int crc_enabled
enable Cyclic Redundancy Checksum
Definition: alsdec.c:180
ALSDecContext::use_ltp
int * use_ltp
contains use_ltp flags for all channels
Definition: alsdec.c:215
ALSSpecificConfig::floating
int floating
1 = IEEE 32-bit floating-point, 0 = integer
Definition: alsdec.c:161
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
unary.h
MPEG4AudioConfig::channels
int channels
Definition: mpeg4audio.h:43
ALSDecContext::store_prev_samples
int * store_prev_samples
contains store_prev_samples flags for all channels
Definition: alsdec.c:214
ALSChannelData::stop_flag
int stop_flag
Definition: alsdec.c:185
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1197
decode_blocks_ind
static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame, unsigned int c, const unsigned int *div_blocks, unsigned int *js_blocks)
Decode blocks independently.
Definition: alsdec.c:1094
SoftFloat_IEEE754::mant
uint64_t mant
Definition: softfloat_ieee754.h:31
i
int i
Definition: input.c:407
ALSBlockData::use_ltp
int * use_ltp
if true, long-term prediction is used
Definition: alsdec.c:251
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
ALSSpecificConfig::rlslms
int rlslms
use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off
Definition: alsdec.c:177
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
bgmc.h
ALSDecContext::last_acf_mantissa
int * last_acf_mantissa
contains the last acf mantissa data of common multiplier for all channels
Definition: alsdec.c:233
ALSBlockData::quant_cof
int32_t * quant_cof
quantized parcor coefficients
Definition: alsdec.c:254
RA_Flag
RA_Flag
Definition: alsdec.c:151
delta
float delta
Definition: vorbis_enc_data.h:457
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
uint8_t
uint8_t
Definition: audio_convert.c:194
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
ALSDecContext::quant_cof
int32_t ** quant_cof
quantized parcor coefficients for a channel
Definition: alsdec.c:219
ALSDecContext::raw_mantissa
int ** raw_mantissa
decoded mantissa bits of the difference signal
Definition: alsdec.c:236
ALSDecContext
Definition: alsdec.c:194
ALSBlockData::lpc_cof
int32_t * lpc_cof
coefficients of the direct form prediction
Definition: alsdec.c:255
SoftFloat_IEEE754
Definition: softfloat_ieee754.h:29
ALSChannelData::weighting
int weighting[6]
Definition: alsdec.c:190
ALSDecContext::prev_raw_samples
int32_t * prev_raw_samples
contains unshifted raw samples from the previous block
Definition: alsdec.c:227
avcodec.h
ALSSpecificConfig::sb_part
int sb_part
sub-block partition
Definition: alsdec.c:172
dprint_specific_config
static av_cold void dprint_specific_config(ALSDecContext *ctx)
Definition: alsdec.c:262
ALSDecContext::crc_buffer
uint8_t * crc_buffer
buffer of byte order corrected samples used for CRC check
Definition: alsdec.c:230
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: avcodec.h:1653
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
av_div_sf_ieee754
static SoftFloat_IEEE754 av_div_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b)
Divide a by b.
Definition: softfloat_ieee754.h:80
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
ALSSpecificConfig
Definition: alsdec.c:158
AVCodecContext
main external API structure.
Definition: avcodec.h:536
ALSSpecificConfig::coef_table
int coef_table
table index of Rice code parameters
Definition: alsdec.c:167
read_channel_data
static int read_channel_data(ALSDecContext *ctx, ALSChannelData *cd, int c)
Read the channel data.
Definition: alsdec.c:1227
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
ALSDecContext::bdsp
BswapDSPContext bdsp
Definition: alsdec.c:198
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
ALSDecContext::raw_samples
int32_t ** raw_samples
decoded raw samples for each channel
Definition: alsdec.c:228
ALSDecContext::lpc_cof_reversed_buffer
int32_t * lpc_cof_reversed_buffer
temporary buffer to set up a reversed versio of lpc_cof_buffer
Definition: alsdec.c:223
ALSDecContext::crc_table
const AVCRC * crc_table
Definition: alsdec.c:199
MUL64
#define MUL64(a, b)
Definition: mathops.h:54
decode_rice
static int32_t decode_rice(GetBitContext *gb, unsigned int k)
Read and decode a Rice codeword.
Definition: alsdec.c:493
ALSDecContext::quant_cof_buffer
int32_t * quant_cof_buffer
contains all quantized parcor coefficients
Definition: alsdec.c:220
flush
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
Definition: alsdec.c:2171
read_specific_config
static av_cold int read_specific_config(ALSDecContext *ctx)
Read an ALSSpecificConfig from a buffer into the output struct.
Definition: alsdec.c:292
ff_mlz_decompression
int ff_mlz_decompression(MLZ *mlz, GetBitContext *gb, int size, unsigned char *buff)
Run mlz decompression on the next size bits and the output will be stored in buff.
Definition: mlz.c:123
ALSBlockData::prev_raw_samples
int32_t * prev_raw_samples
contains unshifted raw samples from the previous block
Definition: alsdec.c:257
shift
static int shift(int a, int b)
Definition: sonic.c:82
AV_CRC_32_IEEE_LE
@ AV_CRC_32_IEEE_LE
Definition: crc.h:54
ALSDecContext::sconf
ALSSpecificConfig sconf
Definition: alsdec.c:196
ALSSpecificConfig::samples
uint32_t samples
number of samples, 0xFFFFFFFF if unknown
Definition: alsdec.c:159
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
AV_CODEC_CAP_SUBFRAMES
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
Definition: codec.h:95
ALSBlockData::js_blocks
int js_blocks
true if this block contains a difference signal
Definition: alsdec.c:247
read_frame_data
static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
Read the frame data.
Definition: alsdec.c:1629
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
decode_var_block_data
static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data for a non-constant block.
Definition: alsdec.c:903
ALSChannelData::master_channel
int master_channel
Definition: alsdec.c:186
INTERLEAVE_OUTPUT
#define INTERLEAVE_OUTPUT(bps)
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
AVPacket
This structure stores compressed data.
Definition: packet.h:346
ALSDecContext::frame_id
unsigned int frame_id
the frame ID / number of the current frame
Definition: alsdec.c:203
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
decode_block
static int decode_block(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data.
Definition: alsdec.c:1039
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_bgmc_decode_end
void ff_bgmc_decode_end(GetBitContext *gb)
Finish decoding.
Definition: bgmc.c:503
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
BswapDSPContext
Definition: bswapdsp.h:24
ff_mlz_init_dict
av_cold void ff_mlz_init_dict(void *context, MLZ *mlz)
Initialize the dictionary.
Definition: mlz.c:23
SoftFloat_IEEE754::exp
int32_t exp
Definition: softfloat_ieee754.h:32
ALSSpecificConfig::max_order
int max_order
maximum prediction order (0..1023)
Definition: alsdec.c:169
FF_SANE_NB_CHANNELS
#define FF_SANE_NB_CHANNELS
Definition: internal.h:107
get_sbits_long
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:590
int
int
Definition: ffmpeg_filter.c:170
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
ALSDecContext::acf
SoftFloat_IEEE754 * acf
contains common multiplier for all channels
Definition: alsdec.c:232
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ALSSpecificConfig::mc_coding
int mc_coding
extended inter-channel coding (multi channel coding): 1 = on, 0 = off
Definition: alsdec.c:174
get_block_sizes
static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks, uint32_t *bs_info)
Read block switching field if necessary and set actual block sizes.
Definition: alsdec.c:531
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
parse_bs_info
static void parse_bs_info(const uint32_t bs_info, unsigned int n, unsigned int div, unsigned int **div_blocks, unsigned int *num_blocks)
Parse the bs_info field to extract the block partitioning used in block switching mode,...
Definition: alsdec.c:470
parcor_rice_table
static const int8_t parcor_rice_table[3][20][2]
Rice parameters and corresponding index offsets for decoding the indices of scaled PARCOR values.
Definition: alsdec.c:50
softfloat_ieee754.h
MPEG4AudioConfig::sample_rate
int sample_rate
Definition: mpeg4audio.h:36
RA_FLAG_FRAMES
@ RA_FLAG_FRAMES
Definition: alsdec.c:153
ALSBlockData::const_block
int * const_block
if true, this is a constant value block
Definition: alsdec.c:246
SoftFloat_IEEE754::sign
int32_t sign
Definition: softfloat_ieee754.h:30
Generated on Wed Aug 24 2022 21:33:46 for FFmpeg by   doxygen 1.8.17