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