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