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