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