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