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 
36 #include "libavutil/crc.h"
37 #include "avcodec.h"
38 #include "internal.h"
39 #include "get_bits.h"
40 #include "bytestream.h"
41 #include "golomb.h"
42 #include "flac.h"
43 #include "flacdata.h"
44 
45 #undef NDEBUG
46 #include <assert.h>
47 
48 typedef struct FLACContext {
50 
54 
55  int blocksize;
56  int curr_bps;
58  int is32;
59  int ch_mode;
61 
63 } FLACContext;
64 
65 static void allocate_buffers(FLACContext *s);
66 
68  enum FLACExtradataFormat *format,
69  uint8_t **streaminfo_start)
70 {
71  if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
72  av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
73  return 0;
74  }
75  if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
76  /* extradata contains STREAMINFO only */
77  if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
78  av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
80  }
82  *streaminfo_start = avctx->extradata;
83  } else {
84  if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
85  av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
86  return 0;
87  }
89  *streaminfo_start = &avctx->extradata[8];
90  }
91  return 1;
92 }
93 
95 {
96  enum FLACExtradataFormat format;
97  uint8_t *streaminfo;
98  FLACContext *s = avctx->priv_data;
99  s->avctx = avctx;
100 
101  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
102 
103  /* for now, the raw FLAC header is allowed to be passed to the decoder as
104  frame data instead of extradata. */
105  if (!avctx->extradata)
106  return 0;
107 
108  if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
109  return -1;
110 
111  /* initialize based on the demuxer-supplied streamdata header */
112  avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
113  if (s->bps > 16)
114  avctx->sample_fmt = AV_SAMPLE_FMT_S32;
115  else
116  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
117  allocate_buffers(s);
118  s->got_streaminfo = 1;
119 
121  avctx->coded_frame = &s->frame;
122 
123  return 0;
124 }
125 
127 {
128  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
129  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
130  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
131  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
132  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
133 }
134 
136 {
137  int i;
138 
139  assert(s->max_blocksize);
140 
141  for (i = 0; i < s->channels; i++) {
142  s->decoded[i] = av_realloc(s->decoded[i],
143  sizeof(int32_t)*s->max_blocksize);
144  }
145 }
146 
148  const uint8_t *buffer)
149 {
150  GetBitContext gb;
151  init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
152 
153  skip_bits(&gb, 16); /* skip min blocksize */
154  s->max_blocksize = get_bits(&gb, 16);
155  if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
156  av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
157  s->max_blocksize);
158  s->max_blocksize = 16;
159  }
160 
161  skip_bits(&gb, 24); /* skip min frame size */
162  s->max_framesize = get_bits_long(&gb, 24);
163 
164  s->samplerate = get_bits_long(&gb, 20);
165  s->channels = get_bits(&gb, 3) + 1;
166  s->bps = get_bits(&gb, 5) + 1;
167 
168  avctx->channels = s->channels;
169  avctx->sample_rate = s->samplerate;
170  avctx->bits_per_raw_sample = s->bps;
171 
172  s->samples = get_bits_long(&gb, 32) << 4;
173  s->samples |= get_bits(&gb, 4);
174 
175  skip_bits_long(&gb, 64); /* md5 sum */
176  skip_bits_long(&gb, 64); /* md5 sum */
177 
178  dump_headers(avctx, s);
179 }
180 
181 void avpriv_flac_parse_block_header(const uint8_t *block_header,
182  int *last, int *type, int *size)
183 {
184  int tmp = bytestream_get_byte(&block_header);
185  if (last)
186  *last = tmp & 0x80;
187  if (type)
188  *type = tmp & 0x7F;
189  if (size)
190  *size = bytestream_get_be24(&block_header);
191 }
192 
200 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
201 {
202  int metadata_type, metadata_size;
203 
204  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
205  /* need more data */
206  return 0;
207  }
208  avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
209  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
210  metadata_size != FLAC_STREAMINFO_SIZE) {
211  return AVERROR_INVALIDDATA;
212  }
214  allocate_buffers(s);
215  s->got_streaminfo = 1;
216 
217  return 0;
218 }
219 
226 static int get_metadata_size(const uint8_t *buf, int buf_size)
227 {
228  int metadata_last, metadata_size;
229  const uint8_t *buf_end = buf + buf_size;
230 
231  buf += 4;
232  do {
233  if (buf_end - buf < 4)
234  return 0;
235  avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
236  buf += 4;
237  if (buf_end - buf < metadata_size) {
238  /* need more data in order to read the complete header */
239  return 0;
240  }
241  buf += metadata_size;
242  } while (!metadata_last);
243 
244  return buf_size - (buf_end - buf);
245 }
246 
247 static int decode_residuals(FLACContext *s, int channel, int pred_order)
248 {
249  int i, tmp, partition, method_type, rice_order;
250  int sample = 0, samples;
251 
252  method_type = get_bits(&s->gb, 2);
253  if (method_type > 1) {
254  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
255  method_type);
256  return -1;
257  }
258 
259  rice_order = get_bits(&s->gb, 4);
260 
261  samples= s->blocksize >> rice_order;
262  if (pred_order > samples) {
263  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
264  pred_order, samples);
265  return -1;
266  }
267 
268  sample=
269  i= pred_order;
270  for (partition = 0; partition < (1 << rice_order); partition++) {
271  tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
272  if (tmp == (method_type == 0 ? 15 : 31)) {
273  tmp = get_bits(&s->gb, 5);
274  for (; i < samples; i++, sample++)
275  s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
276  } else {
277  for (; i < samples; i++, sample++) {
278  s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
279  }
280  }
281  i= 0;
282  }
283 
284  return 0;
285 }
286 
287 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
288 {
289  const int blocksize = s->blocksize;
290  int32_t *decoded = s->decoded[channel];
291  int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
292 
293  /* warm up samples */
294  for (i = 0; i < pred_order; i++) {
295  decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
296  }
297 
298  if (decode_residuals(s, channel, pred_order) < 0)
299  return -1;
300 
301  if (pred_order > 0)
302  a = decoded[pred_order-1];
303  if (pred_order > 1)
304  b = a - decoded[pred_order-2];
305  if (pred_order > 2)
306  c = b - decoded[pred_order-2] + decoded[pred_order-3];
307  if (pred_order > 3)
308  d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
309 
310  switch (pred_order) {
311  case 0:
312  break;
313  case 1:
314  for (i = pred_order; i < blocksize; i++)
315  decoded[i] = a += decoded[i];
316  break;
317  case 2:
318  for (i = pred_order; i < blocksize; i++)
319  decoded[i] = a += b += decoded[i];
320  break;
321  case 3:
322  for (i = pred_order; i < blocksize; i++)
323  decoded[i] = a += b += c += decoded[i];
324  break;
325  case 4:
326  for (i = pred_order; i < blocksize; i++)
327  decoded[i] = a += b += c += d += decoded[i];
328  break;
329  default:
330  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
331  return -1;
332  }
333 
334  return 0;
335 }
336 
337 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
338 {
339  int i, j;
340  int coeff_prec, qlevel;
341  int coeffs[32];
342  int32_t *decoded = s->decoded[channel];
343 
344  /* warm up samples */
345  for (i = 0; i < pred_order; i++) {
346  decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
347  }
348 
349  coeff_prec = get_bits(&s->gb, 4) + 1;
350  if (coeff_prec == 16) {
351  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
352  return -1;
353  }
354  qlevel = get_sbits(&s->gb, 5);
355  if (qlevel < 0) {
356  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
357  qlevel);
358  return -1;
359  }
360 
361  for (i = 0; i < pred_order; i++) {
362  coeffs[i] = get_sbits(&s->gb, coeff_prec);
363  }
364 
365  if (decode_residuals(s, channel, pred_order) < 0)
366  return -1;
367 
368  if (s->bps > 16) {
369  int64_t sum;
370  for (i = pred_order; i < s->blocksize; i++) {
371  sum = 0;
372  for (j = 0; j < pred_order; j++)
373  sum += (int64_t)coeffs[j] * decoded[i-j-1];
374  decoded[i] += sum >> qlevel;
375  }
376  } else {
377  for (i = pred_order; i < s->blocksize-1; i += 2) {
378  int c;
379  int d = decoded[i-pred_order];
380  int s0 = 0, s1 = 0;
381  for (j = pred_order-1; j > 0; j--) {
382  c = coeffs[j];
383  s0 += c*d;
384  d = decoded[i-j];
385  s1 += c*d;
386  }
387  c = coeffs[0];
388  s0 += c*d;
389  d = decoded[i] += s0 >> qlevel;
390  s1 += c*d;
391  decoded[i+1] += s1 >> qlevel;
392  }
393  if (i < s->blocksize) {
394  int sum = 0;
395  for (j = 0; j < pred_order; j++)
396  sum += coeffs[j] * decoded[i-j-1];
397  decoded[i] += sum >> qlevel;
398  }
399  }
400 
401  return 0;
402 }
403 
404 static inline int decode_subframe(FLACContext *s, int channel)
405 {
406  int type, wasted = 0;
407  int i, tmp;
408 
409  s->curr_bps = s->bps;
410  if (channel == 0) {
412  s->curr_bps++;
413  } else {
415  s->curr_bps++;
416  }
417 
418  if (get_bits1(&s->gb)) {
419  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
420  return -1;
421  }
422  type = get_bits(&s->gb, 6);
423 
424  if (get_bits1(&s->gb)) {
425  int left = get_bits_left(&s->gb);
426  wasted = 1;
427  if ( left < 0 ||
428  (left < s->curr_bps && !show_bits_long(&s->gb, left)) ||
429  !show_bits_long(&s->gb, s->curr_bps)) {
431  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
432  s->curr_bps, left);
433  return AVERROR_INVALIDDATA;
434  }
435  while (!get_bits1(&s->gb))
436  wasted++;
437  s->curr_bps -= wasted;
438  }
439  if (s->curr_bps > 32) {
440  av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
441  return -1;
442  }
443 
444 //FIXME use av_log2 for types
445  if (type == 0) {
446  tmp = get_sbits_long(&s->gb, s->curr_bps);
447  for (i = 0; i < s->blocksize; i++)
448  s->decoded[channel][i] = tmp;
449  } else if (type == 1) {
450  for (i = 0; i < s->blocksize; i++)
451  s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
452  } else if ((type >= 8) && (type <= 12)) {
453  if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
454  return -1;
455  } else if (type >= 32) {
456  if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
457  return -1;
458  } else {
459  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
460  return -1;
461  }
462 
463  if (wasted) {
464  int i;
465  for (i = 0; i < s->blocksize; i++)
466  s->decoded[channel][i] <<= wasted;
467  }
468 
469  return 0;
470 }
471 
472 static int decode_frame(FLACContext *s)
473 {
474  int i;
475  GetBitContext *gb = &s->gb;
476  FLACFrameInfo fi;
477 
478  if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
479  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
480  return -1;
481  }
482 
483  if (s->channels && fi.channels != s->channels) {
484  av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
485  "is not supported\n");
486  return -1;
487  }
488  s->channels = s->avctx->channels = fi.channels;
489  s->ch_mode = fi.ch_mode;
490 
491  if (!s->bps && !fi.bps) {
492  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
493  return -1;
494  }
495  if (!fi.bps) {
496  fi.bps = s->bps;
497  } else if (s->bps && fi.bps != s->bps) {
498  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
499  "supported\n");
500  return -1;
501  }
502  s->bps = s->avctx->bits_per_raw_sample = fi.bps;
503 
504  if (s->bps > 16) {
506  s->sample_shift = 32 - s->bps;
507  s->is32 = 1;
508  } else {
510  s->sample_shift = 16 - s->bps;
511  s->is32 = 0;
512  }
513 
514  if (!s->max_blocksize)
515  s->max_blocksize = FLAC_MAX_BLOCKSIZE;
516  if (fi.blocksize > s->max_blocksize) {
517  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
518  s->max_blocksize);
519  return -1;
520  }
521  s->blocksize = fi.blocksize;
522 
523  if (!s->samplerate && !fi.samplerate) {
524  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
525  " or frame header\n");
526  return -1;
527  }
528  if (fi.samplerate == 0) {
529  fi.samplerate = s->samplerate;
530  } else if (s->samplerate && fi.samplerate != s->samplerate) {
531  av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
532  s->samplerate, fi.samplerate);
533  }
534  s->samplerate = s->avctx->sample_rate = fi.samplerate;
535 
536  if (!s->got_streaminfo) {
537  allocate_buffers(s);
538  s->got_streaminfo = 1;
540  }
541 
542 // dump_headers(s->avctx, (FLACStreaminfo *)s);
543 
544  /* subframes */
545  for (i = 0; i < s->channels; i++) {
546  if (decode_subframe(s, i) < 0)
547  return -1;
548  }
549 
550  align_get_bits(gb);
551 
552  /* frame footer */
553  skip_bits(gb, 16); /* data crc */
554 
555  return 0;
556 }
557 
558 static int flac_decode_frame(AVCodecContext *avctx, void *data,
559  int *got_frame_ptr, AVPacket *avpkt)
560 {
561  const uint8_t *buf = avpkt->data;
562  int buf_size = avpkt->size;
563  FLACContext *s = avctx->priv_data;
564  int i, j = 0, bytes_read = 0;
565  int16_t *samples_16;
566  int32_t *samples_32;
567  int ret;
568 
569  *got_frame_ptr = 0;
570 
571  if (s->max_framesize == 0) {
572  s->max_framesize =
573  ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
574  FLAC_MAX_CHANNELS, 32);
575  }
576 
577  /* check that there is at least the smallest decodable amount of data.
578  this amount corresponds to the smallest valid FLAC frame possible.
579  FF F8 69 02 00 00 9A 00 00 34 46 */
580  if (buf_size < FLAC_MIN_FRAME_SIZE)
581  return buf_size;
582 
583  /* check for inline header */
584  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
585  if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
586  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
587  return -1;
588  }
589  return get_metadata_size(buf, buf_size);
590  }
591 
592  /* decode frame */
593  init_get_bits(&s->gb, buf, buf_size*8);
594  if (decode_frame(s) < 0) {
595  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
596  return -1;
597  }
598  bytes_read = (get_bits_count(&s->gb)+7)/8;
599 
600  /* get output buffer */
601  s->frame.nb_samples = s->blocksize;
602  if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
603  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
604  return ret;
605  }
606  samples_16 = (int16_t *)s->frame.data[0];
607  samples_32 = (int32_t *)s->frame.data[0];
608 
609 #define DECORRELATE(left, right)\
610  assert(s->channels == 2);\
611  for (i = 0; i < s->blocksize; i++) {\
612  int a= s->decoded[0][i];\
613  int b= s->decoded[1][i];\
614  if (s->is32) {\
615  *samples_32++ = (left) << s->sample_shift;\
616  *samples_32++ = (right) << s->sample_shift;\
617  } else {\
618  *samples_16++ = (left) << s->sample_shift;\
619  *samples_16++ = (right) << s->sample_shift;\
620  }\
621  }\
622  break;
623 
624  switch (s->ch_mode) {
626  for (j = 0; j < s->blocksize; j++) {
627  for (i = 0; i < s->channels; i++) {
628  if (s->is32)
629  *samples_32++ = s->decoded[i][j] << s->sample_shift;
630  else
631  *samples_16++ = s->decoded[i][j] << s->sample_shift;
632  }
633  }
634  break;
636  DECORRELATE(a,a-b)
638  DECORRELATE(a+b,b)
640  DECORRELATE( (a-=b>>1) + b, a)
641  }
642 
643  if (bytes_read > buf_size) {
644  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
645  return -1;
646  }
647  if (bytes_read < buf_size) {
648  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
649  buf_size - bytes_read, buf_size);
650  }
651 
652  *got_frame_ptr = 1;
653  *(AVFrame *)data = s->frame;
654 
655  return bytes_read;
656 }
657 
659 {
660  FLACContext *s = avctx->priv_data;
661  int i;
662 
663  for (i = 0; i < s->channels; i++) {
664  av_freep(&s->decoded[i]);
665  }
666 
667  return 0;
668 }
669 
671  .name = "flac",
672  .type = AVMEDIA_TYPE_AUDIO,
673  .id = CODEC_ID_FLAC,
674  .priv_data_size = sizeof(FLACContext),
678  .capabilities = CODEC_CAP_DR1,
679  .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
680 };