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