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