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