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 libavcodec/flacdec.c
  24  * FLAC (Free Lossless Audio Codec) decoder
  25  * @author Alex Beregszaszi
  26  *
  27  * For more information on the FLAC format, visit:
  28  *  http://flac.sourceforge.net/
  29  *
  30  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
  31  * through, starting from the initial 'fLaC' signature; or by passing the
  32  * 34-byte streaminfo structure through avctx->extradata[_size] followed
  33  * by data starting with the 0xFFF8 marker.
  34  */
  35
  36 #include <limits.h>
  37
  38 #include "libavutil/crc.h"
  39 #include "avcodec.h"
  40 #include "internal.h"
  41 #include "bitstream.h"
  42 #include "bytestream.h"
  43 #include "golomb.h"
  44 #include "flac.h"
  45 #include "flacdata.h"
  46
  47 #undef NDEBUG
  48 #include <assert.h>
  49
  50 typedef struct FLACContext {
  51     FLACSTREAMINFO
  52
  53     AVCodecContext *avctx;                  ///< parent AVCodecContext
  54     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
  55
  56     int blocksize;                          ///< number of samples in the current frame
  57     int curr_bps;                           ///< bps for current subframe, adjusted for channel correlation and wasted bits
  58     int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
  59     int is32;                               ///< flag to indicate if output should be 32-bit instead of 16-bit
  60     int ch_mode;                            ///< channel decorrelation type in the current frame
  61     int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
  62
  63     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
  64     uint8_t *bitstream;
  65     unsigned int bitstream_size;
  66     unsigned int bitstream_index;
  67     unsigned int allocated_bitstream_size;
  68 } FLACContext;
  69
  70 static const int sample_size_table[] =
  71 { 0, 8, 12, 0, 16, 20, 24, 0 };
  72
  73 static int64_t get_utf8(GetBitContext *gb)
  74 {
  75     int64_t val;
  76     GET_UTF8(val, get_bits(gb, 8), return -1;)
  77     return val;
  78 }
  79
  80 static void allocate_buffers(FLACContext *s);
  81
  82 int ff_flac_is_extradata_valid(AVCodecContext *avctx,
  83                                enum FLACExtradataFormat *format,
  84                                uint8_t **streaminfo_start)
  85 {
  86     if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
  87         av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
  88         return 0;
  89     }
  90     if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
  91         /* extradata contains STREAMINFO only */
  92         if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
  93             av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
  94                    FLAC_STREAMINFO_SIZE-avctx->extradata_size);
  95         }
  96         *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
  97         *streaminfo_start = avctx->extradata;
  98     } else {
  99         if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
 100             av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
 101             return 0;
 102         }
 103         *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
 104         *streaminfo_start = &avctx->extradata[8];
 105     }
 106     return 1;
 107 }
 108
 109 static av_cold int flac_decode_init(AVCodecContext *avctx)
 110 {
 111     enum FLACExtradataFormat format;
 112     uint8_t *streaminfo;
 113     FLACContext *s = avctx->priv_data;
 114     s->avctx = avctx;
 115
 116     avctx->sample_fmt = SAMPLE_FMT_S16;
 117
 118     /* for now, the raw FLAC header is allowed to be passed to the decoder as
 119        frame data instead of extradata. */
 120     if (!avctx->extradata)
 121         return 0;
 122
 123     if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
 124         return -1;
 125
 126     /* initialize based on the demuxer-supplied streamdata header */
 127     ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
 128     allocate_buffers(s);
 129     s->got_streaminfo = 1;
 130
 131     return 0;
 132 }
 133
 134 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
 135 {
 136     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
 137     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
 138     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
 139     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
 140     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
 141 }
 142
 143 static void allocate_buffers(FLACContext *s)
 144 {
 145     int i;
 146
 147     assert(s->max_blocksize);
 148
 149     if (s->max_framesize == 0 && s->max_blocksize) {
 150         s->max_framesize = ff_flac_get_max_frame_size(s->max_blocksize,
 151                                                       s->channels, s->bps);
 152     }
 153
 154     for (i = 0; i < s->channels; i++) {
 155         s->decoded[i] = av_realloc(s->decoded[i],
 156                                    sizeof(int32_t)*s->max_blocksize);
 157     }
 158
 159     if (s->allocated_bitstream_size < s->max_framesize)
 160         s->bitstream= av_fast_realloc(s->bitstream,
 161                                       &s->allocated_bitstream_size,
 162                                       s->max_framesize);
 163 }
 164
 165 void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
 166                               const uint8_t *buffer)
 167 {
 168     GetBitContext gb;
 169     init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
 170
 171     skip_bits(&gb, 16); /* skip min blocksize */
 172     s->max_blocksize = get_bits(&gb, 16);
 173     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
 174         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
 175                s->max_blocksize);
 176         s->max_blocksize = 16;
 177     }
 178
 179     skip_bits(&gb, 24); /* skip min frame size */
 180     s->max_framesize = get_bits_long(&gb, 24);
 181
 182     s->samplerate = get_bits_long(&gb, 20);
 183     s->channels = get_bits(&gb, 3) + 1;
 184     s->bps = get_bits(&gb, 5) + 1;
 185
 186     avctx->channels = s->channels;
 187     avctx->sample_rate = s->samplerate;
 188     avctx->bits_per_raw_sample = s->bps;
 189     if (s->bps > 16)
 190         avctx->sample_fmt = SAMPLE_FMT_S32;
 191     else
 192         avctx->sample_fmt = SAMPLE_FMT_S16;
 193
 194     s->samples  = get_bits_long(&gb, 32) << 4;
 195     s->samples |= get_bits(&gb, 4);
 196
 197     skip_bits_long(&gb, 64); /* md5 sum */
 198     skip_bits_long(&gb, 64); /* md5 sum */
 199
 200     dump_headers(avctx, s);
 201 }
 202
 203 void ff_flac_parse_block_header(const uint8_t *block_header,
 204                                 int *last, int *type, int *size)
 205 {
 206     int tmp = bytestream_get_byte(&block_header);
 207     if (last)
 208         *last = tmp & 0x80;
 209     if (type)
 210         *type = tmp & 0x7F;
 211     if (size)
 212         *size = bytestream_get_be24(&block_header);
 213 }
 214
 215 /**
 216  * Parse the STREAMINFO from an inline header.
 217  * @param s the flac decoding context
 218  * @param buf input buffer, starting with the "fLaC" marker
 219  * @param buf_size buffer size
 220  * @return non-zero if metadata is invalid
 221  */
 222 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
 223 {
 224     int metadata_type, metadata_size;
 225
 226     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
 227         /* need more data */
 228         return 0;
 229     }
 230     ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
 231     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
 232         metadata_size != FLAC_STREAMINFO_SIZE) {
 233         return AVERROR_INVALIDDATA;
 234     }
 235     ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
 236     allocate_buffers(s);
 237     s->got_streaminfo = 1;
 238
 239     return 0;
 240 }
 241
 242 /**
 243  * Determine the size of an inline header.
 244  * @param buf input buffer, starting with the "fLaC" marker
 245  * @param buf_size buffer size
 246  * @return number of bytes in the header, or 0 if more data is needed
 247  */
 248 static int get_metadata_size(const uint8_t *buf, int buf_size)
 249 {
 250     int metadata_last, metadata_size;
 251     const uint8_t *buf_end = buf + buf_size;
 252
 253     buf += 4;
 254     do {
 255         ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
 256         buf += 4;
 257         if (buf + metadata_size > buf_end) {
 258             /* need more data in order to read the complete header */
 259             return 0;
 260         }
 261         buf += metadata_size;
 262     } while (!metadata_last);
 263
 264     return buf_size - (buf_end - buf);
 265 }
 266
 267 static int decode_residuals(FLACContext *s, int channel, int pred_order)
 268 {
 269     int i, tmp, partition, method_type, rice_order;
 270     int sample = 0, samples;
 271
 272     method_type = get_bits(&s->gb, 2);
 273     if (method_type > 1) {
 274         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
 275                method_type);
 276         return -1;
 277     }
 278
 279     rice_order = get_bits(&s->gb, 4);
 280
 281     samples= s->blocksize >> rice_order;
 282     if (pred_order > samples) {
 283         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
 284                pred_order, samples);
 285         return -1;
 286     }
 287
 288     sample=
 289     i= pred_order;
 290     for (partition = 0; partition < (1 << rice_order); partition++) {
 291         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
 292         if (tmp == (method_type == 0 ? 15 : 31)) {
 293             tmp = get_bits(&s->gb, 5);
 294             for (; i < samples; i++, sample++)
 295                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
 296         } else {
 297             for (; i < samples; i++, sample++) {
 298                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 299             }
 300         }
 301         i= 0;
 302     }
 303
 304     return 0;
 305 }
 306
 307 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
 308 {
 309     const int blocksize = s->blocksize;
 310     int32_t *decoded = s->decoded[channel];
 311     int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
 312
 313     /* warm up samples */
 314     for (i = 0; i < pred_order; i++) {
 315         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
 316     }
 317
 318     if (decode_residuals(s, channel, pred_order) < 0)
 319         return -1;
 320
 321     if (pred_order > 0)
 322         a = decoded[pred_order-1];
 323     if (pred_order > 1)
 324         b = a - decoded[pred_order-2];
 325     if (pred_order > 2)
 326         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 327     if (pred_order > 3)
 328         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 329
 330     switch (pred_order) {
 331     case 0:
 332         break;
 333     case 1:
 334         for (i = pred_order; i < blocksize; i++)
 335             decoded[i] = a += decoded[i];
 336         break;
 337     case 2:
 338         for (i = pred_order; i < blocksize; i++)
 339             decoded[i] = a += b += decoded[i];
 340         break;
 341     case 3:
 342         for (i = pred_order; i < blocksize; i++)
 343             decoded[i] = a += b += c += decoded[i];
 344         break;
 345     case 4:
 346         for (i = pred_order; i < blocksize; i++)
 347             decoded[i] = a += b += c += d += decoded[i];
 348         break;
 349     default:
 350         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 351         return -1;
 352     }
 353
 354     return 0;
 355 }
 356
 357 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
 358 {
 359     int i, j;
 360     int coeff_prec, qlevel;
 361     int coeffs[pred_order];
 362     int32_t *decoded = s->decoded[channel];
 363
 364     /* warm up samples */
 365     for (i = 0; i < pred_order; i++) {
 366         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
 367     }
 368
 369     coeff_prec = get_bits(&s->gb, 4) + 1;
 370     if (coeff_prec == 16) {
 371         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
 372         return -1;
 373     }
 374     qlevel = get_sbits(&s->gb, 5);
 375     if (qlevel < 0) {
 376         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 377                qlevel);
 378         return -1;
 379     }
 380
 381     for (i = 0; i < pred_order; i++) {
 382         coeffs[i] = get_sbits(&s->gb, coeff_prec);
 383     }
 384
 385     if (decode_residuals(s, channel, pred_order) < 0)
 386         return -1;
 387
 388     if (s->bps > 16) {
 389         int64_t sum;
 390         for (i = pred_order; i < s->blocksize; i++) {
 391             sum = 0;
 392             for (j = 0; j < pred_order; j++)
 393                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
 394             decoded[i] += sum >> qlevel;
 395         }
 396     } else {
 397         for (i = pred_order; i < s->blocksize-1; i += 2) {
 398             int c;
 399             int d = decoded[i-pred_order];
 400             int s0 = 0, s1 = 0;
 401             for (j = pred_order-1; j > 0; j--) {
 402                 c = coeffs[j];
 403                 s0 += c*d;
 404                 d = decoded[i-j];
 405                 s1 += c*d;
 406             }
 407             c = coeffs[0];
 408             s0 += c*d;
 409             d = decoded[i] += s0 >> qlevel;
 410             s1 += c*d;
 411             decoded[i+1] += s1 >> qlevel;
 412         }
 413         if (i < s->blocksize) {
 414             int sum = 0;
 415             for (j = 0; j < pred_order; j++)
 416                 sum += coeffs[j] * decoded[i-j-1];
 417             decoded[i] += sum >> qlevel;
 418         }
 419     }
 420
 421     return 0;
 422 }
 423
 424 static inline int decode_subframe(FLACContext *s, int channel)
 425 {
 426     int type, wasted = 0;
 427     int i, tmp;
 428
 429     s->curr_bps = s->bps;
 430     if (channel == 0) {
 431         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
 432             s->curr_bps++;
 433     } else {
 434         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
 435             s->curr_bps++;
 436     }
 437
 438     if (get_bits1(&s->gb)) {
 439         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
 440         return -1;
 441     }
 442     type = get_bits(&s->gb, 6);
 443
 444     if (get_bits1(&s->gb)) {
 445         wasted = 1;
 446         while (!get_bits1(&s->gb))
 447             wasted++;
 448         s->curr_bps -= wasted;
 449     }
 450     if (s->curr_bps > 32) {
 451         ff_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
 452         return -1;
 453     }
 454
 455 //FIXME use av_log2 for types
 456     if (type == 0) {
 457         tmp = get_sbits_long(&s->gb, s->curr_bps);
 458         for (i = 0; i < s->blocksize; i++)
 459             s->decoded[channel][i] = tmp;
 460     } else if (type == 1) {
 461         for (i = 0; i < s->blocksize; i++)
 462             s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
 463     } else if ((type >= 8) && (type <= 12)) {
 464         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
 465             return -1;
 466     } else if (type >= 32) {
 467         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
 468             return -1;
 469     } else {
 470         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 471         return -1;
 472     }
 473
 474     if (wasted) {
 475         int i;
 476         for (i = 0; i < s->blocksize; i++)
 477             s->decoded[channel][i] <<= wasted;
 478     }
 479
 480     return 0;
 481 }
 482
 483 static int decode_frame(FLACContext *s)
 484 {
 485     int bs_code, sr_code, bps_code, i;
 486     int ch_mode, bps, blocksize, samplerate, channels;
 487     GetBitContext *gb = &s->gb;
 488
 489     /* frame sync code */
 490     skip_bits(&s->gb, 16);
 491
 492     /* block size and sample rate codes */
 493     bs_code = get_bits(gb, 4);
 494     sr_code = get_bits(gb, 4);
 495
 496     /* channels and decorrelation */
 497     ch_mode = get_bits(gb, 4);
 498     if (ch_mode < FLAC_MAX_CHANNELS) {
 499         channels = ch_mode + 1;
 500         ch_mode = FLAC_CHMODE_INDEPENDENT;
 501     } else if (ch_mode <= FLAC_CHMODE_MID_SIDE) {
 502         channels = 2;
 503     } else {
 504         av_log(s->avctx, AV_LOG_ERROR, "invalid channel mode: %d\n", ch_mode);
 505         return -1;
 506     }
 507
 508     /* bits per sample */
 509     bps_code = get_bits(gb, 3);
 510     if (bps_code == 3 || bps_code == 7) {
 511         av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n",
 512                bps_code);
 513         return -1;
 514     }
 515     bps = sample_size_table[bps_code];
 516
 517     /* reserved bit */
 518     if (get_bits1(gb)) {
 519         av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
 520         return -1;
 521     }
 522
 523     /* sample or frame count */
 524     if (get_utf8(gb) < 0) {
 525         av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
 526         return -1;
 527     }
 528
 529     /* blocksize */
 530     if (bs_code == 0) {
 531         av_log(s->avctx, AV_LOG_ERROR, "reserved blocksize code: 0\n");
 532         return -1;
 533     } else if (bs_code == 6) {
 534         blocksize = get_bits(gb, 8) + 1;
 535     } else if (bs_code == 7) {
 536         blocksize = get_bits(gb, 16) + 1;
 537     } else {
 538         blocksize = ff_flac_blocksize_table[bs_code];
 539     }
 540
 541     /* sample rate */
 542     if (sr_code < 12) {
 543         samplerate = ff_flac_sample_rate_table[sr_code];
 544     } else if (sr_code == 12) {
 545         samplerate = get_bits(gb, 8) * 1000;
 546     } else if (sr_code == 13) {
 547         samplerate = get_bits(gb, 16);
 548     } else if (sr_code == 14) {
 549         samplerate = get_bits(gb, 16) * 10;
 550     } else {
 551         av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n",
 552                sr_code);
 553         return -1;
 554     }
 555
 556     /* header CRC-8 check */
 557     skip_bits(gb, 8);
 558     if (av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, gb->buffer,
 559                get_bits_count(gb)/8)) {
 560         av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch\n");
 561         return -1;
 562     }
 563
 564     if (channels != s->channels) {
 565         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
 566                                        "is not supported\n");
 567         return -1;
 568     }
 569     s->ch_mode = ch_mode;
 570
 571     if (bps && bps != s->bps) {
 572         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 573                                        "supported\n");
 574         return -1;
 575     }
 576     if (s->bps > 16) {
 577         s->avctx->sample_fmt = SAMPLE_FMT_S32;
 578         s->sample_shift = 32 - s->bps;
 579         s->is32 = 1;
 580     } else {
 581         s->avctx->sample_fmt = SAMPLE_FMT_S16;
 582         s->sample_shift = 16 - s->bps;
 583         s->is32 = 0;
 584     }
 585
 586     if (blocksize > s->max_blocksize) {
 587         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize,
 588                s->max_blocksize);
 589         return -1;
 590     }
 591     s->blocksize = blocksize;
 592
 593     if (samplerate == 0) {
 594         samplerate = s->samplerate;
 595     } else if (samplerate != s->samplerate) {
 596         av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
 597                s->samplerate, samplerate);
 598     }
 599     s->samplerate = s->avctx->sample_rate = samplerate;
 600
 601 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
 602
 603     /* subframes */
 604     for (i = 0; i < s->channels; i++) {
 605         if (decode_subframe(s, i) < 0)
 606             return -1;
 607     }
 608
 609     align_get_bits(gb);
 610
 611     /* frame footer */
 612     skip_bits(gb, 16); /* data crc */
 613
 614     return 0;
 615 }
 616
 617 static int flac_decode_frame(AVCodecContext *avctx,
 618                             void *data, int *data_size,
 619                             const uint8_t *buf, int buf_size)
 620 {
 621     FLACContext *s = avctx->priv_data;
 622     int i, j = 0, input_buf_size = 0, bytes_read = 0;
 623     int16_t *samples_16 = data;
 624     int32_t *samples_32 = data;
 625     int alloc_data_size= *data_size;
 626     int output_size;
 627
 628     *data_size=0;
 629
 630     if (s->max_framesize == 0) {
 631         s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header
 632         s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
 633     }
 634
 635     if (1 && s->max_framesize) { //FIXME truncated
 636         if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
 637             buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
 638         input_buf_size= buf_size;
 639
 640         if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
 641             return -1;
 642
 643         if (s->allocated_bitstream_size < s->bitstream_size + buf_size)
 644             s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
 645
 646         if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) {
 647             memmove(s->bitstream, &s->bitstream[s->bitstream_index],
 648                     s->bitstream_size);
 649             s->bitstream_index=0;
 650         }
 651         memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size],
 652                buf, buf_size);
 653         buf= &s->bitstream[s->bitstream_index];
 654         buf_size += s->bitstream_size;
 655         s->bitstream_size= buf_size;
 656
 657         if (buf_size < s->max_framesize && input_buf_size) {
 658             return input_buf_size;
 659         }
 660     }
 661
 662     /* check that there is at least the smallest decodable amount of data.
 663        this amount corresponds to the smallest valid FLAC frame possible.
 664        FF F8 69 02 00 00 9A 00 00 34 46 */
 665     if (buf_size < 11)
 666         goto end;
 667
 668     /* check for inline header */
 669     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
 670         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
 671             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
 672             return -1;
 673         }
 674         bytes_read = get_metadata_size(buf, buf_size);
 675         goto end;
 676     }
 677
 678     /* check for frame sync code and resync stream if necessary */
 679     if ((AV_RB16(buf) & 0xFFFE) != 0xFFF8) {
 680         const uint8_t *buf_end = buf + buf_size;
 681         av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
 682         while (buf+2 < buf_end && (AV_RB16(buf) & 0xFFFE) != 0xFFF8)
 683             buf++;
 684         bytes_read = buf_size - (buf_end - buf);
 685         goto end; // we may not have enough bits left to decode a frame, so try next time
 686     }
 687
 688     /* decode frame */
 689     init_get_bits(&s->gb, buf, buf_size*8);
 690     if (decode_frame(s) < 0) {
 691         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 692         s->bitstream_size=0;
 693         s->bitstream_index=0;
 694         return -1;
 695     }
 696     bytes_read = (get_bits_count(&s->gb)+7)/8;
 697
 698     /* check if allocated data size is large enough for output */
 699     output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
 700     if (output_size > alloc_data_size) {
 701         av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
 702                                        "allocated data size\n");
 703         goto end;
 704     }
 705     *data_size = output_size;
 706
 707 #define DECORRELATE(left, right)\
 708             assert(s->channels == 2);\
 709             for (i = 0; i < s->blocksize; i++) {\
 710                 int a= s->decoded[0][i];\
 711                 int b= s->decoded[1][i];\
 712                 if (s->is32) {\
 713                     *samples_32++ = (left)  << s->sample_shift;\
 714                     *samples_32++ = (right) << s->sample_shift;\
 715                 } else {\
 716                     *samples_16++ = (left)  << s->sample_shift;\
 717                     *samples_16++ = (right) << s->sample_shift;\
 718                 }\
 719             }\
 720             break;
 721
 722     switch (s->ch_mode) {
 723     case FLAC_CHMODE_INDEPENDENT:
 724         for (j = 0; j < s->blocksize; j++) {
 725             for (i = 0; i < s->channels; i++) {
 726                 if (s->is32)
 727                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
 728                 else
 729                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
 730             }
 731         }
 732         break;
 733     case FLAC_CHMODE_LEFT_SIDE:
 734         DECORRELATE(a,a-b)
 735     case FLAC_CHMODE_RIGHT_SIDE:
 736         DECORRELATE(a+b,b)
 737     case FLAC_CHMODE_MID_SIDE:
 738         DECORRELATE( (a-=b>>1) + b, a)
 739     }
 740
 741 end:
 742     if (bytes_read > buf_size) {
 743         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 744         s->bitstream_size=0;
 745         s->bitstream_index=0;
 746         return -1;
 747     }
 748
 749     if (s->bitstream_size) {
 750         s->bitstream_index += bytes_read;
 751         s->bitstream_size  -= bytes_read;
 752         return input_buf_size;
 753     } else
 754         return bytes_read;
 755 }
 756
 757 static av_cold int flac_decode_close(AVCodecContext *avctx)
 758 {
 759     FLACContext *s = avctx->priv_data;
 760     int i;
 761
 762     for (i = 0; i < s->channels; i++) {
 763         av_freep(&s->decoded[i]);
 764     }
 765     av_freep(&s->bitstream);
 766
 767     return 0;
 768 }
 769
 770 static void flac_flush(AVCodecContext *avctx)
 771 {
 772     FLACContext *s = avctx->priv_data;
 773
 774     s->bitstream_size=
 775     s->bitstream_index= 0;
 776 }
 777
 778 AVCodec flac_decoder = {
 779     "flac",
 780     CODEC_TYPE_AUDIO,
 781     CODEC_ID_FLAC,
 782     sizeof(FLACContext),
 783     flac_decode_init,
 784     NULL,
 785     flac_decode_close,
 786     flac_decode_frame,
 787     CODEC_CAP_DELAY,
 788     .flush= flac_flush,
 789     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 790 };