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     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, 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     int initial_pos= get_bits_count(&s->gb);
 185
 186     if (show_bits_long(&s->gb, 32) == MKBETAG('f','L','a','C')) {
 187         skip_bits(&s->gb, 32);
 188
 189         av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
 190         do {
 191             metadata_last = get_bits1(&s->gb);
 192             metadata_type = get_bits(&s->gb, 7);
 193             metadata_size = get_bits_long(&s->gb, 24);
 194
 195             if(get_bits_count(&s->gb) + 8*metadata_size > s->gb.size_in_bits){
 196                 skip_bits_long(&s->gb, initial_pos - get_bits_count(&s->gb));
 197                 break;
 198             }
 199
 200             av_log(s->avctx, AV_LOG_DEBUG,
 201                    " metadata block: flag = %d, type = %d, size = %d\n",
 202                    metadata_last, metadata_type, metadata_size);
 203             if (metadata_size) {
 204                 switch (metadata_type) {
 205                 case METADATA_TYPE_STREAMINFO:
 206                     ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, s->gb.buffer+get_bits_count(&s->gb)/8);
 207                     streaminfo_updated = 1;
 208
 209                 default:
 210                     for (i=0; i<metadata_size; i++)
 211                         skip_bits(&s->gb, 8);
 212                 }
 213             }
 214         } while (!metadata_last);
 215
 216         if (streaminfo_updated)
 217             allocate_buffers(s);
 218         return 1;
 219     }
 220     return 0;
 221 }
 222
 223 static int decode_residuals(FLACContext *s, int channel, int pred_order)
 224 {
 225     int i, tmp, partition, method_type, rice_order;
 226     int sample = 0, samples;
 227
 228     method_type = get_bits(&s->gb, 2);
 229     if (method_type > 1){
 230         av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
 231         return -1;
 232     }
 233
 234     rice_order = get_bits(&s->gb, 4);
 235
 236     samples= s->blocksize >> rice_order;
 237     if (pred_order > samples) {
 238         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n", pred_order, samples);
 239         return -1;
 240     }
 241
 242     sample=
 243     i= pred_order;
 244     for (partition = 0; partition < (1 << rice_order); partition++)
 245     {
 246         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
 247         if (tmp == (method_type == 0 ? 15 : 31))
 248         {
 249             av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
 250             tmp = get_bits(&s->gb, 5);
 251             for (; i < samples; i++, sample++)
 252                 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
 253         }
 254         else
 255         {
 256 //            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
 257             for (; i < samples; i++, sample++){
 258                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 259             }
 260         }
 261         i= 0;
 262     }
 263
 264 //    av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
 265
 266     return 0;
 267 }
 268
 269 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
 270 {
 271     const int blocksize = s->blocksize;
 272     int32_t *decoded = s->decoded[channel];
 273     int a, b, c, d, i;
 274
 275 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");
 276
 277     /* warm up samples */
 278 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
 279
 280     for (i = 0; i < pred_order; i++)
 281     {
 282         decoded[i] = get_sbits(&s->gb, s->curr_bps);
 283 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
 284     }
 285
 286     if (decode_residuals(s, channel, pred_order) < 0)
 287         return -1;
 288
 289     if(pred_order > 0)
 290         a = decoded[pred_order-1];
 291     if(pred_order > 1)
 292         b = a - decoded[pred_order-2];
 293     if(pred_order > 2)
 294         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 295     if(pred_order > 3)
 296         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 297
 298     switch(pred_order)
 299     {
 300         case 0:
 301             break;
 302         case 1:
 303             for (i = pred_order; i < blocksize; i++)
 304                 decoded[i] = a += decoded[i];
 305             break;
 306         case 2:
 307             for (i = pred_order; i < blocksize; i++)
 308                 decoded[i] = a += b += decoded[i];
 309             break;
 310         case 3:
 311             for (i = pred_order; i < blocksize; i++)
 312                 decoded[i] = a += b += c += decoded[i];
 313             break;
 314         case 4:
 315             for (i = pred_order; i < blocksize; i++)
 316                 decoded[i] = a += b += c += d += decoded[i];
 317             break;
 318         default:
 319             av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 320             return -1;
 321     }
 322
 323     return 0;
 324 }
 325
 326 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
 327 {
 328     int i, j;
 329     int coeff_prec, qlevel;
 330     int coeffs[pred_order];
 331     int32_t *decoded = s->decoded[channel];
 332
 333 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");
 334
 335     /* warm up samples */
 336 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
 337
 338     for (i = 0; i < pred_order; i++)
 339     {
 340         decoded[i] = get_sbits(&s->gb, s->curr_bps);
 341 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, decoded[i]);
 342     }
 343
 344     coeff_prec = get_bits(&s->gb, 4) + 1;
 345     if (coeff_prec == 16)
 346     {
 347         av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
 348         return -1;
 349     }
 350 //    av_log(s->avctx, AV_LOG_DEBUG, "   qlp coeff prec: %d\n", coeff_prec);
 351     qlevel = get_sbits(&s->gb, 5);
 352 //    av_log(s->avctx, AV_LOG_DEBUG, "   quant level: %d\n", qlevel);
 353     if(qlevel < 0){
 354         av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
 355         return -1;
 356     }
 357
 358     for (i = 0; i < pred_order; i++)
 359     {
 360         coeffs[i] = get_sbits(&s->gb, coeff_prec);
 361 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);
 362     }
 363
 364     if (decode_residuals(s, channel, pred_order) < 0)
 365         return -1;
 366
 367     if (s->bps > 16) {
 368         int64_t sum;
 369         for (i = pred_order; i < s->blocksize; i++)
 370         {
 371             sum = 0;
 372             for (j = 0; j < pred_order; j++)
 373                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
 374             decoded[i] += sum >> qlevel;
 375         }
 376     } else {
 377         for (i = pred_order; i < s->blocksize-1; i += 2)
 378         {
 379             int c;
 380             int d = decoded[i-pred_order];
 381             int s0 = 0, s1 = 0;
 382             for (j = pred_order-1; j > 0; j--)
 383             {
 384                 c = coeffs[j];
 385                 s0 += c*d;
 386                 d = decoded[i-j];
 387                 s1 += c*d;
 388             }
 389             c = coeffs[0];
 390             s0 += c*d;
 391             d = decoded[i] += s0 >> qlevel;
 392             s1 += c*d;
 393             decoded[i+1] += s1 >> qlevel;
 394         }
 395         if (i < s->blocksize)
 396         {
 397             int sum = 0;
 398             for (j = 0; j < pred_order; j++)
 399                 sum += coeffs[j] * decoded[i-j-1];
 400             decoded[i] += sum >> qlevel;
 401         }
 402     }
 403
 404     return 0;
 405 }
 406
 407 static inline int decode_subframe(FLACContext *s, int channel)
 408 {
 409     int type, wasted = 0;
 410     int i, tmp;
 411
 412     s->curr_bps = s->bps;
 413     if(channel == 0){
 414         if(s->decorrelation == RIGHT_SIDE)
 415             s->curr_bps++;
 416     }else{
 417         if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
 418             s->curr_bps++;
 419     }
 420
 421     if (get_bits1(&s->gb))
 422     {
 423         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
 424         return -1;
 425     }
 426     type = get_bits(&s->gb, 6);
 427 //    wasted = get_bits1(&s->gb);
 428
 429 //    if (wasted)
 430 //    {
 431 //        while (!get_bits1(&s->gb))
 432 //            wasted++;
 433 //        if (wasted)
 434 //            wasted++;
 435 //        s->curr_bps -= wasted;
 436 //    }
 437 #if 0
 438     wasted= 16 - av_log2(show_bits(&s->gb, 17));
 439     skip_bits(&s->gb, wasted+1);
 440     s->curr_bps -= wasted;
 441 #else
 442     if (get_bits1(&s->gb))
 443     {
 444         wasted = 1;
 445         while (!get_bits1(&s->gb))
 446             wasted++;
 447         s->curr_bps -= wasted;
 448         av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
 449     }
 450 #endif
 451 //FIXME use av_log2 for types
 452     if (type == 0)
 453     {
 454         av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
 455         tmp = get_sbits(&s->gb, s->curr_bps);
 456         for (i = 0; i < s->blocksize; i++)
 457             s->decoded[channel][i] = tmp;
 458     }
 459     else if (type == 1)
 460     {
 461         av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
 462         for (i = 0; i < s->blocksize; i++)
 463             s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
 464     }
 465     else if ((type >= 8) && (type <= 12))
 466     {
 467 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
 468         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
 469             return -1;
 470     }
 471     else if (type >= 32)
 472     {
 473 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
 474         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
 475             return -1;
 476     }
 477     else
 478     {
 479         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 480         return -1;
 481     }
 482
 483     if (wasted)
 484     {
 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     {
 509         av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", 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     {
 520         av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code);
 521         return -1;
 522     }
 523
 524     if (get_bits1(&s->gb))
 525     {
 526         av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
 527         return -1;
 528     }
 529
 530     if(get_utf8(&s->gb) < 0){
 531         av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
 532         return -1;
 533     }
 534 #if 0
 535     if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
 536         (s->min_blocksize != s->max_blocksize)){
 537     }else{
 538     }
 539 #endif
 540
 541     if (blocksize_code == 0)
 542         blocksize = s->min_blocksize;
 543     else if (blocksize_code == 6)
 544         blocksize = get_bits(&s->gb, 8)+1;
 545     else if (blocksize_code == 7)
 546         blocksize = get_bits(&s->gb, 16)+1;
 547     else
 548         blocksize = blocksize_table[blocksize_code];
 549
 550     if(blocksize > s->max_blocksize){
 551         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
 552         return -1;
 553     }
 554
 555     if(blocksize * s->channels * sizeof(int16_t) > alloc_data_size)
 556         return -1;
 557
 558     if (sample_rate_code == 0){
 559         samplerate= s->samplerate;
 560     }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
 561         samplerate = sample_rate_table[sample_rate_code];
 562     else if (sample_rate_code == 12)
 563         samplerate = get_bits(&s->gb, 8) * 1000;
 564     else if (sample_rate_code == 13)
 565         samplerate = get_bits(&s->gb, 16);
 566     else if (sample_rate_code == 14)
 567         samplerate = get_bits(&s->gb, 16) * 10;
 568     else{
 569         av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
 570         return -1;
 571     }
 572
 573     skip_bits(&s->gb, 8);
 574     crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
 575                   s->gb.buffer, get_bits_count(&s->gb)/8);
 576     if(crc8){
 577         av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
 578         return -1;
 579     }
 580
 581     s->blocksize    = blocksize;
 582     s->samplerate   = samplerate;
 583     s->bps          = bps;
 584     s->decorrelation= decorrelation;
 585
 586 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
 587
 588     /* subframes */
 589     for (i = 0; i < s->channels; i++)
 590     {
 591 //        av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
 592         if (decode_subframe(s, i) < 0)
 593             return -1;
 594     }
 595
 596     align_get_bits(&s->gb);
 597
 598     /* frame footer */
 599     skip_bits(&s->gb, 16); /* data crc */
 600
 601     return 0;
 602 }
 603
 604 static int flac_decode_frame(AVCodecContext *avctx,
 605                             void *data, int *data_size,
 606                             const uint8_t *buf, int buf_size)
 607 {
 608     FLACContext *s = avctx->priv_data;
 609     int tmp = 0, i, j = 0, input_buf_size = 0;
 610     int16_t *samples = data;
 611     int alloc_data_size= *data_size;
 612
 613     *data_size=0;
 614
 615     if(s->max_framesize == 0){
 616         s->max_framesize= 65536; // should hopefully be enough for the first header
 617         s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
 618     }
 619
 620     if(1 && s->max_framesize){//FIXME truncated
 621             if(s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
 622                 buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
 623             input_buf_size= buf_size;
 624
 625             if(s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
 626                 return -1;
 627
 628             if(s->allocated_bitstream_size < s->bitstream_size + buf_size)
 629                 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
 630
 631             if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
 632 //                printf("memmove\n");
 633                 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
 634                 s->bitstream_index=0;
 635             }
 636             memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
 637             buf= &s->bitstream[s->bitstream_index];
 638             buf_size += s->bitstream_size;
 639             s->bitstream_size= buf_size;
 640
 641             if(buf_size < s->max_framesize && input_buf_size){
 642 //                printf("wanna more data ...\n");
 643                 return input_buf_size;
 644             }
 645     }
 646
 647     init_get_bits(&s->gb, buf, buf_size*8);
 648
 649     if(metadata_parse(s))
 650         goto end;
 651
 652         tmp = show_bits(&s->gb, 16);
 653         if((tmp & 0xFFFE) != 0xFFF8){
 654             av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
 655             while(get_bits_count(&s->gb)/8+2 < buf_size && (show_bits(&s->gb, 16) & 0xFFFE) != 0xFFF8)
 656                 skip_bits(&s->gb, 8);
 657             goto end; // we may not have enough bits left to decode a frame, so try next time
 658         }
 659         skip_bits(&s->gb, 16);
 660         if (decode_frame(s, alloc_data_size) < 0){
 661             av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 662             s->bitstream_size=0;
 663             s->bitstream_index=0;
 664             return -1;
 665         }
 666
 667
 668 #if 0
 669     /* fix the channel order here */
 670     if (s->order == MID_SIDE)
 671     {
 672         short *left = samples;
 673         short *right = samples + s->blocksize;
 674         for (i = 0; i < s->blocksize; i += 2)
 675         {
 676             uint32_t x = s->decoded[0][i];
 677             uint32_t y = s->decoded[0][i+1];
 678
 679             right[i] = x - (y / 2);
 680             left[i] = right[i] + y;
 681         }
 682         *data_size = 2 * s->blocksize;
 683     }
 684     else
 685     {
 686     for (i = 0; i < s->channels; i++)
 687     {
 688         switch(s->order)
 689         {
 690             case INDEPENDENT:
 691                 for (j = 0; j < s->blocksize; j++)
 692                     samples[(s->blocksize*i)+j] = s->decoded[i][j];
 693                 break;
 694             case LEFT_SIDE:
 695             case RIGHT_SIDE:
 696                 if (i == 0)
 697                     for (j = 0; j < s->blocksize; j++)
 698                         samples[(s->blocksize*i)+j] = s->decoded[0][j];
 699                 else
 700                     for (j = 0; j < s->blocksize; j++)
 701                         samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
 702                 break;
 703 //            case MID_SIDE:
 704 //                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
 705         }
 706         *data_size += s->blocksize;
 707     }
 708     }
 709 #else
 710 #define DECORRELATE(left, right)\
 711             assert(s->channels == 2);\
 712             for (i = 0; i < s->blocksize; i++)\
 713             {\
 714                 int a= s->decoded[0][i];\
 715                 int b= s->decoded[1][i];\
 716                 *samples++ = ((left)  << (24 - s->bps)) >> 8;\
 717                 *samples++ = ((right) << (24 - s->bps)) >> 8;\
 718             }\
 719             break;
 720
 721     switch(s->decorrelation)
 722     {
 723         case INDEPENDENT:
 724             for (j = 0; j < s->blocksize; j++)
 725             {
 726                 for (i = 0; i < s->channels; i++)
 727                     *samples++ = (s->decoded[i][j] << (24 - s->bps)) >> 8;
 728             }
 729             break;
 730         case LEFT_SIDE:
 731             DECORRELATE(a,a-b)
 732         case RIGHT_SIDE:
 733             DECORRELATE(a+b,b)
 734         case MID_SIDE:
 735             DECORRELATE( (a-=b>>1) + b, a)
 736     }
 737 #endif
 738
 739     *data_size = (int8_t *)samples - (int8_t *)data;
 740 //    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
 741
 742 //    s->last_blocksize = s->blocksize;
 743 end:
 744     i= (get_bits_count(&s->gb)+7)/8;
 745     if(i > buf_size){
 746         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
 747         s->bitstream_size=0;
 748         s->bitstream_index=0;
 749         return -1;
 750     }
 751
 752     if(s->bitstream_size){
 753         s->bitstream_index += i;
 754         s->bitstream_size  -= i;
 755         return input_buf_size;
 756     }else
 757         return i;
 758 }
 759
 760 static av_cold int flac_decode_close(AVCodecContext *avctx)
 761 {
 762     FLACContext *s = avctx->priv_data;
 763     int i;
 764
 765     for (i = 0; i < s->channels; i++)
 766     {
 767         av_freep(&s->decoded[i]);
 768     }
 769     av_freep(&s->bitstream);
 770
 771     return 0;
 772 }
 773
 774 static void flac_flush(AVCodecContext *avctx){
 775     FLACContext *s = avctx->priv_data;
 776
 777     s->bitstream_size=
 778     s->bitstream_index= 0;
 779 }
 780
 781 AVCodec flac_decoder = {
 782     "flac",
 783     CODEC_TYPE_AUDIO,
 784     CODEC_ID_FLAC,
 785     sizeof(FLACContext),
 786     flac_decode_init,
 787     NULL,
 788     flac_decode_close,
 789     flac_decode_frame,
 790     CODEC_CAP_DELAY,
 791     .flush= flac_flush,
 792     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 793 };