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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
34 #include <limits.h>
35 
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 
47 #undef NDEBUG
48 #include <assert.h>
49 
50 typedef struct FLACContext {
52 
56 
57  int blocksize;
59  int ch_mode;
61 
64  unsigned int decoded_buffer_size;
65 
67 } FLACContext;
68 
69 static int allocate_buffers(FLACContext *s);
70 
71 static void flac_set_bps(FLACContext *s)
72 {
74  int need32 = s->bps > 16;
75  int want32 = av_get_bytes_per_sample(req) > 2;
76  int planar = av_sample_fmt_is_planar(req);
77 
78  if (need32 || want32) {
79  if (planar)
81  else
83  s->sample_shift = 32 - s->bps;
84  } else {
85  if (planar)
87  else
89  s->sample_shift = 16 - s->bps;
90  }
91 }
92 
94 {
95  enum FLACExtradataFormat format;
96  uint8_t *streaminfo;
97  int ret;
98  FLACContext *s = avctx->priv_data;
99  s->avctx = avctx;
100 
101  /* for now, the raw FLAC header is allowed to be passed to the decoder as
102  frame data instead of extradata. */
103  if (!avctx->extradata)
104  return 0;
105 
106  if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
107  return -1;
108 
109  /* initialize based on the demuxer-supplied streamdata header */
110  avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
111  ret = allocate_buffers(s);
112  if (ret < 0)
113  return ret;
114  flac_set_bps(s);
115  ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
116  s->got_streaminfo = 1;
117 
119  avctx->coded_frame = &s->frame;
120 
121  return 0;
122 }
123 
125 {
126  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
127  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
128  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
129  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
130  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
131 }
132 
134 {
135  int buf_size;
136 
137  assert(s->max_blocksize);
138 
139  buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
140  AV_SAMPLE_FMT_S32P, 0);
141  if (buf_size < 0)
142  return buf_size;
143 
145  if (!s->decoded_buffer)
146  return AVERROR(ENOMEM);
147 
149  s->decoded_buffer, s->channels,
150  s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
151 }
152 
160 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
161 {
162  int metadata_type, metadata_size, ret;
163 
164  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
165  /* need more data */
166  return 0;
167  }
168  avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
169  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
170  metadata_size != FLAC_STREAMINFO_SIZE) {
171  return AVERROR_INVALIDDATA;
172  }
174  ret = allocate_buffers(s);
175  if (ret < 0)
176  return ret;
177  flac_set_bps(s);
178  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
179  s->got_streaminfo = 1;
180 
181  return 0;
182 }
183 
190 static int get_metadata_size(const uint8_t *buf, int buf_size)
191 {
192  int metadata_last, metadata_size;
193  const uint8_t *buf_end = buf + buf_size;
194 
195  buf += 4;
196  do {
197  if (buf_end - buf < 4)
198  return 0;
199  avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
200  buf += 4;
201  if (buf_end - buf < metadata_size) {
202  /* need more data in order to read the complete header */
203  return 0;
204  }
205  buf += metadata_size;
206  } while (!metadata_last);
207 
208  return buf_size - (buf_end - buf);
209 }
210 
211 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
212 {
213  int i, tmp, partition, method_type, rice_order;
214  int rice_bits, rice_esc;
215  int samples;
216 
217  method_type = get_bits(&s->gb, 2);
218  if (method_type > 1) {
219  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
220  method_type);
221  return -1;
222  }
223 
224  rice_order = get_bits(&s->gb, 4);
225 
226  samples= s->blocksize >> rice_order;
227  if (pred_order > samples) {
228  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
229  pred_order, samples);
230  return -1;
231  }
232 
233  rice_bits = 4 + method_type;
234  rice_esc = (1 << rice_bits) - 1;
235 
236  decoded += pred_order;
237  i= pred_order;
238  for (partition = 0; partition < (1 << rice_order); partition++) {
239  tmp = get_bits(&s->gb, rice_bits);
240  if (tmp == rice_esc) {
241  tmp = get_bits(&s->gb, 5);
242  for (; i < samples; i++)
243  *decoded++ = get_sbits_long(&s->gb, tmp);
244  } else {
245  for (; i < samples; i++) {
246  *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
247  }
248  }
249  i= 0;
250  }
251 
252  return 0;
253 }
254 
255 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
256  int pred_order, int bps)
257 {
258  const int blocksize = s->blocksize;
259  int a, b, c, d, i;
260 
261  /* warm up samples */
262  for (i = 0; i < pred_order; i++) {
263  decoded[i] = get_sbits_long(&s->gb, bps);
264  }
265 
266  if (decode_residuals(s, decoded, pred_order) < 0)
267  return -1;
268 
269  if (pred_order > 0)
270  a = decoded[pred_order-1];
271  if (pred_order > 1)
272  b = a - decoded[pred_order-2];
273  if (pred_order > 2)
274  c = b - decoded[pred_order-2] + decoded[pred_order-3];
275  if (pred_order > 3)
276  d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
277 
278  switch (pred_order) {
279  case 0:
280  break;
281  case 1:
282  for (i = pred_order; i < blocksize; i++)
283  decoded[i] = a += decoded[i];
284  break;
285  case 2:
286  for (i = pred_order; i < blocksize; i++)
287  decoded[i] = a += b += decoded[i];
288  break;
289  case 3:
290  for (i = pred_order; i < blocksize; i++)
291  decoded[i] = a += b += c += decoded[i];
292  break;
293  case 4:
294  for (i = pred_order; i < blocksize; i++)
295  decoded[i] = a += b += c += d += decoded[i];
296  break;
297  default:
298  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
299  return -1;
300  }
301 
302  return 0;
303 }
304 
305 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
306  int bps)
307 {
308  int i;
309  int coeff_prec, qlevel;
310  int coeffs[32];
311 
312  /* warm up samples */
313  for (i = 0; i < pred_order; i++) {
314  decoded[i] = get_sbits_long(&s->gb, bps);
315  }
316 
317  coeff_prec = get_bits(&s->gb, 4) + 1;
318  if (coeff_prec == 16) {
319  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
320  return -1;
321  }
322  qlevel = get_sbits(&s->gb, 5);
323  if (qlevel < 0) {
324  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
325  qlevel);
326  return -1;
327  }
328 
329  for (i = 0; i < pred_order; i++) {
330  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
331  }
332 
333  if (decode_residuals(s, decoded, pred_order) < 0)
334  return -1;
335 
336  s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
337 
338  return 0;
339 }
340 
341 static inline int decode_subframe(FLACContext *s, int channel)
342 {
343  int32_t *decoded = s->decoded[channel];
344  int type, wasted = 0;
345  int bps = s->bps;
346  int i, tmp;
347 
348  if (channel == 0) {
350  bps++;
351  } else {
353  bps++;
354  }
355 
356  if (get_bits1(&s->gb)) {
357  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
358  return -1;
359  }
360  type = get_bits(&s->gb, 6);
361 
362  if (get_bits1(&s->gb)) {
363  int left = get_bits_left(&s->gb);
364  wasted = 1;
365  if ( left < 0 ||
366  (left < bps && !show_bits_long(&s->gb, left)) ||
367  !show_bits_long(&s->gb, bps)) {
369  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
370  bps, left);
371  return AVERROR_INVALIDDATA;
372  }
373  while (!get_bits1(&s->gb))
374  wasted++;
375  bps -= wasted;
376  }
377  if (bps > 32) {
378  av_log_missing_feature(s->avctx, "Decorrelated bit depth > 32", 0);
379  return AVERROR_PATCHWELCOME;
380  }
381 
382 //FIXME use av_log2 for types
383  if (type == 0) {
384  tmp = get_sbits_long(&s->gb, bps);
385  for (i = 0; i < s->blocksize; i++)
386  decoded[i] = tmp;
387  } else if (type == 1) {
388  for (i = 0; i < s->blocksize; i++)
389  decoded[i] = get_sbits_long(&s->gb, bps);
390  } else if ((type >= 8) && (type <= 12)) {
391  if (decode_subframe_fixed(s, decoded, type & ~0x8, bps) < 0)
392  return -1;
393  } else if (type >= 32) {
394  if (decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps) < 0)
395  return -1;
396  } else {
397  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
398  return -1;
399  }
400 
401  if (wasted) {
402  int i;
403  for (i = 0; i < s->blocksize; i++)
404  decoded[i] <<= wasted;
405  }
406 
407  return 0;
408 }
409 
410 static int decode_frame(FLACContext *s)
411 {
412  int i, ret;
413  GetBitContext *gb = &s->gb;
414  FLACFrameInfo fi;
415 
416  if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
417  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
418  return -1;
419  }
420 
421  if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
422  s->channels = s->avctx->channels = fi.channels;
424  ret = allocate_buffers(s);
425  if (ret < 0)
426  return ret;
427  }
428  s->channels = s->avctx->channels = fi.channels;
429  if (!s->avctx->channel_layout && s->channels <= 6)
431  s->ch_mode = fi.ch_mode;
432 
433  if (!s->bps && !fi.bps) {
434  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
435  return -1;
436  }
437  if (!fi.bps) {
438  fi.bps = s->bps;
439  } else if (s->bps && fi.bps != s->bps) {
440  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
441  "supported\n");
442  return -1;
443  }
444 
445  if (!s->bps) {
446  s->bps = s->avctx->bits_per_raw_sample = fi.bps;
447  flac_set_bps(s);
448  }
449 
450  if (!s->max_blocksize)
451  s->max_blocksize = FLAC_MAX_BLOCKSIZE;
452  if (fi.blocksize > s->max_blocksize) {
453  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
454  s->max_blocksize);
455  return -1;
456  }
457  s->blocksize = fi.blocksize;
458 
459  if (!s->samplerate && !fi.samplerate) {
460  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
461  " or frame header\n");
462  return -1;
463  }
464  if (fi.samplerate == 0)
465  fi.samplerate = s->samplerate;
466  s->samplerate = s->avctx->sample_rate = fi.samplerate;
467 
468  if (!s->got_streaminfo) {
469  ret = allocate_buffers(s);
470  if (ret < 0)
471  return ret;
472  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
473  s->got_streaminfo = 1;
475  }
476 
477 // dump_headers(s->avctx, (FLACStreaminfo *)s);
478 
479  /* subframes */
480  for (i = 0; i < s->channels; i++) {
481  if (decode_subframe(s, i) < 0)
482  return -1;
483  }
484 
485  align_get_bits(gb);
486 
487  /* frame footer */
488  skip_bits(gb, 16); /* data crc */
489 
490  return 0;
491 }
492 
493 static int flac_decode_frame(AVCodecContext *avctx, void *data,
494  int *got_frame_ptr, AVPacket *avpkt)
495 {
496  const uint8_t *buf = avpkt->data;
497  int buf_size = avpkt->size;
498  FLACContext *s = avctx->priv_data;
499  int bytes_read = 0;
500  int ret;
501 
502  *got_frame_ptr = 0;
503 
504  if (s->max_framesize == 0) {
505  s->max_framesize =
506  ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
507  FLAC_MAX_CHANNELS, 32);
508  }
509 
510  /* check that there is at least the smallest decodable amount of data.
511  this amount corresponds to the smallest valid FLAC frame possible.
512  FF F8 69 02 00 00 9A 00 00 34 46 */
513  if (buf_size < FLAC_MIN_FRAME_SIZE)
514  return buf_size;
515 
516  /* check for inline header */
517  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
518  if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
519  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
520  return -1;
521  }
522  return get_metadata_size(buf, buf_size);
523  }
524 
525  /* decode frame */
526  init_get_bits(&s->gb, buf, buf_size*8);
527  if (decode_frame(s) < 0) {
528  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
529  return -1;
530  }
531  bytes_read = (get_bits_count(&s->gb)+7)/8;
532 
533  /* get output buffer */
534  s->frame.nb_samples = s->blocksize;
535  if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
536  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
537  return ret;
538  }
539 
540  s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels,
541  s->blocksize, s->sample_shift);
542 
543  if (bytes_read > buf_size) {
544  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
545  return -1;
546  }
547  if (bytes_read < buf_size) {
548  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
549  buf_size - bytes_read, buf_size);
550  }
551 
552  *got_frame_ptr = 1;
553  *(AVFrame *)data = s->frame;
554 
555  return bytes_read;
556 }
557 
559 {
560  FLACContext *s = avctx->priv_data;
561 
563 
564  return 0;
565 }
566 
568  .name = "flac",
569  .type = AVMEDIA_TYPE_AUDIO,
570  .id = AV_CODEC_ID_FLAC,
571  .priv_data_size = sizeof(FLACContext),
575  .capabilities = CODEC_CAP_DR1,
576  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
577  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
581  -1 },
582 };
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:345
static int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (flac).
Definition: golomb.h:348
static const int16_t coeffs[28]
static int16_t * samples
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
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:108
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:235
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
struct FLACContext FLACContext
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2725
static int allocate_buffers(FLACContext *s)
Definition: flacdec.c:133
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int bps)
Definition: flacdsp.c:88
static void align_get_bits(GetBitContext *s)
Definition: get_bits.h:412
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:146
int size
Definition: avcodec.h:916
int avpriv_flac_is_extradata_valid(AVCodecContext *avctx, enum FLACExtradataFormat *format, uint8_t **streaminfo_start)
Validate the FLAC extradata.
Definition: flac.c:167
#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:2711
static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
Definition: flacdec.c:211
signed 16 bits
Definition: samplefmt.h:52
AVCodec.
Definition: avcodec.h:2960
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:85
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:223
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:337
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:151
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:72
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 channel data pointers and linesize for samples with sample format sample_fmt.
Definition: samplefmt.c:140
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2112
uint8_t
FLACDSPContext dsp
Definition: flacdec.c:66
#define AV_RB32
Definition: intreadwrite.h:130
#define b
Definition: input.c:52
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1454
static void flac_set_bps(FLACContext *s)
Definition: flacdec.c:71
uint8_t * decoded_buffer
Definition: flacdec.c:63
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:915
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:192
bitstream reader API header.
unsigned int decoded_buffer_size
Definition: flacdec.c:64
signed 32 bits, planar
Definition: samplefmt.h:59
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
FLACExtradataFormat
Definition: flac.h:57
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:547
int32_t * decoded[FLAC_MAX_CHANNELS]
decoded samples
Definition: flacdec.c:62
int ch_mode
channel decorrelation mode
Definition: flac.h:86
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
enum AVSampleFormat request_sample_fmt
Used to request a sample format from the decoder.
Definition: avcodec.h:2186
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:305
static int get_metadata_size(const uint8_t *buf, int buf_size)
Determine the size of an inline header.
Definition: flacdec.c:190
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
GetBitContext gb
GetBitContext initialized to start at the current frame.
Definition: flacdec.c:55
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
Definition: flacdec.c:124
void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Parse the Streaminfo metadata block.
Definition: flac.c:202
#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:48
static int decode_subframe_fixed(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:255
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2165
signed 32 bits
Definition: samplefmt.h:53
audio channel layout utility functions
int got_streaminfo
indicates if the STREAMINFO has been read
Definition: flacdec.c:60
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
Definition: utils.c:464
int32_t
#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:58
AVCodec ff_flac_decoder
Definition: flacdec.c:567
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:95
NULL
Definition: eval.c:52
AVFrame frame
Definition: flacdec.c:54
external API header
int sample_rate
samples per second
Definition: avcodec.h:2104
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:410
main external API structure.
Definition: avcodec.h:1339
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:326
void ff_flac_set_channel_layout(AVCodecContext *avctx)
Definition: flac.c:194
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: utils.c:602
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:260
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:101
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
Definition: utils.c:2005
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:372
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
Parse the STREAMINFO from an inline header.
Definition: flacdec.c:160
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
int blocksize
number of samples in the current frame
Definition: flacdec.c:57
static int decode_subframe(FLACContext *s, int channel)
Definition: flacdec.c:341
FLACSTREAMINFO AVCodecContext * avctx
parent AVCodecContext
Definition: flacdec.c:53
common internal api header.
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
#define FLAC_MIN_FRAME_SIZE
Definition: flac.h:37
unsigned bps
Definition: movenc.c:803
void * priv_data
Definition: avcodec.h:1382
int channels
number of audio channels
Definition: avcodec.h:2105
signed 16 bits, planar
Definition: samplefmt.h:58
static av_cold int flac_decode_init(AVCodecContext *avctx)
Definition: flacdec.c:93
exp golomb vlc stuff
This structure stores compressed data.
Definition: avcodec.h:898
int nb_samples
number of audio samples (per channel) described by this frame
Definition: avcodec.h:1042
void(* decorrelate[4])(uint8_t **out, int32_t **in, int channels, int len, int shift)
Definition: flacdsp.h:26
#define FLAC_MAX_CHANNELS
Definition: flac.h:34
static av_cold int flac_decode_close(AVCodecContext *avctx)
Definition: flacdec.c:558
int ch_mode
channel decorrelation type in the current frame
Definition: flacdec.c:59
static int flac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: flacdec.c:493