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