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 -1;
 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 -1;
 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 -1;
 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
 255     /* warm up samples */
 256     for (i = 0; i < pred_order; i++) {
 257         decoded[i] = get_sbits_long(&s->gb, bps);
 258     }
 259
 260     if (decode_residuals(s, decoded, pred_order) < 0)
 261         return -1;
 262
 263     if (pred_order > 0)
 264         a = decoded[pred_order-1];
 265     if (pred_order > 1)
 266         b = a - decoded[pred_order-2];
 267     if (pred_order > 2)
 268         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 269     if (pred_order > 3)
 270         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 271
 272     switch (pred_order) {
 273     case 0:
 274         break;
 275     case 1:
 276         for (i = pred_order; i < blocksize; i++)
 277             decoded[i] = a += decoded[i];
 278         break;
 279     case 2:
 280         for (i = pred_order; i < blocksize; i++)
 281             decoded[i] = a += b += decoded[i];
 282         break;
 283     case 3:
 284         for (i = pred_order; i < blocksize; i++)
 285             decoded[i] = a += b += c += decoded[i];
 286         break;
 287     case 4:
 288         for (i = pred_order; i < blocksize; i++)
 289             decoded[i] = a += b += c += d += decoded[i];
 290         break;
 291     default:
 292         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 293         return -1;
 294     }
 295
 296     return 0;
 297 }
 298
 299 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
 300                                int bps)
 301 {
 302     int i;
 303     int coeff_prec, qlevel;
 304     int coeffs[32];
 305
 306     /* warm up samples */
 307     for (i = 0; i < pred_order; i++) {
 308         decoded[i] = get_sbits_long(&s->gb, bps);
 309     }
 310
 311     coeff_prec = get_bits(&s->gb, 4) + 1;
 312     if (coeff_prec == 16) {
 313         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
 314         return -1;
 315     }
 316     qlevel = get_sbits(&s->gb, 5);
 317     if (qlevel < 0) {
 318         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 319                qlevel);
 320         return -1;
 321     }
 322
 323     for (i = 0; i < pred_order; i++) {
 324         coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
 325     }
 326
 327     if (decode_residuals(s, decoded, pred_order) < 0)
 328         return -1;
 329
 330     s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
 331
 332     return 0;
 333 }
 334
 335 static inline int decode_subframe(FLACContext *s, int channel)
 336 {
 337     int32_t *decoded = s->decoded[channel];
 338     int type, wasted = 0;
 339     int bps = s->bps;
 340     int i, tmp;
 341
 342     if (channel == 0) {
 343         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
 344             bps++;
 345     } else {
 346         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
 347             bps++;
 348     }
 349
 350     if (get_bits1(&s->gb)) {
 351         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
 352         return -1;
 353     }
 354     type = get_bits(&s->gb, 6);
 355
 356     if (get_bits1(&s->gb)) {
 357         int left = get_bits_left(&s->gb);
 358         wasted = 1;
 359         if ( left < 0 ||
 360             (left < bps && !show_bits_long(&s->gb, left)) ||
 361                            !show_bits_long(&s->gb, bps)) {
 362             av_log(s->avctx, AV_LOG_ERROR,
 363                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
 364                    bps, left);
 365             return AVERROR_INVALIDDATA;
 366         }
 367         while (!get_bits1(&s->gb))
 368             wasted++;
 369         bps -= wasted;
 370     }
 371     if (bps > 32) {
 372         av_log_missing_feature(s->avctx, "Decorrelated bit depth > 32", 0);
 373         return AVERROR_PATCHWELCOME;
 374     }
 375
 376 //FIXME use av_log2 for types
 377     if (type == 0) {
 378         tmp = get_sbits_long(&s->gb, bps);
 379         for (i = 0; i < s->blocksize; i++)
 380             decoded[i] = tmp;
 381     } else if (type == 1) {
 382         for (i = 0; i < s->blocksize; i++)
 383             decoded[i] = get_sbits_long(&s->gb, bps);
 384     } else if ((type >= 8) && (type <= 12)) {
 385         if (decode_subframe_fixed(s, decoded, type & ~0x8, bps) < 0)
 386             return -1;
 387     } else if (type >= 32) {
 388         if (decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps) < 0)
 389             return -1;
 390     } else {
 391         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 392         return -1;
 393     }
 394
 395     if (wasted) {
 396         int i;
 397         for (i = 0; i < s->blocksize; i++)
 398             decoded[i] <<= wasted;
 399     }
 400
 401     return 0;
 402 }
 403
 404 static int decode_frame(FLACContext *s)
 405 {
 406     int i, ret;
 407     GetBitContext *gb = &s->gb;
 408     FLACFrameInfo fi;
 409
 410     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
 411         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
 412         return -1;
 413     }
 414
 415     if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
 416         s->channels = s->avctx->channels = fi.channels;
 417         ff_flac_set_channel_layout(s->avctx);
 418         ret = allocate_buffers(s);
 419         if (ret < 0)
 420             return ret;
 421     }
 422     s->channels = s->avctx->channels = fi.channels;
 423     if (!s->avctx->channel_layout)
 424         ff_flac_set_channel_layout(s->avctx);
 425     s->ch_mode = fi.ch_mode;
 426
 427     if (!s->bps && !fi.bps) {
 428         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 429         return -1;
 430     }
 431     if (!fi.bps) {
 432         fi.bps = s->bps;
 433     } else if (s->bps && fi.bps != s->bps) {
 434         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 435                                        "supported\n");
 436         return -1;
 437     }
 438
 439     if (!s->bps) {
 440         s->bps = s->avctx->bits_per_raw_sample = fi.bps;
 441         flac_set_bps(s);
 442     }
 443
 444     if (!s->max_blocksize)
 445         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
 446     if (fi.blocksize > s->max_blocksize) {
 447         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
 448                s->max_blocksize);
 449         return -1;
 450     }
 451     s->blocksize = fi.blocksize;
 452
 453     if (!s->samplerate && !fi.samplerate) {
 454         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
 455                                         " or frame header\n");
 456         return -1;
 457     }
 458     if (fi.samplerate == 0)
 459         fi.samplerate = s->samplerate;
 460     s->samplerate = s->avctx->sample_rate = fi.samplerate;
 461
 462     if (!s->got_streaminfo) {
 463         ret = allocate_buffers(s);
 464         if (ret < 0)
 465             return ret;
 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     AVFrame *frame     = data;
 491     const uint8_t *buf = avpkt->data;
 492     int buf_size = avpkt->size;
 493     FLACContext *s = avctx->priv_data;
 494     int bytes_read = 0;
 495     int ret;
 496
 497     *got_frame_ptr = 0;
 498
 499     if (s->max_framesize == 0) {
 500         s->max_framesize =
 501             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
 502                                        FLAC_MAX_CHANNELS, 32);
 503     }
 504
 505     if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
 506         av_log(s->avctx, AV_LOG_DEBUG, "skiping flac header packet 1\n");
 507         return buf_size;
 508     }
 509
 510     if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
 511         av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");
 512         return buf_size;
 513     }
 514
 515     /* check that there is at least the smallest decodable amount of data.
 516        this amount corresponds to the smallest valid FLAC frame possible.
 517        FF F8 69 02 00 00 9A 00 00 34 46 */
 518     if (buf_size < FLAC_MIN_FRAME_SIZE)
 519         return buf_size;
 520
 521     /* check for inline header */
 522     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
 523         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
 524             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
 525             return -1;
 526         }
 527         return get_metadata_size(buf, buf_size);
 528     }
 529
 530     /* decode frame */
 531     init_get_bits(&s->gb, buf, buf_size*8);
 532     if (decode_frame(s) < 0) {
 533         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 534         return -1;
 535     }
 536     bytes_read = (get_bits_count(&s->gb)+7)/8;
 537
 538     /* get output buffer */
 539     frame->nb_samples = s->blocksize;
 540     if ((ret = ff_get_buffer(avctx, frame)) < 0) {
 541         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 542         return ret;
 543     }
 544
 545     s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
 546                                    s->blocksize, s->sample_shift);
 547
 548     if (bytes_read > buf_size) {
 549         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 550         return -1;
 551     }
 552     if (bytes_read < buf_size) {
 553         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 554                buf_size - bytes_read, buf_size);
 555     }
 556
 557     *got_frame_ptr = 1;
 558
 559     return bytes_read;
 560 }
 561
 562 static av_cold int flac_decode_close(AVCodecContext *avctx)
 563 {
 564     FLACContext *s = avctx->priv_data;
 565
 566     av_freep(&s->decoded_buffer);
 567
 568     return 0;
 569 }
 570
 571 AVCodec ff_flac_decoder = {
 572     .name           = "flac",
 573     .type           = AVMEDIA_TYPE_AUDIO,
 574     .id             = AV_CODEC_ID_FLAC,
 575     .priv_data_size = sizeof(FLACContext),
 576     .init           = flac_decode_init,
 577     .close          = flac_decode_close,
 578     .decode         = flac_decode_frame,
 579     .capabilities   = CODEC_CAP_DR1,
 580     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 581     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
 582                                                       AV_SAMPLE_FMT_S16P,
 583                                                       AV_SAMPLE_FMT_S32,
 584                                                       AV_SAMPLE_FMT_S32P,
 585                                                       AV_SAMPLE_FMT_NONE },
 586 };