FFmpeg
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 "libavutil/mem.h"
39 #include "libavutil/opt.h"
40 #include "avcodec.h"
41 #include "codec_internal.h"
42 #include "get_bits.h"
43 #include "golomb.h"
44 #include "flac.h"
45 #include "flacdsp.h"
46 #include "flac_parse.h"
47 #include "thread.h"
48 #include "unary.h"
49 
50 
51 typedef struct FLACContext {
52  AVClass *class;
54 
55  AVCodecContext *avctx; ///< parent AVCodecContext
56  GetBitContext gb; ///< GetBitContext initialized to start at the current frame
57 
58  int blocksize; ///< number of samples in the current frame
59  int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
60  int ch_mode; ///< channel decorrelation type in the current frame
61  int got_streaminfo; ///< indicates if the STREAMINFO has been read
62 
63  int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
64  uint8_t *decoded_buffer;
65  unsigned int decoded_buffer_size;
66  int64_t *decoded_33bps; ///< decoded samples for a 33 bps subframe
69  int buggy_lpc; ///< use workaround for old lavc encoded files
70 
72 } FLACContext;
73 
74 static int allocate_buffers(FLACContext *s);
75 
76 static void flac_set_bps(FLACContext *s)
77 {
78  enum AVSampleFormat req = s->avctx->request_sample_fmt;
79  int need32 = s->stream_info.bps > 16;
80  int want32 = av_get_bytes_per_sample(req) > 2;
82 
83  if (need32 || want32) {
84  if (planar)
85  s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
86  else
87  s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
88  s->sample_shift = 32 - s->stream_info.bps;
89  } else {
90  if (planar)
91  s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
92  else
93  s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
94  s->sample_shift = 16 - s->stream_info.bps;
95  }
96 }
97 
99 {
100  uint8_t *streaminfo;
101  int ret;
102  FLACContext *s = avctx->priv_data;
103  s->avctx = avctx;
104 
105  /* for now, the raw FLAC header is allowed to be passed to the decoder as
106  frame data instead of extradata. */
107  if (!avctx->extradata)
108  return 0;
109 
110  if (!ff_flac_is_extradata_valid(avctx, &streaminfo))
111  return AVERROR_INVALIDDATA;
112 
113  /* initialize based on the demuxer-supplied streamdata header */
114  ret = ff_flac_parse_streaminfo(avctx, &s->stream_info, streaminfo);
115  if (ret < 0)
116  return ret;
118  if (ret < 0)
119  return ret;
120  flac_set_bps(s);
121  ff_flacdsp_init(&s->dsp, avctx->sample_fmt,
122  s->stream_info.channels);
123  s->got_streaminfo = 1;
124 
125  return 0;
126 }
127 
129 {
130  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
131  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
132  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
133  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
134  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
135 }
136 
138 {
139  int buf_size;
140  int ret;
141 
142  av_assert0(s->stream_info.max_blocksize);
143 
144  buf_size = av_samples_get_buffer_size(NULL, s->stream_info.channels,
145  s->stream_info.max_blocksize,
146  AV_SAMPLE_FMT_S32P, 0);
147  if (buf_size < 0)
148  return buf_size;
149 
150  av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
151  if (!s->decoded_buffer)
152  return AVERROR(ENOMEM);
153 
154  ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
155  s->decoded_buffer,
156  s->stream_info.channels,
157  s->stream_info.max_blocksize,
158  AV_SAMPLE_FMT_S32P, 0);
159  if (ret >= 0 && s->stream_info.bps == 32 && s->stream_info.channels == 2) {
160  buf_size = av_samples_get_buffer_size(NULL, 1,
161  s->stream_info.max_blocksize,
162  AV_SAMPLE_FMT_S64P, 0);
163  if (buf_size < 0)
164  return buf_size;
165 
166  av_fast_malloc(&s->decoded_buffer_33bps, &s->decoded_buffer_size_33bps, buf_size);
167  if (!s->decoded_buffer_33bps)
168  return AVERROR(ENOMEM);
169 
170  ret = av_samples_fill_arrays((uint8_t **)&s->decoded_33bps, NULL,
171  s->decoded_buffer_33bps,
172  1,
173  s->stream_info.max_blocksize,
174  AV_SAMPLE_FMT_S64P, 0);
175 
176  }
177  return ret < 0 ? ret : 0;
178 }
179 
180 /**
181  * Parse the STREAMINFO from an inline header.
182  * @param s the flac decoding context
183  * @param buf input buffer, starting with the "fLaC" marker
184  * @param buf_size buffer size
185  * @return non-zero if metadata is invalid
186  */
187 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
188 {
189  int metadata_type, metadata_size, ret;
190 
191  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
192  /* need more data */
193  return 0;
194  }
195  flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
196  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
197  metadata_size != FLAC_STREAMINFO_SIZE) {
198  return AVERROR_INVALIDDATA;
199  }
200  ret = ff_flac_parse_streaminfo(s->avctx, &s->stream_info, &buf[8]);
201  if (ret < 0)
202  return ret;
204  if (ret < 0)
205  return ret;
206  flac_set_bps(s);
207  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
208  s->stream_info.channels);
209  s->got_streaminfo = 1;
210 
211  return 0;
212 }
213 
214 /**
215  * Determine the size of an inline header.
216  * @param buf input buffer, starting with the "fLaC" marker
217  * @param buf_size buffer size
218  * @return number of bytes in the header, or 0 if more data is needed
219  */
220 static int get_metadata_size(const uint8_t *buf, int buf_size)
221 {
222  int metadata_last, metadata_size;
223  const uint8_t *buf_end = buf + buf_size;
224 
225  buf += 4;
226  do {
227  if (buf_end - buf < 4)
228  return AVERROR_INVALIDDATA;
229  flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
230  buf += 4;
231  if (buf_end - buf < metadata_size) {
232  /* need more data in order to read the complete header */
233  return AVERROR_INVALIDDATA;
234  }
235  buf += metadata_size;
236  } while (!metadata_last);
237 
238  return buf_size - (buf_end - buf);
239 }
240 
241 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
242 {
243  GetBitContext gb = s->gb;
244  int i, tmp, partition, method_type, rice_order;
245  int rice_bits, rice_esc;
246  int samples;
247 
248  method_type = get_bits(&gb, 2);
249  rice_order = get_bits(&gb, 4);
250 
251  samples = s->blocksize >> rice_order;
252  rice_bits = 4 + method_type;
253  rice_esc = (1 << rice_bits) - 1;
254 
255  decoded += pred_order;
256  i = pred_order;
257 
258  if (method_type > 1) {
259  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
260  method_type);
261  return AVERROR_INVALIDDATA;
262  }
263 
264  if (samples << rice_order != s->blocksize) {
265  av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
266  rice_order, s->blocksize);
267  return AVERROR_INVALIDDATA;
268  }
269 
270  if (pred_order > samples) {
271  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
272  pred_order, samples);
273  return AVERROR_INVALIDDATA;
274  }
275 
276  for (partition = 0; partition < (1 << rice_order); partition++) {
277  tmp = get_bits(&gb, rice_bits);
278  if (tmp == rice_esc) {
279  tmp = get_bits(&gb, 5);
280  for (; i < samples; i++)
281  *decoded++ = get_sbits_long(&gb, tmp);
282  } else {
283  int real_limit = (tmp > 1) ? (INT_MAX >> (tmp - 1)) + 2 : INT_MAX;
284  for (; i < samples; i++) {
285  int v = get_sr_golomb_flac(&gb, tmp, real_limit, 1);
286  if (v == 0x80000000){
287  av_log(s->avctx, AV_LOG_ERROR, "invalid residual\n");
288  return AVERROR_INVALIDDATA;
289  }
290 
291  *decoded++ = v;
292  }
293  }
294  i= 0;
295  }
296 
297  s->gb = gb;
298 
299  return 0;
300 }
301 
303  int pred_order, int bps)
304 {
305  const int blocksize = s->blocksize;
306  unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
307  int i;
308  int ret;
309 
310  /* warm up samples */
311  for (i = 0; i < pred_order; i++) {
312  decoded[i] = get_sbits_long(&s->gb, bps);
313  }
314 
315  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
316  return ret;
317 
318  if (pred_order > 0)
319  a = decoded[pred_order-1];
320  if (pred_order > 1)
321  b = a - decoded[pred_order-2];
322  if (pred_order > 2)
323  c = b - decoded[pred_order-2] + decoded[pred_order-3];
324  if (pred_order > 3)
325  d = c - decoded[pred_order-2] + 2U*decoded[pred_order-3] - decoded[pred_order-4];
326 
327  switch (pred_order) {
328  case 0:
329  break;
330  case 1:
331  for (i = pred_order; i < blocksize; i++)
332  decoded[i] = a += decoded[i];
333  break;
334  case 2:
335  for (i = pred_order; i < blocksize; i++)
336  decoded[i] = a += b += decoded[i];
337  break;
338  case 3:
339  for (i = pred_order; i < blocksize; i++)
340  decoded[i] = a += b += c += decoded[i];
341  break;
342  case 4:
343  for (i = pred_order; i < blocksize; i++)
344  decoded[i] = a += b += c += d += decoded[i];
345  break;
346  default:
347  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
348  return AVERROR_INVALIDDATA;
349  }
350 
351  return 0;
352 }
353 
354 #define DECODER_SUBFRAME_FIXED_WIDE(residual) { \
355  const int blocksize = s->blocksize; \
356  int ret; \
357  \
358  if ((ret = decode_residuals(s, residual, pred_order)) < 0) \
359  return ret; \
360  \
361  switch (pred_order) { \
362  case 0: \
363  for (int i = pred_order; i < blocksize; i++) \
364  decoded[i] = residual[i]; \
365  break; \
366  case 1: \
367  for (int i = pred_order; i < blocksize; i++) \
368  decoded[i] = (uint64_t)residual[i] + (uint64_t)decoded[i-1];\
369  break; \
370  case 2: \
371  for (int i = pred_order; i < blocksize; i++) \
372  decoded[i] = (uint64_t)residual[i] + 2*(uint64_t)decoded[i-1] - (uint64_t)decoded[i-2]; \
373  break; \
374  case 3: \
375  for (int i = pred_order; i < blocksize; i++) \
376  decoded[i] = (uint64_t)residual[i] + 3*(uint64_t)decoded[i-1] - 3*(uint64_t)decoded[i-2] + (uint64_t)decoded[i-3]; \
377  break; \
378  case 4: \
379  for (int i = pred_order; i < blocksize; i++) \
380  decoded[i] = (uint64_t)residual[i] + 4*(uint64_t)decoded[i-1] - 6*(uint64_t)decoded[i-2] + 4*(uint64_t)decoded[i-3] - (uint64_t)decoded[i-4]; \
381  break; \
382  default: \
383  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); \
384  return AVERROR_INVALIDDATA; \
385  } \
386  return 0; \
387 }
388 
390  int pred_order, int bps)
391 {
392  /* warm up samples */
393  for (int i = 0; i < pred_order; i++) {
394  decoded[i] = get_sbits_long(&s->gb, bps);
395  }
397 }
398 
399 
401  int32_t *residual, int pred_order)
402 {
403  /* warm up samples */ \
404  for (int i = 0; i < pred_order; i++) { \
405  decoded[i] = get_sbits64(&s->gb, 33); \
406  } \
407  DECODER_SUBFRAME_FIXED_WIDE(residual);
408 }
409 
410 static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32],
411  int order, int qlevel, int len, int bps)
412 {
413  int i, j;
414  int ebps = 1 << (bps-1);
415  unsigned sigma = 0;
416 
417  for (i = order; i < len; i++)
418  sigma |= decoded[i] + ebps;
419 
420  if (sigma < 2*ebps)
421  return;
422 
423  for (i = len - 1; i >= order; i--) {
424  int64_t p = 0;
425  for (j = 0; j < order; j++)
426  p += coeffs[j] * (int64_t)(int32_t)decoded[i-order+j];
427  decoded[i] -= p >> qlevel;
428  }
429  for (i = order; i < len; i++, decoded++) {
430  int32_t p = 0;
431  for (j = 0; j < order; j++)
432  p += coeffs[j] * (uint32_t)decoded[j];
433  decoded[j] += p >> qlevel;
434  }
435 }
436 
437 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
438  int bps)
439 {
440  int i, ret;
441  int coeff_prec, qlevel;
442  int coeffs[32];
443 
444  /* warm up samples */
445  for (i = 0; i < pred_order; i++) {
446  decoded[i] = get_sbits_long(&s->gb, bps);
447  }
448 
449  coeff_prec = get_bits(&s->gb, 4) + 1;
450  if (coeff_prec == 16) {
451  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
452  return AVERROR_INVALIDDATA;
453  }
454  qlevel = get_sbits(&s->gb, 5);
455  if (qlevel < 0) {
456  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
457  qlevel);
458  return AVERROR_INVALIDDATA;
459  }
460 
461  for (i = 0; i < pred_order; i++) {
462  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
463  }
464 
465  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
466  return ret;
467 
468  if ( ( s->buggy_lpc && s->stream_info.bps <= 16)
469  || ( !s->buggy_lpc && bps <= 16
470  && bps + coeff_prec + av_log2(pred_order) <= 32)) {
471  s->dsp.lpc16(decoded, coeffs, pred_order, qlevel, s->blocksize);
472  } else {
473  s->dsp.lpc32(decoded, coeffs, pred_order, qlevel, s->blocksize);
474  if (s->stream_info.bps <= 16)
475  lpc_analyze_remodulate(decoded, coeffs, pred_order, qlevel, s->blocksize, bps);
476  }
477 
478  return 0;
479 }
480 
482  int32_t *residual, int pred_order)
483 {
484  int i, ret;
485  int coeff_prec, qlevel;
486  int coeffs[32];
487 
488  /* warm up samples */
489  for (i = 0; i < pred_order; i++) {
490  decoded[i] = get_sbits64(&s->gb, 33);
491  }
492 
493  coeff_prec = get_bits(&s->gb, 4) + 1;
494  if (coeff_prec == 16) {
495  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
496  return AVERROR_INVALIDDATA;
497  }
498  qlevel = get_sbits(&s->gb, 5);
499  if (qlevel < 0) {
500  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
501  qlevel);
502  return AVERROR_INVALIDDATA;
503  }
504 
505  for (i = 0; i < pred_order; i++) {
506  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
507  }
508 
509  if ((ret = decode_residuals(s, residual, pred_order)) < 0)
510  return ret;
511 
512  s->dsp.lpc33(decoded, residual, coeffs, pred_order, qlevel, s->blocksize);
513 
514  return 0;
515 }
516 
517 static inline int decode_subframe(FLACContext *s, int channel)
518 {
519  int32_t *decoded = s->decoded[channel];
520  int type, wasted = 0;
521  int bps = s->stream_info.bps;
522  int i, ret;
523 
524  if (channel == 0) {
525  if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
526  bps++;
527  } else {
528  if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
529  bps++;
530  }
531 
532  if (get_bits1(&s->gb)) {
533  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
534  return AVERROR_INVALIDDATA;
535  }
536  type = get_bits(&s->gb, 6);
537 
538  if (get_bits1(&s->gb)) {
539  int left = get_bits_left(&s->gb);
540  if ( left <= 0 ||
541  (left < bps && !show_bits_long(&s->gb, left)) ||
542  !show_bits_long(&s->gb, bps-1)) {
543  av_log(s->avctx, AV_LOG_ERROR,
544  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
545  bps, left);
546  return AVERROR_INVALIDDATA;
547  }
548  wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
549  bps -= wasted;
550  }
551 
552 //FIXME use av_log2 for types
553  if (type == 0) {
554  if (bps < 33) {
555  int32_t tmp = get_sbits_long(&s->gb, bps);
556  for (i = 0; i < s->blocksize; i++)
557  decoded[i] = tmp;
558  } else {
559  int64_t tmp = get_sbits64(&s->gb, 33);
560  for (i = 0; i < s->blocksize; i++)
561  s->decoded_33bps[i] = tmp;
562  }
563  } else if (type == 1) {
564  if (bps < 33) {
565  for (i = 0; i < s->blocksize; i++)
566  decoded[i] = get_sbits_long(&s->gb, bps);
567  } else {
568  for (i = 0; i < s->blocksize; i++)
569  s->decoded_33bps[i] = get_sbits64(&s->gb, 33);
570  }
571  } else if ((type >= 8) && (type <= 12)) {
572  int order = type & ~0x8;
573  if (bps < 33) {
574  if (bps + order <= 32) {
575  if ((ret = decode_subframe_fixed(s, decoded, order, bps)) < 0)
576  return ret;
577  } else {
578  if ((ret = decode_subframe_fixed_wide(s, decoded, order, bps)) < 0)
579  return ret;
580  }
581  } else {
582  if ((ret = decode_subframe_fixed_33bps(s, s->decoded_33bps, decoded, order)) < 0)
583  return ret;
584  }
585  } else if (type >= 32) {
586  if (bps < 33) {
587  if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
588  return ret;
589  } else {
590  if ((ret = decode_subframe_lpc_33bps(s, s->decoded_33bps, decoded, (type & ~0x20)+1)) < 0)
591  return ret;
592  }
593  } else {
594  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
595  return AVERROR_INVALIDDATA;
596  }
597 
598  if (wasted) {
599  if (wasted+bps == 33) {
600  s->dsp.wasted33(s->decoded_33bps, decoded, wasted, s->blocksize);
601  } else if (wasted < 32) {
602  s->dsp.wasted32(decoded, wasted, s->blocksize);
603  }
604  }
605 
606  return 0;
607 }
608 
610 {
611  int i, ret;
612  GetBitContext *gb = &s->gb;
613  FLACFrameInfo fi;
614 
615  if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
616  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
617  return ret;
618  }
619 
620  if ( s->stream_info.channels
621  && fi.channels != s->stream_info.channels
622  && s->got_streaminfo) {
623  s->stream_info.channels = fi.channels;
626  if (ret < 0)
627  return ret;
628  }
629  s->stream_info.channels = fi.channels;
631  s->ch_mode = fi.ch_mode;
632 
633  if (!s->stream_info.bps && !fi.bps) {
634  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
635  return AVERROR_INVALIDDATA;
636  }
637  if (!fi.bps) {
638  fi.bps = s->stream_info.bps;
639  } else if (s->stream_info.bps && fi.bps != s->stream_info.bps) {
640  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
641  "supported\n");
642  return AVERROR_INVALIDDATA;
643  }
644 
645  if (!s->stream_info.bps) {
646  s->stream_info.bps = s->avctx->bits_per_raw_sample = fi.bps;
647  flac_set_bps(s);
648  }
649 
650  if (!s->stream_info.max_blocksize)
651  s->stream_info.max_blocksize = FLAC_MAX_BLOCKSIZE;
652  if (fi.blocksize > s->stream_info.max_blocksize) {
653  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
654  s->stream_info.max_blocksize);
655  return AVERROR_INVALIDDATA;
656  }
657  s->blocksize = fi.blocksize;
658 
659  if (!s->stream_info.samplerate && !fi.samplerate) {
660  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
661  " or frame header\n");
662  return AVERROR_INVALIDDATA;
663  }
664  if (fi.samplerate == 0)
665  fi.samplerate = s->stream_info.samplerate;
666  s->stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;
667 
668  if (!s->got_streaminfo) {
670  if (ret < 0)
671  return ret;
672  s->got_streaminfo = 1;
673  dump_headers(s->avctx, &s->stream_info);
674  }
675  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
676  s->stream_info.channels);
677 
678 // dump_headers(s->avctx, &s->stream_info);
679 
680  /* subframes */
681  for (i = 0; i < s->stream_info.channels; i++) {
682  if ((ret = decode_subframe(s, i)) < 0)
683  return ret;
684  }
685 
686  align_get_bits(gb);
687 
688  /* frame footer */
689  skip_bits(gb, 16); /* data crc */
690 
691  return 0;
692 }
693 
694 static void decorrelate_33bps(int ch_mode, int32_t **decoded, int64_t *decoded_33bps, int len)
695 {
696  int i;
697  if (ch_mode == FLAC_CHMODE_LEFT_SIDE ) {
698  for (i = 0; i < len; i++)
699  decoded[1][i] = decoded[0][i] - (uint64_t)decoded_33bps[i];
700  } else if (ch_mode == FLAC_CHMODE_RIGHT_SIDE ) {
701  for (i = 0; i < len; i++)
702  decoded[0][i] = decoded[1][i] + (uint64_t)decoded_33bps[i];
703  } else if (ch_mode == FLAC_CHMODE_MID_SIDE ) {
704  for (i = 0; i < len; i++) {
705  uint64_t a = decoded[0][i];
706  int64_t b = decoded_33bps[i];
707  a -= b >> 1;
708  decoded[0][i] = (a + b);
709  decoded[1][i] = a;
710  }
711  }
712 }
713 
715  int *got_frame_ptr, AVPacket *avpkt)
716 {
717  const uint8_t *buf = avpkt->data;
718  int buf_size = avpkt->size;
719  FLACContext *s = avctx->priv_data;
720  int bytes_read = 0;
721  int ret;
722 
723  *got_frame_ptr = 0;
724 
725  if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
726  av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
727  return buf_size;
728  }
729 
730  if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
731  av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
732  return buf_size;
733  }
734 
735  /* check that there is at least the smallest decodable amount of data.
736  this amount corresponds to the smallest valid FLAC frame possible.
737  FF F8 69 02 00 00 9A 00 00 34 */
738  if (buf_size < FLAC_MIN_FRAME_SIZE)
739  return buf_size;
740 
741  /* check for inline header */
742  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
743  if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
744  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
745  return ret;
746  }
747  return get_metadata_size(buf, buf_size);
748  }
749 
750  /* decode frame */
751  if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
752  return ret;
753  if ((ret = decode_frame(s)) < 0) {
754  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
755  return ret;
756  }
757  bytes_read = get_bits_count(&s->gb)/8;
758 
759  if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
761  0, buf, bytes_read)) {
762  av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
763  if (s->avctx->err_recognition & AV_EF_EXPLODE)
764  return AVERROR_INVALIDDATA;
765  }
766 
767  /* get output buffer */
768  frame->nb_samples = s->blocksize;
769  if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
770  return ret;
771 
772  if (s->stream_info.bps == 32 && s->ch_mode > 0) {
773  decorrelate_33bps(s->ch_mode, s->decoded, s->decoded_33bps, s->blocksize);
774  s->dsp.decorrelate[0](frame->data, s->decoded, s->stream_info.channels,
775  s->blocksize, s->sample_shift);
776  } else {
777  s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded,
778  s->stream_info.channels,
779  s->blocksize, s->sample_shift);
780  }
781 
782  if (bytes_read > buf_size) {
783  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
784  return AVERROR_INVALIDDATA;
785  }
786  if (bytes_read < buf_size) {
787  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
788  buf_size - bytes_read, buf_size);
789  }
790 
791  *got_frame_ptr = 1;
792 
793  return bytes_read;
794 }
795 
797 {
798  FLACContext *s = avctx->priv_data;
799 
800  av_freep(&s->decoded_buffer);
801  av_freep(&s->decoded_buffer_33bps);
802 
803  return 0;
804 }
805 
806 static const AVOption options[] = {
807 { "use_buggy_lpc", "emulate old buggy lavc behavior", offsetof(FLACContext, buggy_lpc), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
808 { NULL },
809 };
810 
811 static const AVClass flac_decoder_class = {
812  .class_name = "FLAC decoder",
813  .item_name = av_default_item_name,
814  .option = options,
815  .version = LIBAVUTIL_VERSION_INT,
816 };
817 
819  .p.name = "flac",
820  CODEC_LONG_NAME("FLAC (Free Lossless Audio Codec)"),
821  .p.type = AVMEDIA_TYPE_AUDIO,
822  .p.id = AV_CODEC_ID_FLAC,
823  .priv_data_size = sizeof(FLACContext),
825  .close = flac_decode_close,
827  .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
830  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
835  .p.priv_class = &flac_decoder_class,
836 };
decode_residuals
static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
Definition: flacdec.c:241
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
flac_decode_close
static av_cold int flac_decode_close(AVCodecContext *avctx)
Definition: flacdec.c:796
FLACContext::decoded_buffer_size
unsigned int decoded_buffer_size
Definition: flacdec.c:65
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:495
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
FLACContext::decoded_buffer_size_33bps
unsigned int decoded_buffer_size_33bps
Definition: flacdec.c:68
allocate_buffers
static int allocate_buffers(FLACContext *s)
Definition: flacdec.c:137
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: defs.h:55
ff_flac_decoder
const FFCodec ff_flac_decoder
Definition: flacdec.c:818
int64_t
long long int64_t
Definition: coverity.c:34
av_samples_fill_arrays
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:153
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
FLACContext::ch_mode
int ch_mode
channel decorrelation type in the current frame
Definition: flacdec.c:60
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVOption
AVOption.
Definition: opt.h:429
b
#define b
Definition: input.c:41
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
FLACContext::dsp
FLACDSPContext dsp
Definition: flacdec.c:71
ff_flac_parse_streaminfo
int ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Parse the Streaminfo metadata block.
Definition: flac.c:187
FFCodec
Definition: codec_internal.h:127
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:458
flacdsp.h
thread.h
FLACContext::sample_shift
int sample_shift
shift required to make output samples 16-bit or 32-bit
Definition: flacdec.c:59
flac_decoder_class
static const AVClass flac_decoder_class
Definition: flacdec.c:811
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
flac_parse.h
golomb.h
exp golomb vlc stuff
FLAC_METADATA_TYPE_VORBIS_COMMENT
@ FLAC_METADATA_TYPE_VORBIS_COMMENT
Definition: flac.h:50
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
ff_flac_set_channel_layout
void ff_flac_set_channel_layout(AVCodecContext *avctx, int channels)
Definition: flac.c:173
ff_flac_decode_frame_header
int ff_flac_decode_frame_header(void *logctx, GetBitContext *gb, FLACFrameInfo *fi, int log_level_offset)
Validate and decode a frame header.
Definition: flac.c:51
GetBitContext
Definition: get_bits.h:108
SUINT32
#define SUINT32
Definition: dct32_template.c:31
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AV_SAMPLE_FMT_S64P
@ AV_SAMPLE_FMT_S64P
signed 64 bits, planar
Definition: samplefmt.h:69
decode_subframe_lpc
static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:437
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:357
DECODER_SUBFRAME_FIXED_WIDE
#define DECODER_SUBFRAME_FIXED_WIDE(residual)
Definition: flacdec.c:354
avassert.h
get_sbits64
static int64_t get_sbits64(GetBitContext *s, int n)
Read 0-64 bits as a signed integer.
Definition: get_bits.h:483
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
FLAC_CHMODE_RIGHT_SIDE
@ FLAC_CHMODE_RIGHT_SIDE
Definition: flac.h:41
FLACFrameInfo::channels
int channels
number of channels
Definition: flac_parse.h:44
FLACStreaminfo
Definition: flac_parse.h:33
decode_subframe_fixed_33bps
static int decode_subframe_fixed_33bps(FLACContext *s, int64_t *decoded, int32_t *residual, int pred_order)
Definition: flacdec.c:400
FLACContext::gb
GetBitContext gb
GetBitContext initialized to start at the current frame.
Definition: flacdec.c:56
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
s
#define s(width, name)
Definition: cbs_vp9.c:198
flac_set_bps
static void flac_set_bps(FLACContext *s)
Definition: flacdec.c:76
FLACFrameInfo::blocksize
int blocksize
block size of the frame
Definition: flac_parse.h:46
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1049
dump_headers
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
Definition: flacdec.c:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:114
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:320
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
get_bits.h
limits.h
flac_decode_frame
static int flac_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: flacdec.c:714
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
ff_flac_is_extradata_valid
int ff_flac_is_extradata_valid(AVCodecContext *avctx, uint8_t **streaminfo_start)
Validate the FLAC extradata.
Definition: flac.c:149
AV_CRC_16_ANSI
@ AV_CRC_16_ANSI
Definition: crc.h:50
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
FLAC_CHMODE_LEFT_SIDE
@ FLAC_CHMODE_LEFT_SIDE
Definition: flac.h:40
get_sr_golomb_flac
static int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (flac).
Definition: golomb.h:544
flac_parse_block_header
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:63
FLAC_METADATA_TYPE_STREAMINFO
@ FLAC_METADATA_TYPE_STREAMINFO
Definition: flac.h:46
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
options
Definition: swscale.c:42
FLACContext::decoded
int32_t * decoded[FLAC_MAX_CHANNELS]
decoded samples
Definition: flacdec.c:63
FLAC_STREAMINFO_SIZE
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:32
FLACFrameInfo
Definition: flac_parse.h:42
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: defs.h:48
decode_frame
static int decode_frame(FLACContext *s)
Definition: flacdec.c:609
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
decode_subframe_fixed_wide
static int decode_subframe_fixed_wide(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:389
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:540
get_metadata_size
static int get_metadata_size(const uint8_t *buf, int buf_size)
Determine the size of an inline header.
Definition: flacdec.c:220
codec_internal.h
ff_flacdsp_init
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int channels)
Definition: flacdsp.c:114
bps
unsigned bps
Definition: movenc.c:1880
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1063
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
FLACContext::buggy_lpc
int buggy_lpc
use workaround for old lavc encoded files
Definition: flacdec.c:69
decode_subframe_fixed
static int decode_subframe_fixed(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:302
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
decode_subframe
static int decode_subframe(FLACContext *s, int channel)
Definition: flacdec.c:517
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
unary.h
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
FLACContext
Definition: flacdec.c:51
FLACContext::got_streaminfo
int got_streaminfo
indicates if the STREAMINFO has been read
Definition: flacdec.c:61
parse_streaminfo
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
Parse the STREAMINFO from an inline header.
Definition: flacdec.c:187
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:529
decorrelate_33bps
static void decorrelate_33bps(int ch_mode, int32_t **decoded, int64_t *decoded_33bps, int len)
Definition: flacdec.c:694
FLACFrameInfo::ch_mode
int ch_mode
channel decorrelation mode
Definition: flac_parse.h:47
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
options
static const AVOption options[]
Definition: flacdec.c:806
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
av_samples_get_buffer_size
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:121
FLACFrameInfo::samplerate
int samplerate
sample rate
Definition: flac_parse.h:43
avcodec.h
lpc_analyze_remodulate
static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32], int order, int qlevel, int len, int bps)
Definition: flacdec.c:410
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
FLACContext::avctx
AVCodecContext * avctx
parent AVCodecContext
Definition: flacdec.c:55
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:80
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
FLACContext::decoded_buffer_33bps
uint8_t * decoded_buffer_33bps
Definition: flacdec.c:67
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:561
FLAC_MIN_FRAME_SIZE
#define FLAC_MIN_FRAME_SIZE
Definition: flac.h:36
FLACContext::decoded_buffer
uint8_t * decoded_buffer
Definition: flacdec.c:64
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
U
#define U(x)
Definition: vpx_arith.h:37
FLAC_MAX_CHANNELS
#define FLAC_MAX_CHANNELS
Definition: flac.h:33
AVCodecContext
main external API structure.
Definition: avcodec.h:451
FLACContext::decoded_33bps
int64_t * decoded_33bps
decoded samples for a 33 bps subframe
Definition: flacdec.c:66
av_crc
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:392
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
flac_decode_init
static av_cold int flac_decode_init(AVCodecContext *avctx)
Definition: flacdec.c:98
decode_subframe_lpc_33bps
static int decode_subframe_lpc_33bps(FLACContext *s, int64_t *decoded, int32_t *residual, int pred_order)
Definition: flacdec.c:481
FLAC_MAX_BLOCKSIZE
#define FLAC_MAX_BLOCKSIZE
Definition: flac.h:35
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:356
mem.h
FLACContext::blocksize
int blocksize
number of samples in the current frame
Definition: flacdec.c:58
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_fast_malloc
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:557
int32_t
int32_t
Definition: audioconvert.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
FLACFrameInfo::bps
int bps
bits-per-sample
Definition: flac_parse.h:45
flac.h
get_sbits_long
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:471
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:59
FLACDSPContext
Definition: flacdsp.h:26
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
FLAC_CHMODE_MID_SIDE
@ FLAC_CHMODE_MID_SIDE
Definition: flac.h:42
channel
channel
Definition: ebur128.h:39
FLACContext::stream_info
FLACStreaminfo stream_info
Definition: flacdec.c:53