FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
flacdec.c
Go to the documentation of this file.
1 /*
2  * FLAC (Free Lossless Audio Codec) decoder
3  * Copyright (c) 2003 Alex Beregszaszi
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * FLAC (Free Lossless Audio Codec) decoder
25  * @author Alex Beregszaszi
26  * @see http://flac.sourceforge.net/
27  *
28  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
29  * through, starting from the initial 'fLaC' signature; or by passing the
30  * 34-byte streaminfo structure through avctx->extradata[_size] followed
31  * by data starting with the 0xFFF8 marker.
32  */
33 
34 #include <limits.h>
35 
36 #include "libavutil/avassert.h"
38 #include "libavutil/crc.h"
39 #include "avcodec.h"
40 #include "internal.h"
41 #include "get_bits.h"
42 #include "bytestream.h"
43 #include "golomb.h"
44 #include "flac.h"
45 #include "flacdata.h"
46 #include "flacdsp.h"
47 #include "thread.h"
48 
49 typedef struct FLACContext {
51 
52  AVCodecContext *avctx; ///< parent AVCodecContext
53  GetBitContext gb; ///< GetBitContext initialized to start at the current frame
54 
55  int blocksize; ///< number of samples in the current frame
56  int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
57  int ch_mode; ///< channel decorrelation type in the current frame
58  int got_streaminfo; ///< indicates if the STREAMINFO has been read
59 
60  int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
62  unsigned int decoded_buffer_size;
63 
65 } FLACContext;
66 
67 static int allocate_buffers(FLACContext *s);
68 
69 static void flac_set_bps(FLACContext *s)
70 {
72  int need32 = s->bps > 16;
73  int want32 = av_get_bytes_per_sample(req) > 2;
74  int planar = av_sample_fmt_is_planar(req);
75 
76  if (need32 || want32) {
77  if (planar)
79  else
81  s->sample_shift = 32 - s->bps;
82  } else {
83  if (planar)
85  else
87  s->sample_shift = 16 - s->bps;
88  }
89 }
90 
92 {
93  enum FLACExtradataFormat format;
94  uint8_t *streaminfo;
95  int ret;
96  FLACContext *s = avctx->priv_data;
97  s->avctx = avctx;
98 
99  /* for now, the raw FLAC header is allowed to be passed to the decoder as
100  frame data instead of extradata. */
101  if (!avctx->extradata)
102  return 0;
103 
104  if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
105  return AVERROR_INVALIDDATA;
106 
107  /* initialize based on the demuxer-supplied streamdata header */
108  avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
109  ret = allocate_buffers(s);
110  if (ret < 0)
111  return ret;
112  flac_set_bps(s);
113  ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
114  s->got_streaminfo = 1;
115 
116  return 0;
117 }
118 
120 {
121  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
122  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
123  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
124  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
125  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
126 }
127 
129 {
130  int buf_size;
131 
132  av_assert0(s->max_blocksize);
133 
134  buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
135  AV_SAMPLE_FMT_S32P, 0);
136  if (buf_size < 0)
137  return buf_size;
138 
140  if (!s->decoded_buffer)
141  return AVERROR(ENOMEM);
142 
143  return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
144  s->decoded_buffer, s->channels,
145  s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
146 }
147 
148 /**
149  * Parse the STREAMINFO from an inline header.
150  * @param s the flac decoding context
151  * @param buf input buffer, starting with the "fLaC" marker
152  * @param buf_size buffer size
153  * @return non-zero if metadata is invalid
154  */
155 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
156 {
157  int metadata_type, metadata_size, ret;
158 
159  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
160  /* need more data */
161  return 0;
162  }
163  avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
164  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
165  metadata_size != FLAC_STREAMINFO_SIZE) {
166  return AVERROR_INVALIDDATA;
167  }
169  ret = allocate_buffers(s);
170  if (ret < 0)
171  return ret;
172  flac_set_bps(s);
173  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
174  s->got_streaminfo = 1;
175 
176  return 0;
177 }
178 
179 /**
180  * Determine the size of an inline header.
181  * @param buf input buffer, starting with the "fLaC" marker
182  * @param buf_size buffer size
183  * @return number of bytes in the header, or 0 if more data is needed
184  */
185 static int get_metadata_size(const uint8_t *buf, int buf_size)
186 {
187  int metadata_last, metadata_size;
188  const uint8_t *buf_end = buf + buf_size;
189 
190  buf += 4;
191  do {
192  if (buf_end - buf < 4)
193  return 0;
194  avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
195  buf += 4;
196  if (buf_end - buf < metadata_size) {
197  /* need more data in order to read the complete header */
198  return 0;
199  }
200  buf += metadata_size;
201  } while (!metadata_last);
202 
203  return buf_size - (buf_end - buf);
204 }
205 
206 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
207 {
208  int i, tmp, partition, method_type, rice_order;
209  int rice_bits, rice_esc;
210  int samples;
211 
212  method_type = get_bits(&s->gb, 2);
213  if (method_type > 1) {
214  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
215  method_type);
216  return AVERROR_INVALIDDATA;
217  }
218 
219  rice_order = get_bits(&s->gb, 4);
220 
221  samples= s->blocksize >> rice_order;
222  if (pred_order > samples) {
223  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
224  pred_order, samples);
225  return AVERROR_INVALIDDATA;
226  }
227 
228  rice_bits = 4 + method_type;
229  rice_esc = (1 << rice_bits) - 1;
230 
231  decoded += pred_order;
232  i= pred_order;
233  for (partition = 0; partition < (1 << rice_order); partition++) {
234  tmp = get_bits(&s->gb, rice_bits);
235  if (tmp == rice_esc) {
236  tmp = get_bits(&s->gb, 5);
237  for (; i < samples; i++)
238  *decoded++ = get_sbits_long(&s->gb, tmp);
239  } else {
240  for (; i < samples; i++) {
241  *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
242  }
243  }
244  i= 0;
245  }
246 
247  return 0;
248 }
249 
251  int pred_order, int bps)
252 {
253  const int blocksize = s->blocksize;
254  int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
255  int ret;
256 
257  /* warm up samples */
258  for (i = 0; i < pred_order; i++) {
259  decoded[i] = get_sbits_long(&s->gb, bps);
260  }
261 
262  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
263  return ret;
264 
265  if (pred_order > 0)
266  a = decoded[pred_order-1];
267  if (pred_order > 1)
268  b = a - decoded[pred_order-2];
269  if (pred_order > 2)
270  c = b - decoded[pred_order-2] + decoded[pred_order-3];
271  if (pred_order > 3)
272  d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
273 
274  switch (pred_order) {
275  case 0:
276  break;
277  case 1:
278  for (i = pred_order; i < blocksize; i++)
279  decoded[i] = a += decoded[i];
280  break;
281  case 2:
282  for (i = pred_order; i < blocksize; i++)
283  decoded[i] = a += b += decoded[i];
284  break;
285  case 3:
286  for (i = pred_order; i < blocksize; i++)
287  decoded[i] = a += b += c += decoded[i];
288  break;
289  case 4:
290  for (i = pred_order; i < blocksize; i++)
291  decoded[i] = a += b += c += d += decoded[i];
292  break;
293  default:
294  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
295  return AVERROR_INVALIDDATA;
296  }
297 
298  return 0;
299 }
300 
301 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
302  int bps)
303 {
304  int i, ret;
305  int coeff_prec, qlevel;
306  int coeffs[32];
307 
308  /* warm up samples */
309  for (i = 0; i < pred_order; i++) {
310  decoded[i] = get_sbits_long(&s->gb, bps);
311  }
312 
313  coeff_prec = get_bits(&s->gb, 4) + 1;
314  if (coeff_prec == 16) {
315  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
316  return AVERROR_INVALIDDATA;
317  }
318  qlevel = get_sbits(&s->gb, 5);
319  if (qlevel < 0) {
320  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
321  qlevel);
322  return AVERROR_INVALIDDATA;
323  }
324 
325  for (i = 0; i < pred_order; i++) {
326  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
327  }
328 
329  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
330  return ret;
331 
332  s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
333 
334  return 0;
335 }
336 
337 static inline int decode_subframe(FLACContext *s, int channel)
338 {
339  int32_t *decoded = s->decoded[channel];
340  int type, wasted = 0;
341  int bps = s->bps;
342  int i, tmp, ret;
343 
344  if (channel == 0) {
346  bps++;
347  } else {
349  bps++;
350  }
351 
352  if (get_bits1(&s->gb)) {
353  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
354  return AVERROR_INVALIDDATA;
355  }
356  type = get_bits(&s->gb, 6);
357 
358  if (get_bits1(&s->gb)) {
359  int left = get_bits_left(&s->gb);
360  wasted = 1;
361  if ( left < 0 ||
362  (left < bps && !show_bits_long(&s->gb, left)) ||
363  !show_bits_long(&s->gb, bps)) {
365  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
366  bps, left);
367  return AVERROR_INVALIDDATA;
368  }
369  while (!get_bits1(&s->gb))
370  wasted++;
371  bps -= wasted;
372  }
373  if (bps > 32) {
374  avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
375  return AVERROR_PATCHWELCOME;
376  }
377 
378 //FIXME use av_log2 for types
379  if (type == 0) {
380  tmp = get_sbits_long(&s->gb, bps);
381  for (i = 0; i < s->blocksize; i++)
382  decoded[i] = tmp;
383  } else if (type == 1) {
384  for (i = 0; i < s->blocksize; i++)
385  decoded[i] = get_sbits_long(&s->gb, bps);
386  } else if ((type >= 8) && (type <= 12)) {
387  if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
388  return ret;
389  } else if (type >= 32) {
390  if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
391  return ret;
392  } else {
393  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
394  return AVERROR_INVALIDDATA;
395  }
396 
397  if (wasted) {
398  int i;
399  for (i = 0; i < s->blocksize; i++)
400  decoded[i] <<= wasted;
401  }
402 
403  return 0;
404 }
405 
407 {
408  int i, ret;
409  GetBitContext *gb = &s->gb;
411 
412  if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
413  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
414  return AVERROR_INVALIDDATA;
415  }
416 
417  if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
418  s->channels = s->avctx->channels = fi.channels;
420  ret = allocate_buffers(s);
421  if (ret < 0)
422  return ret;
423  }
424  s->channels = s->avctx->channels = fi.channels;
425  if (!s->avctx->channel_layout)
427  s->ch_mode = fi.ch_mode;
428 
429  if (!s->bps && !fi.bps) {
430  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
431  return AVERROR_INVALIDDATA;
432  }
433  if (!fi.bps) {
434  fi.bps = s->bps;
435  } else if (s->bps && fi.bps != s->bps) {
436  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
437  "supported\n");
438  return -1;
439  }
440 
441  if (!s->bps) {
442  s->bps = s->avctx->bits_per_raw_sample = fi.bps;
443  flac_set_bps(s);
444  }
445 
446  if (!s->max_blocksize)
447  s->max_blocksize = FLAC_MAX_BLOCKSIZE;
448  if (fi.blocksize > s->max_blocksize) {
449  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
450  s->max_blocksize);
451  return AVERROR_INVALIDDATA;
452  }
453  s->blocksize = fi.blocksize;
454 
455  if (!s->samplerate && !fi.samplerate) {
456  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
457  " or frame header\n");
458  return AVERROR_INVALIDDATA;
459  }
460  if (fi.samplerate == 0)
461  fi.samplerate = s->samplerate;
462  s->samplerate = s->avctx->sample_rate = fi.samplerate;
463 
464  if (!s->got_streaminfo) {
465  ret = allocate_buffers(s);
466  if (ret < 0)
467  return ret;
468  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
469  s->got_streaminfo = 1;
471  }
472 
473 // dump_headers(s->avctx, (FLACStreaminfo *)s);
474 
475  /* subframes */
476  for (i = 0; i < s->channels; i++) {
477  if ((ret = decode_subframe(s, i)) < 0)
478  return ret;
479  }
480 
481  align_get_bits(gb);
482 
483  /* frame footer */
484  skip_bits(gb, 16); /* data crc */
485 
486  return 0;
487 }
488 
489 static int flac_decode_frame(AVCodecContext *avctx, void *data,
490  int *got_frame_ptr, AVPacket *avpkt)
491 {
492  AVFrame *frame = data;
493  ThreadFrame tframe = { .f = data };
494  const uint8_t *buf = avpkt->data;
495  int buf_size = avpkt->size;
496  FLACContext *s = avctx->priv_data;
497  int bytes_read = 0;
498  int ret;
499 
500  *got_frame_ptr = 0;
501 
502  if (s->max_framesize == 0) {
503  s->max_framesize =
504  ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
505  FLAC_MAX_CHANNELS, 32);
506  }
507 
508  if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
509  av_log(s->avctx, AV_LOG_DEBUG, "skiping flac header packet 1\n");
510  return buf_size;
511  }
512 
513  if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
514  av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");
515  return buf_size;
516  }
517 
518  /* check that there is at least the smallest decodable amount of data.
519  this amount corresponds to the smallest valid FLAC frame possible.
520  FF F8 69 02 00 00 9A 00 00 34 46 */
521  if (buf_size < FLAC_MIN_FRAME_SIZE)
522  return buf_size;
523 
524  /* check for inline header */
525  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
526  if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
527  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
528  return AVERROR_INVALIDDATA;
529  }
530  return get_metadata_size(buf, buf_size);
531  }
532 
533  /* decode frame */
534  if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
535  return ret;
536  if ((ret = decode_frame(s)) < 0) {
537  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
538  return ret;
539  }
540  bytes_read = get_bits_count(&s->gb)/8;
541 
542  if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
544  0, buf, bytes_read)) {
545  av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
547  return AVERROR_INVALIDDATA;
548  }
549 
550  /* get output buffer */
551  frame->nb_samples = s->blocksize;
552  if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
553  return ret;
554 
555  s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
556  s->blocksize, s->sample_shift);
557 
558  if (bytes_read > buf_size) {
559  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
560  return AVERROR_INVALIDDATA;
561  }
562  if (bytes_read < buf_size) {
563  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
564  buf_size - bytes_read, buf_size);
565  }
566 
567  *got_frame_ptr = 1;
568 
569  return bytes_read;
570 }
571 
573 {
574  FLACContext *s = avctx->priv_data;
575  s->decoded_buffer = NULL;
576  s->decoded_buffer_size = 0;
577  s->avctx = avctx;
578  if (s->max_blocksize)
579  return allocate_buffers(s);
580  return 0;
581 }
582 
584 {
585  FLACContext *s = avctx->priv_data;
586 
588 
589  return 0;
590 }
591 
593  .name = "flac",
594  .type = AVMEDIA_TYPE_AUDIO,
595  .id = AV_CODEC_ID_FLAC,
596  .priv_data_size = sizeof(FLACContext),
601  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
602  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
603  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
608 };