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