FFmpeg  2.1.1
flacdec.c
Go to the documentation of this file.
1 /*
2  * FLAC (Free Lossless Audio Codec) decoder
3  * Copyright (c) 2003 Alex Beregszaszi
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  * FLAC (Free Lossless Audio Codec) decoder
25  * @author Alex Beregszaszi
26  * @see http://flac.sourceforge.net/
27  *
28  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
29  * through, starting from the initial 'fLaC' signature; or by passing the
30  * 34-byte streaminfo structure through avctx->extradata[_size] followed
31  * by data starting with the 0xFFF8 marker.
32  */
33 
34 #include <limits.h>
35 
36 #include "libavutil/avassert.h"
37 #include "libavutil/channel_layout.h"
38 #include "libavutil/crc.h"
39 #include "avcodec.h"
40 #include "internal.h"
41 #include "get_bits.h"
42 #include "bytestream.h"
43 #include "golomb.h"
44 #include "flac.h"
45 #include "flacdata.h"
46 #include "flacdsp.h"
47 #include "thread.h"
48 
49 typedef struct FLACContext {
51 
52  AVCodecContext *avctx; ///< parent AVCodecContext
53  GetBitContext gb; ///< GetBitContext initialized to start at the current frame
54 
55  int blocksize; ///< number of samples in the current frame
56  int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
57  int ch_mode; ///< channel decorrelation type in the current frame
58  int got_streaminfo; ///< indicates if the STREAMINFO has been read
59 
60  int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
62  unsigned int decoded_buffer_size;
63 
65 } FLACContext;
66 
67 static int allocate_buffers(FLACContext *s);
68 
69 static void flac_set_bps(FLACContext *s)
70 {
72  int need32 = s->bps > 16;
73  int want32 = av_get_bytes_per_sample(req) > 2;
74  int planar = av_sample_fmt_is_planar(req);
75 
76  if (need32 || want32) {
77  if (planar)
79  else
81  s->sample_shift = 32 - s->bps;
82  } else {
83  if (planar)
85  else
87  s->sample_shift = 16 - s->bps;
88  }
89 }
90 
92 {
93  enum FLACExtradataFormat format;
94  uint8_t *streaminfo;
95  int ret;
96  FLACContext *s = avctx->priv_data;
97  s->avctx = avctx;
98 
99  /* for now, the raw FLAC header is allowed to be passed to the decoder as
100  frame data instead of extradata. */
101  if (!avctx->extradata)
102  return 0;
103 
104  if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
105  return AVERROR_INVALIDDATA;
106 
107  /* initialize based on the demuxer-supplied streamdata header */
108  avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
109  ret = allocate_buffers(s);
110  if (ret < 0)
111  return ret;
112  flac_set_bps(s);
113  ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
114  s->got_streaminfo = 1;
115 
116  return 0;
117 }
118 
120 {
121  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
122  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
123  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
124  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
125  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
126 }
127 
129 {
130  int buf_size;
131 
132  av_assert0(s->max_blocksize);
133 
134  buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
135  AV_SAMPLE_FMT_S32P, 0);
136  if (buf_size < 0)
137  return buf_size;
138 
140  if (!s->decoded_buffer)
141  return AVERROR(ENOMEM);
142 
143  return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
144  s->decoded_buffer, s->channels,
145  s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
146 }
147 
148 /**
149  * Parse the STREAMINFO from an inline header.
150  * @param s the flac decoding context
151  * @param buf input buffer, starting with the "fLaC" marker
152  * @param buf_size buffer size
153  * @return non-zero if metadata is invalid
154  */
155 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
156 {
157  int metadata_type, metadata_size, ret;
158 
159  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
160  /* need more data */
161  return 0;
162  }
163  avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
164  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
165  metadata_size != FLAC_STREAMINFO_SIZE) {
166  return AVERROR_INVALIDDATA;
167  }
169  ret = allocate_buffers(s);
170  if (ret < 0)
171  return ret;
172  flac_set_bps(s);
173  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
174  s->got_streaminfo = 1;
175 
176  return 0;
177 }
178 
179 /**
180  * Determine the size of an inline header.
181  * @param buf input buffer, starting with the "fLaC" marker
182  * @param buf_size buffer size
183  * @return number of bytes in the header, or 0 if more data is needed
184  */
185 static int get_metadata_size(const uint8_t *buf, int buf_size)
186 {
187  int metadata_last, metadata_size;
188  const uint8_t *buf_end = buf + buf_size;
189 
190  buf += 4;
191  do {
192  if (buf_end - buf < 4)
193  return 0;
194  avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
195  buf += 4;
196  if (buf_end - buf < metadata_size) {
197  /* need more data in order to read the complete header */
198  return 0;
199  }
200  buf += metadata_size;
201  } while (!metadata_last);
202 
203  return buf_size - (buf_end - buf);
204 }
205 
206 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
207 {
208  int i, tmp, partition, method_type, rice_order;
209  int rice_bits, rice_esc;
210  int samples;
211 
212  method_type = get_bits(&s->gb, 2);
213  if (method_type > 1) {
214  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
215  method_type);
216  return AVERROR_INVALIDDATA;
217  }
218 
219  rice_order = get_bits(&s->gb, 4);
220 
221  samples= s->blocksize >> rice_order;
222  if (pred_order > samples) {
223  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
224  pred_order, samples);
225  return AVERROR_INVALIDDATA;
226  }
227 
228  rice_bits = 4 + method_type;
229  rice_esc = (1 << rice_bits) - 1;
230 
231  decoded += pred_order;
232  i= pred_order;
233  for (partition = 0; partition < (1 << rice_order); partition++) {
234  tmp = get_bits(&s->gb, rice_bits);
235  if (tmp == rice_esc) {
236  tmp = get_bits(&s->gb, 5);
237  for (; i < samples; i++)
238  *decoded++ = get_sbits_long(&s->gb, tmp);
239  } else {
240  for (; i < samples; i++) {
241  *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
242  }
243  }
244  i= 0;
245  }
246 
247  return 0;
248 }
249 
251  int pred_order, int bps)
252 {
253  const int blocksize = s->blocksize;
254  int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
255  int ret;
256 
257  /* warm up samples */
258  for (i = 0; i < pred_order; i++) {
259  decoded[i] = get_sbits_long(&s->gb, bps);
260  }
261 
262  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
263  return ret;
264 
265  if (pred_order > 0)
266  a = decoded[pred_order-1];
267  if (pred_order > 1)
268  b = a - decoded[pred_order-2];
269  if (pred_order > 2)
270  c = b - decoded[pred_order-2] + decoded[pred_order-3];
271  if (pred_order > 3)
272  d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
273 
274  switch (pred_order) {
275  case 0:
276  break;
277  case 1:
278  for (i = pred_order; i < blocksize; i++)
279  decoded[i] = a += decoded[i];
280  break;
281  case 2:
282  for (i = pred_order; i < blocksize; i++)
283  decoded[i] = a += b += decoded[i];
284  break;
285  case 3:
286  for (i = pred_order; i < blocksize; i++)
287  decoded[i] = a += b += c += decoded[i];
288  break;
289  case 4:
290  for (i = pred_order; i < blocksize; i++)
291  decoded[i] = a += b += c += d += decoded[i];
292  break;
293  default:
294  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
295  return AVERROR_INVALIDDATA;
296  }
297 
298  return 0;
299 }
300 
301 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
302  int bps)
303 {
304  int i, ret;
305  int coeff_prec, qlevel;
306  int coeffs[32];
307 
308  /* warm up samples */
309  for (i = 0; i < pred_order; i++) {
310  decoded[i] = get_sbits_long(&s->gb, bps);
311  }
312 
313  coeff_prec = get_bits(&s->gb, 4) + 1;
314  if (coeff_prec == 16) {
315  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
316  return AVERROR_INVALIDDATA;
317  }
318  qlevel = get_sbits(&s->gb, 5);
319  if (qlevel < 0) {
320  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
321  qlevel);
322  return AVERROR_INVALIDDATA;
323  }
324 
325  for (i = 0; i < pred_order; i++) {
326  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
327  }
328 
329  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
330  return ret;
331 
332  s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
333 
334  return 0;
335 }
336 
337 static inline int decode_subframe(FLACContext *s, int channel)
338 {
339  int32_t *decoded = s->decoded[channel];
340  int type, wasted = 0;
341  int bps = s->bps;
342  int i, tmp, ret;
343 
344  if (channel == 0) {
346  bps++;
347  } else {
349  bps++;
350  }
351 
352  if (get_bits1(&s->gb)) {
353  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
354  return AVERROR_INVALIDDATA;
355  }
356  type = get_bits(&s->gb, 6);
357 
358  if (get_bits1(&s->gb)) {
359  int left = get_bits_left(&s->gb);
360  wasted = 1;
361  if ( left < 0 ||
362  (left < bps && !show_bits_long(&s->gb, left)) ||
363  !show_bits_long(&s->gb, bps)) {
365  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
366  bps, left);
367  return AVERROR_INVALIDDATA;
368  }
369  while (!get_bits1(&s->gb))
370  wasted++;
371  bps -= wasted;
372  }
373  if (bps > 32) {
374  avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
375  return AVERROR_PATCHWELCOME;
376  }
377 
378 //FIXME use av_log2 for types
379  if (type == 0) {
380  tmp = get_sbits_long(&s->gb, bps);
381  for (i = 0; i < s->blocksize; i++)
382  decoded[i] = tmp;
383  } else if (type == 1) {
384  for (i = 0; i < s->blocksize; i++)
385  decoded[i] = get_sbits_long(&s->gb, bps);
386  } else if ((type >= 8) && (type <= 12)) {
387  if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
388  return ret;
389  } else if (type >= 32) {
390  if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
391  return ret;
392  } else {
393  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
394  return AVERROR_INVALIDDATA;
395  }
396 
397  if (wasted) {
398  int i;
399  for (i = 0; i < s->blocksize; i++)
400  decoded[i] <<= wasted;
401  }
402 
403  return 0;
404 }
405 
407 {
408  int i, ret;
409  GetBitContext *gb = &s->gb;
411 
412  if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
413  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
414  return ret;
415  }
416 
417  if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
418  s->channels = s->avctx->channels = fi.channels;
420  ret = allocate_buffers(s);
421  if (ret < 0)
422  return ret;
423  }
424  s->channels = s->avctx->channels = fi.channels;
425  if (!s->avctx->channel_layout)
427  s->ch_mode = fi.ch_mode;
428 
429  if (!s->bps && !fi.bps) {
430  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
431  return AVERROR_INVALIDDATA;
432  }
433  if (!fi.bps) {
434  fi.bps = s->bps;
435  } else if (s->bps && fi.bps != s->bps) {
436  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
437  "supported\n");
438  return AVERROR_INVALIDDATA;
439  }
440 
441  if (!s->bps) {
442  s->bps = s->avctx->bits_per_raw_sample = fi.bps;
443  flac_set_bps(s);
444  }
445 
446  if (!s->max_blocksize)
447  s->max_blocksize = FLAC_MAX_BLOCKSIZE;
448  if (fi.blocksize > s->max_blocksize) {
449  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
450  s->max_blocksize);
451  return AVERROR_INVALIDDATA;
452  }
453  s->blocksize = fi.blocksize;
454 
455  if (!s->samplerate && !fi.samplerate) {
456  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
457  " or frame header\n");
458  return AVERROR_INVALIDDATA;
459  }
460  if (fi.samplerate == 0)
461  fi.samplerate = s->samplerate;
462  s->samplerate = s->avctx->sample_rate = fi.samplerate;
463 
464  if (!s->got_streaminfo) {
465  ret = allocate_buffers(s);
466  if (ret < 0)
467  return ret;
468  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
469  s->got_streaminfo = 1;
471  }
472 
473 // dump_headers(s->avctx, (FLACStreaminfo *)s);
474 
475  /* subframes */
476  for (i = 0; i < s->channels; i++) {
477  if ((ret = decode_subframe(s, i)) < 0)
478  return ret;
479  }
480 
481  align_get_bits(gb);
482 
483  /* frame footer */
484  skip_bits(gb, 16); /* data crc */
485 
486  return 0;
487 }
488 
489 static int flac_decode_frame(AVCodecContext *avctx, void *data,
490  int *got_frame_ptr, AVPacket *avpkt)
491 {
492  AVFrame *frame = data;
493  ThreadFrame tframe = { .f = data };
494  const uint8_t *buf = avpkt->data;
495  int buf_size = avpkt->size;
496  FLACContext *s = avctx->priv_data;
497  int bytes_read = 0;
498  int ret;
499 
500  *got_frame_ptr = 0;
501 
502  if (s->max_framesize == 0) {
503  s->max_framesize =
504  ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
505  FLAC_MAX_CHANNELS, 32);
506  }
507 
508  if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
509  av_log(s->avctx, AV_LOG_DEBUG, "skiping flac header packet 1\n");
510  return buf_size;
511  }
512 
513  if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
514  av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");
515  return buf_size;
516  }
517 
518  /* check that there is at least the smallest decodable amount of data.
519  this amount corresponds to the smallest valid FLAC frame possible.
520  FF F8 69 02 00 00 9A 00 00 34 46 */
521  if (buf_size < FLAC_MIN_FRAME_SIZE)
522  return buf_size;
523 
524  /* check for inline header */
525  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
526  if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
527  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
528  return ret;
529  }
530  return get_metadata_size(buf, buf_size);
531  }
532 
533  /* decode frame */
534  if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
535  return ret;
536  if ((ret = decode_frame(s)) < 0) {
537  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
538  return ret;
539  }
540  bytes_read = get_bits_count(&s->gb)/8;
541 
544  0, buf, bytes_read)) {
545  av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
547  return AVERROR_INVALIDDATA;
548  }
549 
550  /* get output buffer */
551  frame->nb_samples = s->blocksize;
552  if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
553  return ret;
554 
555  s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
556  s->blocksize, s->sample_shift);
557 
558  if (bytes_read > buf_size) {
559  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
560  return AVERROR_INVALIDDATA;
561  }
562  if (bytes_read < buf_size) {
563  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
564  buf_size - bytes_read, buf_size);
565  }
566 
567  *got_frame_ptr = 1;
568 
569  return bytes_read;
570 }
571 
573 {
574  FLACContext *s = avctx->priv_data;
575  s->decoded_buffer = NULL;
576  s->decoded_buffer_size = 0;
577  s->avctx = avctx;
578  if (s->max_blocksize)
579  return allocate_buffers(s);
580  return 0;
581 }
582 
584 {
585  FLACContext *s = avctx->priv_data;
586 
588 
589  return 0;
590 }
591 
593  .name = "flac",
594  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
595  .type = AVMEDIA_TYPE_AUDIO,
596  .id = AV_CODEC_ID_FLAC,
597  .priv_data_size = sizeof(FLACContext),
602  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
603  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
608 };
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:378
static int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (flac).
Definition: golomb.h:376
static const int16_t coeffs[28]
const char * s
Definition: avisynth_c.h:668
#define AVERROR_PATCHWELCOME
This structure describes decoded (raw) audio or video data.
Definition: frame.h:96
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:306
void avpriv_flac_parse_block_header(const uint8_t *block_header, int *last, int *type, int *size)
Parse the metadata block parameters from the header.
Definition: flac.c:236
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:255
AVFrame * f
Definition: thread.h:36
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static int allocate_buffers(FLACContext *s)
Definition: flacdec.c:128
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int bps)
Definition: flacdsp.c:88
int ff_flac_get_max_frame_size(int blocksize, int ch, int bps)
Calculate an estimate for the maximum frame size based on verbatim mode.
Definition: flac.c:148
int size
Definition: avcodec.h:1064
const char * b
Definition: vf_curves.c:105
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
int avpriv_flac_is_extradata_valid(AVCodecContext *avctx, enum FLACExtradataFormat *format, uint8_t **streaminfo_start)
Validate the FLAC extradata.
Definition: flac.c:169
#define FLAC_MAX_BLOCKSIZE
Definition: flac.h:36
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2570
static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
Definition: flacdec.c:206
AVCodec.
Definition: avcodec.h:2922
#define av_cold
Definition: avcodec.h:653
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:85
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:240
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1254
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:370
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:234
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: utils.c:153
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1881
uint8_t
FLACDSPContext dsp
Definition: flacdec.c:64
signed 32 bits, planar
Definition: samplefmt.h:59
Multithreading support functions.
const char * name
Name of the codec implementation.
Definition: avcodec.h:2929
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:125
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:742
static void flac_set_bps(FLACContext *s)
Definition: flacdec.c:69
uint8_t * decoded_buffer
Definition: flacdec.c:61
const char data[16]
Definition: mxf.c:68
signed 32 bits
Definition: samplefmt.h:53
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:207
int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, const uint8_t *buf, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Fill plane data pointers and linesize for samples with sample format sample_fmt.
Definition: samplefmt.c:155
bitstream reader API header.
unsigned int decoded_buffer_size
Definition: flacdec.c:62
#define av_uninit(x)
Definition: avcodec.h:720
signed 16 bits
Definition: samplefmt.h:52
static AVFrame * frame
Definition: demuxing.c:51
FLACExtradataFormat
Definition: flac.h:57
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:583
AVS_FilterInfo ** fi
Definition: avisynth_c.h:635
int32_t * decoded[FLAC_MAX_CHANNELS]
decoded samples
Definition: flacdec.c:60
int ch_mode
channel decorrelation mode
Definition: flac.h:86
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
enum AVSampleFormat request_sample_fmt
desired sample format
Definition: avcodec.h:1956
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:151
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: avcodec.h:4168
static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:301
static int get_metadata_size(const uint8_t *buf, int buf_size)
Determine the size of an inline header.
Definition: flacdec.c:185
GetBitContext gb
GetBitContext initialized to start at the current frame.
Definition: flacdec.c:53
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
Definition: flacdec.c:119
void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Parse the Streaminfo metadata block.
Definition: flac.c:204
#define FLACSTREAMINFO
Data needed from the Streaminfo header for use by the raw FLAC demuxer and/or the FLAC decoder...
Definition: flac.h:72
int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, FLACFrameInfo *fi, int log_level_offset)
Validate and decode a frame header.
Definition: flac.c:50
Libavcodec external API header.
static int decode_subframe_fixed(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:250
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1934
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:190
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2476
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread.c:1021
int got_streaminfo
indicates if the STREAMINFO has been read
Definition: flacdec.c:58
ret
Definition: avfilter.c:961
int32_t
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length) av_pure
Calculate the CRC of a block.
Definition: crc.c:320
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:33
int sample_shift
shift required to make output samples 16-bit or 32-bit
Definition: flacdec.c:56
AVCodec ff_flac_decoder
Definition: flacdec.c:592
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
int sample_rate
samples per second
Definition: avcodec.h:1873
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:436
void(* lpc)(int32_t *samples, const int coeffs[32], int order, int qlevel, int len)
Definition: flacdsp.h:28
static int decode_frame(FLACContext *s)
Definition: flacdec.c:406
main external API structure.
Definition: avcodec.h:1146
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:538
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2480
void * buf
Definition: avisynth_c.h:594
void ff_flac_set_channel_layout(AVCodecContext *avctx)
Definition: flac.c:196
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:299
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:292
uint8_t * data
Definition: avcodec.h:1063
#define MKBETAG(a, b, c, d)
#define type
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
Parse the STREAMINFO from an inline header.
Definition: flacdec.c:155
void * priv_data
Definition: avcodec.h:1182
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
int blocksize
number of samples in the current frame
Definition: flacdec.c:55
static int decode_subframe(FLACContext *s, int channel)
Definition: flacdec.c:337
FLACSTREAMINFO AVCodecContext * avctx
parent AVCodecContext
Definition: flacdec.c:52
common internal api header.
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:811
static double c[64]
#define FLAC_MIN_FRAME_SIZE
Definition: flac.h:37
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:118
unsigned bps
Definition: movenc.c:962
#define AV_RB32(x)
Definition: intreadwrite.h:258
#define AVERROR_INVALIDDATA
int channels
number of audio channels
Definition: avcodec.h:1874
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:444
#define AVERROR(e)
static av_cold int flac_decode_init(AVCodecContext *avctx)
Definition: flacdec.c:91
#define AV_EF_CRCCHECK
verify embedded CRCs
Definition: avcodec.h:2477
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
signed 16 bits, planar
Definition: samplefmt.h:58
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define AV_EF_COMPLIANT
consider all spec non compliancies as errors
Definition: avcodec.h:2483
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:104
exp golomb vlc stuff
This structure stores compressed data.
Definition: avcodec.h:1040
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:150
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:107
int64_t pts
Presentation timestamp in AVStream-&gt;time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1056
void(* decorrelate[4])(uint8_t **out, int32_t **in, int channels, int len, int shift)
Definition: flacdsp.h:26
static int init_thread_copy(AVCodecContext *avctx)
Definition: flacdec.c:572
#define FLAC_MAX_CHANNELS
Definition: flac.h:34
static av_cold int flac_decode_close(AVCodecContext *avctx)
Definition: flacdec.c:583
int ch_mode
channel decorrelation type in the current frame
Definition: flacdec.c:57
static int flac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: flacdec.c:489