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