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