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