Fix skiping typos
[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/channel_layout.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 {
52     FLACSTREAMINFO
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
63     uint8_t *decoded_buffer;
64     unsigned int decoded_buffer_size;
65
66     FLACDSPContext dsp;
67 } FLACContext;
68
69 static int allocate_buffers(FLACContext *s);
70
71 static void flac_set_bps(FLACContext *s)
72 {
73     enum AVSampleFormat req = s->avctx->request_sample_fmt;
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)
80             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
81         else
82             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
83         s->sample_shift = 32 - s->bps;
84     } else {
85         if (planar)
86             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
87         else
88             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
89         s->sample_shift = 16 - s->bps;
90     }
91 }
92
93 static av_cold int flac_decode_init(AVCodecContext *avctx)
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
121 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
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
130 static int allocate_buffers(FLACContext *s)
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
141     av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
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     }
170     avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
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
258 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
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) {
353         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
354             bps++;
355     } else {
356         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
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)) {
371             av_log(s->avctx, AV_LOG_ERROR,
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
412 static int decode_frame(FLACContext *s)
413 {
414     int i, ret;
415     GetBitContext *gb = &s->gb;
416     FLACFrameInfo fi;
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;
425         ff_flac_set_channel_layout(s->avctx);
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)
432         ff_flac_set_channel_layout(s->avctx);
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;
476         dump_headers(s->avctx, (FLACStreaminfo *)s);
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, "skipping 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, "skipping 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
548     if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
549         av_crc(av_crc_get_table(AV_CRC_16_ANSI),
550                0, buf, bytes_read)) {
551         av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
552         if (s->avctx->err_recognition & AV_EF_EXPLODE)
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
578 static int init_thread_copy(AVCodecContext *avctx)
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
589 static av_cold int flac_decode_close(AVCodecContext *avctx)
590 {
591     FLACContext *s = avctx->priv_data;
592
593     av_freep(&s->decoded_buffer);
594
595     return 0;
596 }
597
598 AVCodec ff_flac_decoder = {
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),
604     .init           = flac_decode_init,
605     .close          = flac_decode_close,
606     .decode         = flac_decode_frame,
607     .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
608     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
609     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
610                                                       AV_SAMPLE_FMT_S16P,
611                                                       AV_SAMPLE_FMT_S32,
612                                                       AV_SAMPLE_FMT_S32P,
613                                                       AV_SAMPLE_FMT_NONE },
614 };