FFmpeg
alac.c
Go to the documentation of this file.
1 /*
2  * ALAC (Apple Lossless Audio Codec) decoder
3  * Copyright (c) 2005 David Hammerton
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  * ALAC (Apple Lossless Audio Codec) decoder
25  * @author 2005 David Hammerton
26  * @see http://crazney.net/programs/itunes/alac.html
27  *
28  * Note: This decoder expects a 36-byte QuickTime atom to be
29  * passed through the extradata[_size] fields. This atom is tacked onto
30  * the end of an 'alac' stsd atom and has the following format:
31  *
32  * 32 bits atom size
33  * 32 bits tag ("alac")
34  * 32 bits tag version (0)
35  * 32 bits samples per frame (used when not set explicitly in the frames)
36  * 8 bits compatible version (0)
37  * 8 bits sample size
38  * 8 bits history mult (40)
39  * 8 bits initial history (10)
40  * 8 bits rice param limit (14)
41  * 8 bits channels
42  * 16 bits maxRun (255)
43  * 32 bits max coded frame size (0 means unknown)
44  * 32 bits average bitrate (0 means unknown)
45  * 32 bits samplerate
46  */
47 
48 #include <inttypes.h>
49 
51 #include "libavutil/mem.h"
52 #include "libavutil/opt.h"
53 #include "avcodec.h"
54 #include "get_bits.h"
55 #include "bytestream.h"
56 #include "codec_internal.h"
57 #include "thread.h"
58 #include "unary.h"
59 #include "mathops.h"
60 #include "alac_data.h"
61 #include "alacdsp.h"
62 
63 #define ALAC_EXTRADATA_SIZE 36
64 
65 typedef struct ALACContext {
66  AVClass *class;
69  int channels;
70 
74 
76  uint8_t sample_size;
79  uint8_t rice_limit;
81 
82  int extra_bits; /**< number of extra bits beyond 16-bit */
83  int nb_samples; /**< number of samples in the current frame */
84 
87 
89 } ALACContext;
90 
91 static inline unsigned int decode_scalar(GetBitContext *gb, int k, int bps)
92 {
93  unsigned int x = get_unary_0_9(gb);
94 
95  if (x > 8) { /* RICE THRESHOLD */
96  /* use alternative encoding */
97  x = get_bits_long(gb, bps);
98  } else if (k != 1) {
99  int extrabits = show_bits(gb, k);
100 
101  /* multiply x by 2^k - 1, as part of their strange algorithm */
102  x = (x << k) - x;
103 
104  if (extrabits > 1) {
105  x += extrabits - 1;
106  skip_bits(gb, k);
107  } else
108  skip_bits(gb, k - 1);
109  }
110  return x;
111 }
112 
113 static int rice_decompress(ALACContext *alac, int32_t *output_buffer,
114  int nb_samples, int bps, int rice_history_mult)
115 {
116  GetBitContext *gb = &alac->gb;
117  int i;
118  unsigned int history = alac->rice_initial_history;
119  int sign_modifier = 0;
120 
121  for (i = 0; i < nb_samples; i++) {
122  int k;
123  unsigned int x;
124 
125  if (get_bits_left(gb) <= 0)
126  return AVERROR_INVALIDDATA;
127 
128  /* calculate rice param and decode next value */
129  k = av_log2((history >> 9) + 3);
130  k = FFMIN(k, alac->rice_limit);
131  x = decode_scalar(gb, k, bps);
132  x += sign_modifier;
133  sign_modifier = 0;
134  output_buffer[i] = (x >> 1) ^ -(x & 1);
135 
136  /* update the history */
137  if (x > 0xffff)
138  history = 0xffff;
139  else
140  history += x * rice_history_mult -
141  ((history * rice_history_mult) >> 9);
142 
143  /* special case: there may be compressed blocks of 0 */
144  if ((history < 128) && (i + 1 < nb_samples)) {
145  int block_size;
146 
147  /* calculate rice param and decode block size */
148  k = 7 - av_log2(history) + ((history + 16) >> 6);
149  k = FFMIN(k, alac->rice_limit);
150  block_size = decode_scalar(gb, k, 16);
151 
152  if (block_size > 0) {
153  if (block_size >= nb_samples - i) {
154  av_log(alac->avctx, AV_LOG_ERROR,
155  "invalid zero block size of %d %d %d\n", block_size,
156  nb_samples, i);
157  block_size = nb_samples - i - 1;
158  }
159  memset(&output_buffer[i + 1], 0,
160  block_size * sizeof(*output_buffer));
161  i += block_size;
162  }
163  if (block_size <= 0xffff)
164  sign_modifier = 1;
165  history = 0;
166  }
167  }
168  return 0;
169 }
170 
171 static inline int sign_only(int v)
172 {
173  return FFDIFFSIGN(v, 0);
174 }
175 
176 static void lpc_prediction(int32_t *error_buffer, uint32_t *buffer_out,
177  int nb_samples, int bps, int16_t *lpc_coefs,
178  int lpc_order, int lpc_quant)
179 {
180  int i;
181  uint32_t *pred = buffer_out;
182 
183  /* first sample always copies */
184  *buffer_out = *error_buffer;
185 
186  if (nb_samples <= 1)
187  return;
188 
189  if (!lpc_order) {
190  memcpy(&buffer_out[1], &error_buffer[1],
191  (nb_samples - 1) * sizeof(*buffer_out));
192  return;
193  }
194 
195  if (lpc_order == 31) {
196  /* simple 1st-order prediction */
197  for (i = 1; i < nb_samples; i++) {
198  buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i],
199  bps);
200  }
201  return;
202  }
203 
204  /* read warm-up samples */
205  for (i = 1; i <= lpc_order && i < nb_samples; i++)
206  buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i], bps);
207 
208  /* NOTE: 4 and 8 are very common cases that could be optimized. */
209 
210  for (; i < nb_samples; i++) {
211  int j;
212  int val = 0;
213  unsigned error_val = error_buffer[i];
214  int error_sign;
215  int d = *pred++;
216 
217  /* LPC prediction */
218  for (j = 0; j < lpc_order; j++)
219  val += (pred[j] - d) * lpc_coefs[j];
220  val = (val + (1LL << (lpc_quant - 1))) >> lpc_quant;
221  val += d + error_val;
222  buffer_out[i] = sign_extend(val, bps);
223 
224  /* adapt LPC coefficients */
225  error_sign = sign_only(error_val);
226  if (error_sign) {
227  for (j = 0; j < lpc_order && (int)(error_val * error_sign) > 0; j++) {
228  int sign;
229  val = d - pred[j];
230  sign = sign_only(val) * error_sign;
231  lpc_coefs[j] -= sign;
232  val *= (unsigned)sign;
233  error_val -= (val >> lpc_quant) * (j + 1U);
234  }
235  }
236  }
237 }
238 
239 static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index,
240  int channels)
241 {
242  ALACContext *alac = avctx->priv_data;
243  int has_size, bps, is_compressed, decorr_shift, decorr_left_weight, ret;
244  GetBitContext *gb = &alac->gb;
245  uint32_t output_samples;
246  int i, ch;
247 
248  skip_bits(gb, 4); /* element instance tag */
249  skip_bits(gb, 12); /* unused header bits */
250 
251  /* the number of output samples is stored in the frame */
252  has_size = get_bits1(gb);
253 
254  alac->extra_bits = get_bits(gb, 2) << 3;
255  bps = alac->sample_size - alac->extra_bits + channels - 1;
256  if (bps > 32) {
257  avpriv_report_missing_feature(avctx, "bps %d", bps);
258  return AVERROR_PATCHWELCOME;
259  }
260  if (bps < 1)
261  return AVERROR_INVALIDDATA;
262 
263  /* whether the frame is compressed */
264  is_compressed = !get_bits1(gb);
265 
266  if (has_size)
267  output_samples = get_bits_long(gb, 32);
268  else
269  output_samples = alac->max_samples_per_frame;
270  if (!output_samples || output_samples > alac->max_samples_per_frame) {
271  av_log(avctx, AV_LOG_ERROR, "invalid samples per frame: %"PRIu32"\n",
272  output_samples);
273  return AVERROR_INVALIDDATA;
274  }
275  if (!alac->nb_samples) {
276  /* get output buffer */
277  frame->nb_samples = output_samples;
278  if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
279  return ret;
280  } else if (output_samples != alac->nb_samples) {
281  av_log(avctx, AV_LOG_ERROR, "sample count mismatch: %"PRIu32" != %d\n",
282  output_samples, alac->nb_samples);
283  return AVERROR_INVALIDDATA;
284  }
285  alac->nb_samples = output_samples;
286  if (alac->direct_output) {
287  for (ch = 0; ch < channels; ch++)
288  alac->output_samples_buffer[ch] = (int32_t *)frame->extended_data[ch_index + ch];
289  }
290 
291  if (is_compressed) {
292  int16_t lpc_coefs[2][32];
293  int lpc_order[2];
294  int prediction_type[2];
295  int lpc_quant[2];
296  int rice_history_mult[2];
297 
298  if (!alac->rice_limit) {
300  "Compression with rice limit 0");
301  return AVERROR(ENOSYS);
302  }
303 
304  decorr_shift = get_bits(gb, 8);
305  decorr_left_weight = get_bits(gb, 8);
306 
307  if (channels == 2 && decorr_left_weight && decorr_shift > 31)
308  return AVERROR_INVALIDDATA;
309 
310  for (ch = 0; ch < channels; ch++) {
311  prediction_type[ch] = get_bits(gb, 4);
312  lpc_quant[ch] = get_bits(gb, 4);
313  rice_history_mult[ch] = get_bits(gb, 3);
314  lpc_order[ch] = get_bits(gb, 5);
315 
316  if (lpc_order[ch] >= alac->max_samples_per_frame || !lpc_quant[ch])
317  return AVERROR_INVALIDDATA;
318 
319  /* read the predictor table */
320  for (i = lpc_order[ch] - 1; i >= 0; i--)
321  lpc_coefs[ch][i] = get_sbits(gb, 16);
322  }
323 
324  if (alac->extra_bits) {
325  const int extra_bits = alac->extra_bits;
326  if (get_bits_left(gb) < (int64_t)alac->nb_samples * channels * extra_bits)
327  return AVERROR_INVALIDDATA;
328  for (i = 0; i < alac->nb_samples; i++) {
329  for (ch = 0; ch < channels; ch++)
330  alac->extra_bits_buffer[ch][i] = get_bits(gb, extra_bits);
331  }
332  }
333  for (ch = 0; ch < channels; ch++) {
334  int ret = rice_decompress(alac, alac->predict_error_buffer[ch],
335  alac->nb_samples, bps,
336  rice_history_mult[ch] * alac->rice_history_mult / 4);
337  if (ret < 0)
338  return ret;
339 
340  /* adaptive FIR filter */
341  if (prediction_type[ch] == 15) {
342  /* Prediction type 15 runs the adaptive FIR twice.
343  * The first pass uses the special-case coef_num = 31, while
344  * the second pass uses the coefs from the bitstream.
345  *
346  * However, this prediction type is not currently used by the
347  * reference encoder.
348  */
350  alac->predict_error_buffer[ch],
351  alac->nb_samples, bps, NULL, 31, 0);
352  } else if (prediction_type[ch] > 0) {
353  av_log(avctx, AV_LOG_WARNING, "unknown prediction type: %i\n",
354  prediction_type[ch]);
355  }
357  alac->output_samples_buffer[ch], alac->nb_samples,
358  bps, lpc_coefs[ch], lpc_order[ch], lpc_quant[ch]);
359  }
360  } else {
361  const int sample_size = alac->sample_size;
362  /* not compressed, easy case */
363  if (get_bits_left(gb) < (int64_t)alac->nb_samples * channels * sample_size)
364  return AVERROR_INVALIDDATA;
365  for (i = 0; i < alac->nb_samples; i++) {
366  for (ch = 0; ch < channels; ch++) {
367  alac->output_samples_buffer[ch][i] =
368  get_sbits_long(gb, sample_size);
369  }
370  }
371  alac->extra_bits = 0;
372  decorr_shift = 0;
373  decorr_left_weight = 0;
374  }
375 
376  if (channels == 2) {
377  if (alac->extra_bits && alac->extra_bit_bug) {
379  alac->extra_bits, channels, alac->nb_samples);
380  }
381 
382  if (decorr_left_weight) {
384  decorr_shift, decorr_left_weight);
385  }
386 
387  if (alac->extra_bits && !alac->extra_bit_bug) {
389  alac->extra_bits, channels, alac->nb_samples);
390  }
391  } else if (alac->extra_bits) {
393  alac->extra_bits, channels, alac->nb_samples);
394  }
395 
396  switch(alac->sample_size) {
397  case 16: {
398  for (ch = 0; ch < channels; ch++) {
399  int16_t *outbuffer = (int16_t *)frame->extended_data[ch_index + ch];
400  for (i = 0; i < alac->nb_samples; i++)
401  *outbuffer++ = alac->output_samples_buffer[ch][i];
402  }}
403  break;
404  case 20: {
405  for (ch = 0; ch < channels; ch++) {
406  for (i = 0; i < alac->nb_samples; i++)
407  alac->output_samples_buffer[ch][i] *= 1U << 12;
408  }}
409  break;
410  case 24: {
411  for (ch = 0; ch < channels; ch++) {
412  for (i = 0; i < alac->nb_samples; i++)
413  alac->output_samples_buffer[ch][i] *= 1U << 8;
414  }}
415  break;
416  }
417 
418  return 0;
419 }
420 
422  int *got_frame_ptr, AVPacket *avpkt)
423 {
424  ALACContext *alac = avctx->priv_data;
425  enum AlacRawDataBlockType element;
426  int channels;
427  int ch, ret, got_end;
428 
429  if ((ret = init_get_bits8(&alac->gb, avpkt->data, avpkt->size)) < 0)
430  return ret;
431 
432  got_end = 0;
433  alac->nb_samples = 0;
434  ch = 0;
435  while (get_bits_left(&alac->gb) >= 3) {
436  element = get_bits(&alac->gb, 3);
437  if (element == TYPE_END) {
438  got_end = 1;
439  break;
440  }
441  if (element > TYPE_CPE && element != TYPE_LFE) {
442  avpriv_report_missing_feature(avctx, "Syntax element %d", element);
443  return AVERROR_PATCHWELCOME;
444  }
445 
446  channels = (element == TYPE_CPE) ? 2 : 1;
447  if (ch + channels > alac->channels ||
448  ff_alac_channel_layout_offsets[alac->channels - 1][ch] + channels > alac->channels) {
449  av_log(avctx, AV_LOG_ERROR, "invalid element channel count\n");
450  return AVERROR_INVALIDDATA;
451  }
452 
453  ret = decode_element(avctx, frame,
455  channels);
456  if (ret < 0 && get_bits_left(&alac->gb))
457  return ret;
458 
459  ch += channels;
460  }
461  if (!got_end) {
462  av_log(avctx, AV_LOG_ERROR, "no end tag found. incomplete packet.\n");
463  return AVERROR_INVALIDDATA;
464  }
465 
466  if (avpkt->size * 8 - get_bits_count(&alac->gb) > 8) {
467  av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n",
468  avpkt->size * 8 - get_bits_count(&alac->gb));
469  }
470 
471  if (alac->channels == ch && alac->nb_samples)
472  *got_frame_ptr = 1;
473  else
474  av_log(avctx, AV_LOG_WARNING, "Failed to decode all channels\n");
475 
476  return avpkt->size;
477 }
478 
480 {
481  ALACContext *alac = avctx->priv_data;
482 
483  int ch;
484  for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) {
485  av_freep(&alac->predict_error_buffer[ch]);
486  if (!alac->direct_output)
487  av_freep(&alac->output_samples_buffer[ch]);
488  av_freep(&alac->extra_bits_buffer[ch]);
489  }
490 
491  return 0;
492 }
493 
494 static int allocate_buffers(ALACContext *alac)
495 {
496  int ch;
497  unsigned buf_size = alac->max_samples_per_frame * sizeof(int32_t);
498  unsigned extra_buf_size = buf_size + AV_INPUT_BUFFER_PADDING_SIZE;
499 
500  for (ch = 0; ch < 2; ch++) {
501  alac->predict_error_buffer[ch] = NULL;
502  alac->output_samples_buffer[ch] = NULL;
503  alac->extra_bits_buffer[ch] = NULL;
504  }
505 
506  for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) {
507  if (!(alac->predict_error_buffer[ch] = av_malloc(buf_size)))
508  return AVERROR(ENOMEM);
509 
510  alac->direct_output = alac->sample_size > 16;
511  if (!alac->direct_output) {
512  if (!(alac->output_samples_buffer[ch] = av_malloc(extra_buf_size)))
513  return AVERROR(ENOMEM);
514  }
515 
516  if (!(alac->extra_bits_buffer[ch] = av_malloc(extra_buf_size)))
517  return AVERROR(ENOMEM);
518  }
519  return 0;
520 }
521 
522 static int alac_set_info(ALACContext *alac)
523 {
524  GetByteContext gb;
525 
526  bytestream2_init(&gb, alac->avctx->extradata,
527  alac->avctx->extradata_size);
528 
529  bytestream2_skipu(&gb, 12); // size:4, alac:4, version:4
530 
531  alac->max_samples_per_frame = bytestream2_get_be32u(&gb);
532  if (!alac->max_samples_per_frame ||
533  alac->max_samples_per_frame > 4096 * 4096) {
534  av_log(alac->avctx, AV_LOG_ERROR,
535  "max samples per frame invalid: %"PRIu32"\n",
536  alac->max_samples_per_frame);
537  return AVERROR_INVALIDDATA;
538  }
539  bytestream2_skipu(&gb, 1); // compatible version
540  alac->sample_size = bytestream2_get_byteu(&gb);
541  alac->rice_history_mult = bytestream2_get_byteu(&gb);
542  alac->rice_initial_history = bytestream2_get_byteu(&gb);
543  alac->rice_limit = bytestream2_get_byteu(&gb);
544  alac->channels = bytestream2_get_byteu(&gb);
545  bytestream2_get_be16u(&gb); // maxRun
546  bytestream2_get_be32u(&gb); // max coded frame size
547  bytestream2_get_be32u(&gb); // average bitrate
548  alac->sample_rate = bytestream2_get_be32u(&gb);
549 
550  return 0;
551 }
552 
554 {
555  int ret;
556  ALACContext *alac = avctx->priv_data;
557  alac->avctx = avctx;
558 
559  /* initialize from the extradata */
561  av_log(avctx, AV_LOG_ERROR, "extradata is too small\n");
562  return AVERROR_INVALIDDATA;
563  }
564  if ((ret = alac_set_info(alac)) < 0) {
565  av_log(avctx, AV_LOG_ERROR, "set_info failed\n");
566  return ret;
567  }
568 
569  switch (alac->sample_size) {
570  case 16: avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
571  break;
572  case 20:
573  case 24:
574  case 32: avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
575  break;
576  default: avpriv_request_sample(avctx, "Sample depth %d", alac->sample_size);
577  return AVERROR_PATCHWELCOME;
578  }
579  avctx->bits_per_raw_sample = alac->sample_size;
580  avctx->sample_rate = alac->sample_rate;
581 
582  if (alac->channels < 1) {
583  av_log(avctx, AV_LOG_WARNING, "Invalid channel count\n");
584  if (avctx->ch_layout.nb_channels < 1)
585  return AVERROR(EINVAL);
586  alac->channels = avctx->ch_layout.nb_channels;
587  }
588  if (alac->channels > ALAC_MAX_CHANNELS) {
589  avpriv_report_missing_feature(avctx, "Channel count %d",
590  alac->channels);
591  return AVERROR_PATCHWELCOME;
592  }
594  avctx->ch_layout = ff_alac_ch_layouts[alac->channels - 1];
595 
596  if ((ret = allocate_buffers(alac)) < 0) {
597  av_log(avctx, AV_LOG_ERROR, "Error allocating buffers\n");
598  return ret;
599  }
600 
601  ff_alacdsp_init(&alac->dsp);
602 
603  return 0;
604 }
605 
606 static const AVOption options[] = {
607  { "extra_bits_bug", "Force non-standard decoding process",
608  offsetof(ALACContext, extra_bit_bug), AV_OPT_TYPE_BOOL, { .i64 = 0 },
610  { NULL },
611 };
612 
613 static const AVClass alac_class = {
614  .class_name = "alac",
615  .item_name = av_default_item_name,
616  .option = options,
617  .version = LIBAVUTIL_VERSION_INT,
618 };
619 
621  .p.name = "alac",
622  CODEC_LONG_NAME("ALAC (Apple Lossless Audio Codec)"),
623  .p.type = AVMEDIA_TYPE_AUDIO,
624  .p.id = AV_CODEC_ID_ALAC,
625  .priv_data_size = sizeof(ALACContext),
627  .close = alac_decode_close,
630  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
631  .p.priv_class = &alac_class
632 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_alacdsp_init
av_cold void ff_alacdsp_init(ALACDSPContext *c)
Definition: alacdsp.c:55
extra_bits
#define extra_bits(eb)
Definition: intrax8.c:120
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:42
ff_alac_decoder
const FFCodec ff_alac_decoder
Definition: alac.c:620
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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
opt.h
ALACDSPContext::decorrelate_stereo
void(* decorrelate_stereo)(int32_t *buffer[2], int nb_samples, int decorr_shift, int decorr_left_weight)
Definition: alacdsp.h:25
get_unary_0_9
static int get_unary_0_9(GetBitContext *gb)
Definition: unary.h:64
alac_data.h
lpc_prediction
static void lpc_prediction(int32_t *error_buffer, uint32_t *buffer_out, int nb_samples, int bps, int16_t *lpc_coefs, int lpc_order, int lpc_quant)
Definition: alac.c:176
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
decode_scalar
static unsigned int decode_scalar(GetBitContext *gb, int k, int bps)
Definition: alac.c:91
GetByteContext
Definition: bytestream.h:33
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
ALACContext::extra_bits
int extra_bits
number of extra bits beyond 16-bit
Definition: alac.c:82
alac_decode_close
static av_cold int alac_decode_close(AVCodecContext *avctx)
Definition: alac.c:479
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVPacket::data
uint8_t * data
Definition: packet.h:520
AVOption
AVOption.
Definition: opt.h:357
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
AV_CODEC_ID_ALAC
@ AV_CODEC_ID_ALAC
Definition: codec_id.h:456
FFCodec
Definition: codec_internal.h:126
ALACContext::rice_history_mult
uint8_t rice_history_mult
Definition: alac.c:77
rice_decompress
static int rice_decompress(ALACContext *alac, int32_t *output_buffer, int nb_samples, int bps, int rice_history_mult)
Definition: alac.c:113
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
thread.h
alacdsp.h
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
sign_only
static int sign_only(int v)
Definition: alac.c:171
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:41
GetBitContext
Definition: get_bits.h:108
val
static double val(void *priv, double ch)
Definition: aeval.c:78
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:285
alac_decode_frame
static int alac_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: alac.c:421
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ALACContext::channels
int channels
Definition: alac.c:69
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:986
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1575
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:320
channels
channels
Definition: aptx.h:31
get_bits.h
ALACContext::predict_error_buffer
int32_t * predict_error_buffer[2]
Definition: alac.c:71
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
decode_element
static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index, int channels)
Definition: alac.c:239
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
ALACContext::dsp
ALACDSPContext dsp
Definition: alac.c:88
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
options
static const AVOption options[]
Definition: alac.c:606
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
mathops.h
ALACDSPContext
Definition: alacdsp.h:24
ALACContext::nb_samples
int nb_samples
number of samples in the current frame
Definition: alac.c:83
ALACContext::max_samples_per_frame
uint32_t max_samples_per_frame
Definition: alac.c:75
ALACContext::rice_initial_history
uint8_t rice_initial_history
Definition: alac.c:78
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:106
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
alac_decode_init
static av_cold int alac_decode_init(AVCodecContext *avctx)
Definition: alac.c:553
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
AVPacket::size
int size
Definition: packet.h:521
codec_internal.h
TYPE_END
@ TYPE_END
Definition: aac.h:47
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
bps
unsigned bps
Definition: movenc.c:1852
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
ALACContext::output_samples_buffer
int32_t * output_samples_buffer[2]
Definition: alac.c:72
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
ALACContext
Definition: alac.c:65
ALACContext::direct_output
int direct_output
Definition: alac.c:85
ALACContext::rice_limit
uint8_t rice_limit
Definition: alac.c:79
ALAC_MAX_CHANNELS
#define ALAC_MAX_CHANNELS
Definition: alac_data.h:40
unary.h
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ff_alac_channel_layout_offsets
const uint8_t ff_alac_channel_layout_offsets[ALAC_MAX_CHANNELS][ALAC_MAX_CHANNELS]
Definition: alac_data.c:24
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
ff_alac_ch_layouts
const AVChannelLayout ff_alac_ch_layouts[ALAC_MAX_CHANNELS+1]
Definition: alac_data.c:35
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
alac_class
static const AVClass alac_class
Definition: alac.c:613
ALACContext::avctx
AVCodecContext * avctx
Definition: alac.c:67
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
TYPE_LFE
@ TYPE_LFE
Definition: aac.h:43
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
ALACContext::extra_bit_bug
int extra_bit_bug
Definition: alac.c:86
avcodec.h
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
ALACContext::sample_size
uint8_t sample_size
Definition: alac.c:76
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
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_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
U
#define U(x)
Definition: vpx_arith.h:37
ALACContext::sample_rate
int sample_rate
Definition: alac.c:80
AVCodecContext
main external API structure.
Definition: avcodec.h:445
channel_layout.h
allocate_buffers
static int allocate_buffers(ALACContext *alac)
Definition: alac.c:494
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:437
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:133
alac_set_info
static int alac_set_info(ALACContext *alac)
Definition: alac.c:522
AlacRawDataBlockType
AlacRawDataBlockType
Definition: alac_data.h:28
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:284
ALACDSPContext::append_extra_bits
void(* append_extra_bits[2])(int32_t *buffer[2], int32_t *extra_bits_buffer[2], int extra_bits, int channels, int nb_samples)
Definition: alacdsp.h:27
mem.h
ALACContext::extra_bits_buffer
int32_t * extra_bits_buffer[2]
Definition: alac.c:73
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AVPacket
This structure stores compressed data.
Definition: packet.h:497
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
d
d
Definition: ffmpeg_filter.c:424
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
get_sbits_long
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:471
int
int
Definition: ffmpeg_filter.c:424
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ALACContext::gb
GetBitContext gb
Definition: alac.c:68
ALAC_EXTRADATA_SIZE
#define ALAC_EXTRADATA_SIZE
Definition: alac.c:63