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