libavcodec/flac.c

   1 /*
   2  * FLAC (Free Lossless Audio Codec) decoder
   3  * Copyright (c) 2003 Alex Beregszaszi
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 /**
  21  * @file flac.c
  22  * FLAC (Free Lossless Audio Codec) decoder
  23  * @author Alex Beregszaszi
  24  *
  25  * For more information on the FLAC format, visit:
  26  *  http://flac.sourceforge.net/
  27  *
  28  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
  29  * through, starting from the initial 'fLaC' signature; or by passing the
  30  * 34-byte streaminfo structure through avctx->extradata[_size] followed
  31  * by data starting with the 0xFFF8 marker.
  32  */
  33
  34 #include <limits.h>
  35
  36 #include "avcodec.h"
  37 #include "golomb.h"
  38
  39 #undef NDEBUG
  40 #include <assert.h>
  41
  42 #define MAX_CHANNELS 8
  43 #define MAX_BLOCKSIZE 65535
  44 #define FLAC_STREAMINFO_SIZE 34
  45
  46 enum decorrelation_type {
  47     INDEPENDENT,
  48     LEFT_SIDE,
  49     RIGHT_SIDE,
  50     MID_SIDE,
  51 };
  52
  53 typedef struct FLACContext {
  54     AVCodecContext *avctx;
  55     GetBitContext gb;
  56
  57     int min_blocksize, max_blocksize;
  58     int min_framesize, max_framesize;
  59     int samplerate, channels;
  60     int blocksize/*, last_blocksize*/;
  61     int bps, curr_bps;
  62     enum decorrelation_type decorrelation;
  63
  64     int32_t *decoded[MAX_CHANNELS];
  65     uint8_t *bitstream;
  66     int bitstream_size;
  67     int bitstream_index;
  68     int allocated_bitstream_size;
  69 } FLACContext;
  70
  71 #define METADATA_TYPE_STREAMINFO 0
  72
  73 static int sample_rate_table[] =
  74 { 0, 0, 0, 0,
  75   8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
  76   0, 0, 0, 0 };
  77
  78 static int sample_size_table[] =
  79 { 0, 8, 12, 0, 16, 20, 24, 0 };
  80
  81 static int blocksize_table[] = {
  82      0,    192, 576<<0, 576<<1, 576<<2, 576<<3,      0,      0,
  83 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
  84 };
  85
  86 static const uint8_t table_crc8[256] = {
  87     0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
  88     0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
  89     0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,
  90     0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d,
  91     0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5,
  92     0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
  93     0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85,
  94     0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd,
  95     0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2,
  96     0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea,
  97     0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2,
  98     0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
  99     0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32,
 100     0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a,
 101     0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42,
 102     0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a,
 103     0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c,
 104     0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
 105     0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec,
 106     0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4,
 107     0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c,
 108     0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44,
 109     0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c,
 110     0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
 111     0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b,
 112     0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63,
 113     0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b,
 114     0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13,
 115     0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb,
 116     0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
 117     0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb,
 118     0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3
 119 };
 120
 121 static int64_t get_utf8(GetBitContext *gb)
 122 {
 123     uint64_t val;
 124     int ones=0, bytes;
 125
 126     while(get_bits1(gb))
 127         ones++;
 128
 129     if     (ones==0) bytes=0;
 130     else if(ones==1) return -1;
 131     else             bytes= ones - 1;
 132
 133     val= get_bits(gb, 7-ones);
 134     while(bytes--){
 135         const int tmp = get_bits(gb, 8);
 136
 137         if((tmp>>6) != 2)
 138             return -1;
 139         val<<=6;
 140         val|= tmp&0x3F;
 141     }
 142     return val;
 143 }
 144
 145 static int get_crc8(const uint8_t *buf, int count){
 146     int crc=0;
 147     int i;
 148
 149     for(i=0; i<count; i++){
 150         crc = table_crc8[crc ^ buf[i]];
 151     }
 152
 153     return crc;
 154 }
 155
 156 static void metadata_streaminfo(FLACContext *s);
 157 static void dump_headers(FLACContext *s);
 158
 159 static int flac_decode_init(AVCodecContext * avctx)
 160 {
 161     FLACContext *s = avctx->priv_data;
 162     s->avctx = avctx;
 163
 164     /* initialize based on the demuxer-supplied streamdata header */
 165     if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
 166         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
 167         metadata_streaminfo(s);
 168         dump_headers(s);
 169     }
 170
 171     return 0;
 172 }
 173
 174 static void dump_headers(FLACContext *s)
 175 {
 176     av_log(s->avctx, AV_LOG_DEBUG, "  Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
 177     av_log(s->avctx, AV_LOG_DEBUG, "  Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
 178     av_log(s->avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
 179     av_log(s->avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
 180     av_log(s->avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
 181 }
 182
 183 static void allocate_buffers(FLACContext *s){
 184     int i;
 185
 186     assert(s->max_blocksize);
 187
 188     if(s->max_framesize == 0 && s->max_blocksize){
 189         s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
 190     }
 191
 192     for (i = 0; i < s->channels; i++)
 193     {
 194         s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
 195     }
 196
 197     s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
 198 }
 199
 200 static void metadata_streaminfo(FLACContext *s)
 201 {
 202     /* mandatory streaminfo */
 203     s->min_blocksize = get_bits(&s->gb, 16);
 204     s->max_blocksize = get_bits(&s->gb, 16);
 205
 206     s->min_framesize = get_bits_long(&s->gb, 24);
 207     s->max_framesize = get_bits_long(&s->gb, 24);
 208
 209     s->samplerate = get_bits_long(&s->gb, 20);
 210     s->channels = get_bits(&s->gb, 3) + 1;
 211     s->bps = get_bits(&s->gb, 5) + 1;
 212
 213     s->avctx->channels = s->channels;
 214     s->avctx->sample_rate = s->samplerate;
 215
 216     skip_bits(&s->gb, 36); /* total num of samples */
 217
 218     skip_bits(&s->gb, 64); /* md5 sum */
 219     skip_bits(&s->gb, 64); /* md5 sum */
 220
 221     allocate_buffers(s);
 222 }
 223
 224 static int decode_residuals(FLACContext *s, int channel, int pred_order)
 225 {
 226     int i, tmp, partition, method_type, rice_order;
 227     int sample = 0, samples;
 228
 229     method_type = get_bits(&s->gb, 2);
 230     if (method_type != 0){
 231         av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
 232         return -1;
 233     }
 234
 235     rice_order = get_bits(&s->gb, 4);
 236
 237     samples= s->blocksize >> rice_order;
 238
 239     sample=
 240     i= pred_order;
 241     for (partition = 0; partition < (1 << rice_order); partition++)
 242     {
 243         tmp = get_bits(&s->gb, 4);
 244         if (tmp == 15)
 245         {
 246             av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
 247             tmp = get_bits(&s->gb, 5);
 248             for (; i < samples; i++, sample++)
 249                 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
 250         }
 251         else
 252         {
 253 //            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
 254             for (; i < samples; i++, sample++){
 255                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 256             }
 257         }
 258         i= 0;
 259     }
 260
 261 //    av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
 262
 263     return 0;
 264 }
 265
 266 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
 267 {
 268     int i;
 269
 270 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");
 271
 272     /* warm up samples */
 273 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
 274
 275     for (i = 0; i < pred_order; i++)
 276     {
 277         s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
 278 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
 279     }
 280
 281     if (decode_residuals(s, channel, pred_order) < 0)
 282         return -1;
 283
 284     switch(pred_order)
 285     {
 286         case 0:
 287             break;
 288         case 1:
 289             for (i = pred_order; i < s->blocksize; i++)
 290                 s->decoded[channel][i] +=   s->decoded[channel][i-1];
 291             break;
 292         case 2:
 293             for (i = pred_order; i < s->blocksize; i++)
 294                 s->decoded[channel][i] += 2*s->decoded[channel][i-1]
 295                                           - s->decoded[channel][i-2];
 296             break;
 297         case 3:
 298             for (i = pred_order; i < s->blocksize; i++)
 299                 s->decoded[channel][i] += 3*s->decoded[channel][i-1]
 300                                         - 3*s->decoded[channel][i-2]
 301                                         +   s->decoded[channel][i-3];
 302             break;
 303         case 4:
 304             for (i = pred_order; i < s->blocksize; i++)
 305                 s->decoded[channel][i] += 4*s->decoded[channel][i-1]
 306                                         - 6*s->decoded[channel][i-2]
 307                                         + 4*s->decoded[channel][i-3]
 308                                         -   s->decoded[channel][i-4];
 309             break;
 310         default:
 311             av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 312             return -1;
 313     }
 314
 315     return 0;
 316 }
 317
 318 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
 319 {
 320     int sum, i, j;
 321     int coeff_prec, qlevel;
 322     int coeffs[pred_order];
 323
 324 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");
 325
 326     /* warm up samples */
 327 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
 328
 329     for (i = 0; i < pred_order; i++)
 330     {
 331         s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
 332 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
 333     }
 334
 335     coeff_prec = get_bits(&s->gb, 4) + 1;
 336     if (coeff_prec == 16)
 337     {
 338         av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
 339         return -1;
 340     }
 341 //    av_log(s->avctx, AV_LOG_DEBUG, "   qlp coeff prec: %d\n", coeff_prec);
 342     qlevel = get_sbits(&s->gb, 5);
 343 //    av_log(s->avctx, AV_LOG_DEBUG, "   quant level: %d\n", qlevel);
 344     if(qlevel < 0){
 345         av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
 346         return -1;
 347     }
 348
 349     for (i = 0; i < pred_order; i++)
 350     {
 351         coeffs[i] = get_sbits(&s->gb, coeff_prec);
 352 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);
 353     }
 354
 355     if (decode_residuals(s, channel, pred_order) < 0)
 356         return -1;
 357
 358     for (i = pred_order; i < s->blocksize; i++)
 359     {
 360         sum = 0;
 361         for (j = 0; j < pred_order; j++)
 362             sum += coeffs[j] * s->decoded[channel][i-j-1];
 363         s->decoded[channel][i] += sum >> qlevel;
 364     }
 365
 366     return 0;
 367 }
 368
 369 static inline int decode_subframe(FLACContext *s, int channel)
 370 {
 371     int type, wasted = 0;
 372     int i, tmp;
 373
 374     s->curr_bps = s->bps;
 375     if(channel == 0){
 376         if(s->decorrelation == RIGHT_SIDE)
 377             s->curr_bps++;
 378     }else{
 379         if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
 380             s->curr_bps++;
 381     }
 382
 383     if (get_bits1(&s->gb))
 384     {
 385         av_log(s->avctx, AV_LOG_DEBUG, "invalid subframe padding\n");
 386         return -1;
 387     }
 388     type = get_bits(&s->gb, 6);
 389 //    wasted = get_bits1(&s->gb);
 390
 391 //    if (wasted)
 392 //    {
 393 //        while (!get_bits1(&s->gb))
 394 //            wasted++;
 395 //        if (wasted)
 396 //            wasted++;
 397 //        s->curr_bps -= wasted;
 398 //    }
 399 #if 0
 400     wasted= 16 - av_log2(show_bits(&s->gb, 17));
 401     skip_bits(&s->gb, wasted+1);
 402     s->curr_bps -= wasted;
 403 #else
 404     if (get_bits1(&s->gb))
 405     {
 406         wasted = 1;
 407         while (!get_bits1(&s->gb))
 408             wasted++;
 409         s->curr_bps -= wasted;
 410         av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
 411     }
 412 #endif
 413 //FIXME use av_log2 for types
 414     if (type == 0)
 415     {
 416         av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
 417         tmp = get_sbits(&s->gb, s->curr_bps);
 418         for (i = 0; i < s->blocksize; i++)
 419             s->decoded[channel][i] = tmp;
 420     }
 421     else if (type == 1)
 422     {
 423         av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
 424         for (i = 0; i < s->blocksize; i++)
 425             s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
 426     }
 427     else if ((type >= 8) && (type <= 12))
 428     {
 429 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
 430         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
 431             return -1;
 432     }
 433     else if (type >= 32)
 434     {
 435 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
 436         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
 437             return -1;
 438     }
 439     else
 440     {
 441         av_log(s->avctx, AV_LOG_DEBUG, "invalid coding type\n");
 442         return -1;
 443     }
 444
 445     if (wasted)
 446     {
 447         int i;
 448         for (i = 0; i < s->blocksize; i++)
 449             s->decoded[channel][i] <<= wasted;
 450     }
 451
 452     return 0;
 453 }
 454
 455 static int decode_frame(FLACContext *s)
 456 {
 457     int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
 458     int decorrelation, bps, blocksize, samplerate;
 459
 460     blocksize_code = get_bits(&s->gb, 4);
 461
 462     sample_rate_code = get_bits(&s->gb, 4);
 463
 464     assignment = get_bits(&s->gb, 4); /* channel assignment */
 465     if (assignment < 8 && s->channels == assignment+1)
 466         decorrelation = INDEPENDENT;
 467     else if (assignment >=8 && assignment < 11 && s->channels == 2)
 468         decorrelation = LEFT_SIDE + assignment - 8;
 469     else
 470     {
 471         av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
 472         return -1;
 473     }
 474
 475     sample_size_code = get_bits(&s->gb, 3);
 476     if(sample_size_code == 0)
 477         bps= s->bps;
 478     else if((sample_size_code != 3) && (sample_size_code != 7))
 479         bps = sample_size_table[sample_size_code];
 480     else
 481     {
 482         av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
 483         return -1;
 484     }
 485
 486     if (get_bits1(&s->gb))
 487     {
 488         av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
 489         return -1;
 490     }
 491
 492     if(get_utf8(&s->gb) < 0){
 493         av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
 494         return -1;
 495     }
 496 #if 0
 497     if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
 498         (s->min_blocksize != s->max_blocksize)){
 499     }else{
 500     }
 501 #endif
 502
 503     if (blocksize_code == 0)
 504         blocksize = s->min_blocksize;
 505     else if (blocksize_code == 6)
 506         blocksize = get_bits(&s->gb, 8)+1;
 507     else if (blocksize_code == 7)
 508         blocksize = get_bits(&s->gb, 16)+1;
 509     else
 510         blocksize = blocksize_table[blocksize_code];
 511
 512     if(blocksize > s->max_blocksize){
 513         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
 514         return -1;
 515     }
 516
 517     if (sample_rate_code == 0){
 518         samplerate= s->samplerate;
 519     }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
 520         samplerate = sample_rate_table[sample_rate_code];
 521     else if (sample_rate_code == 12)
 522         samplerate = get_bits(&s->gb, 8) * 1000;
 523     else if (sample_rate_code == 13)
 524         samplerate = get_bits(&s->gb, 16);
 525     else if (sample_rate_code == 14)
 526         samplerate = get_bits(&s->gb, 16) * 10;
 527     else{
 528         av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
 529         return -1;
 530     }
 531
 532     skip_bits(&s->gb, 8);
 533     crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
 534     if(crc8){
 535         av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
 536         return -1;
 537     }
 538
 539     s->blocksize    = blocksize;
 540     s->samplerate   = samplerate;
 541     s->bps          = bps;
 542     s->decorrelation= decorrelation;
 543
 544 //    dump_headers(s);
 545
 546     /* subframes */
 547     for (i = 0; i < s->channels; i++)
 548     {
 549 //        av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
 550         if (decode_subframe(s, i) < 0)
 551             return -1;
 552     }
 553
 554     align_get_bits(&s->gb);
 555
 556     /* frame footer */
 557     skip_bits(&s->gb, 16); /* data crc */
 558
 559     return 0;
 560 }
 561
 562 static int flac_decode_frame(AVCodecContext *avctx,
 563                             void *data, int *data_size,
 564                             uint8_t *buf, int buf_size)
 565 {
 566     FLACContext *s = avctx->priv_data;
 567     int metadata_last, metadata_type, metadata_size;
 568     int tmp = 0, i, j = 0, input_buf_size = 0;
 569     int16_t *samples = data;
 570
 571     if(s->max_framesize == 0){
 572         s->max_framesize= 8192; // should hopefully be enough for the first header
 573         s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
 574     }
 575
 576     if(1 && s->max_framesize){//FIXME truncated
 577             buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
 578             input_buf_size= buf_size;
 579
 580             if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
 581 //                printf("memmove\n");
 582                 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
 583                 s->bitstream_index=0;
 584             }
 585             memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
 586             buf= &s->bitstream[s->bitstream_index];
 587             buf_size += s->bitstream_size;
 588             s->bitstream_size= buf_size;
 589
 590             if(buf_size < s->max_framesize){
 591 //                printf("wanna more data ...\n");
 592                 return input_buf_size;
 593             }
 594     }
 595
 596     init_get_bits(&s->gb, buf, buf_size*8);
 597
 598     /* fLaC signature (be) */
 599     if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
 600     {
 601         skip_bits(&s->gb, 32);
 602
 603         av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
 604         do {
 605             metadata_last = get_bits(&s->gb, 1);
 606             metadata_type = get_bits(&s->gb, 7);
 607             metadata_size = get_bits_long(&s->gb, 24);
 608
 609             av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
 610                 metadata_last, metadata_type,
 611                 metadata_size);
 612             if(metadata_size){
 613                 switch(metadata_type)
 614                 {
 615                 case METADATA_TYPE_STREAMINFO:
 616                     metadata_streaminfo(s);
 617                     dump_headers(s);
 618                     break;
 619                 default:
 620                     for(i=0; i<metadata_size; i++)
 621                         skip_bits(&s->gb, 8);
 622                 }
 623             }
 624         } while(!metadata_last);
 625     }
 626     else
 627     {
 628
 629         tmp = show_bits(&s->gb, 16);
 630         if(tmp != 0xFFF8){
 631             av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
 632             while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
 633                 skip_bits(&s->gb, 8);
 634             goto end; // we may not have enough bits left to decode a frame, so try next time
 635         }
 636         skip_bits(&s->gb, 16);
 637         if (decode_frame(s) < 0){
 638             av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 639             s->bitstream_size=0;
 640             s->bitstream_index=0;
 641             return -1;
 642         }
 643     }
 644
 645
 646 #if 0
 647     /* fix the channel order here */
 648     if (s->order == MID_SIDE)
 649     {
 650         short *left = samples;
 651         short *right = samples + s->blocksize;
 652         for (i = 0; i < s->blocksize; i += 2)
 653         {
 654             uint32_t x = s->decoded[0][i];
 655             uint32_t y = s->decoded[0][i+1];
 656
 657             right[i] = x - (y / 2);
 658             left[i] = right[i] + y;
 659         }
 660         *data_size = 2 * s->blocksize;
 661     }
 662     else
 663     {
 664     for (i = 0; i < s->channels; i++)
 665     {
 666         switch(s->order)
 667         {
 668             case INDEPENDENT:
 669                 for (j = 0; j < s->blocksize; j++)
 670                     samples[(s->blocksize*i)+j] = s->decoded[i][j];
 671                 break;
 672             case LEFT_SIDE:
 673             case RIGHT_SIDE:
 674                 if (i == 0)
 675                     for (j = 0; j < s->blocksize; j++)
 676                         samples[(s->blocksize*i)+j] = s->decoded[0][j];
 677                 else
 678                     for (j = 0; j < s->blocksize; j++)
 679                         samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
 680                 break;
 681 //            case MID_SIDE:
 682 //                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
 683         }
 684         *data_size += s->blocksize;
 685     }
 686     }
 687 #else
 688     switch(s->decorrelation)
 689     {
 690         case INDEPENDENT:
 691             for (j = 0; j < s->blocksize; j++)
 692             {
 693                 for (i = 0; i < s->channels; i++)
 694                     *(samples++) = s->decoded[i][j];
 695             }
 696             break;
 697         case LEFT_SIDE:
 698             assert(s->channels == 2);
 699             for (i = 0; i < s->blocksize; i++)
 700             {
 701                 *(samples++) = s->decoded[0][i];
 702                 *(samples++) = s->decoded[0][i] - s->decoded[1][i];
 703             }
 704             break;
 705         case RIGHT_SIDE:
 706             assert(s->channels == 2);
 707             for (i = 0; i < s->blocksize; i++)
 708             {
 709                 *(samples++) = s->decoded[0][i] + s->decoded[1][i];
 710                 *(samples++) = s->decoded[1][i];
 711             }
 712             break;
 713         case MID_SIDE:
 714             assert(s->channels == 2);
 715             for (i = 0; i < s->blocksize; i++)
 716             {
 717                 int mid, side;
 718                 mid = s->decoded[0][i];
 719                 side = s->decoded[1][i];
 720
 721 #if 1 //needs to be checked but IMHO it should be binary identical
 722                 mid -= side>>1;
 723                 *(samples++) = mid + side;
 724                 *(samples++) = mid;
 725 #else
 726
 727                 mid <<= 1;
 728                 if (side & 1)
 729                     mid++;
 730                 *(samples++) = (mid + side) >> 1;
 731                 *(samples++) = (mid - side) >> 1;
 732 #endif
 733             }
 734             break;
 735     }
 736 #endif
 737
 738     *data_size = (int8_t *)samples - (int8_t *)data;
 739 //    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
 740
 741 //    s->last_blocksize = s->blocksize;
 742 end:
 743     i= (get_bits_count(&s->gb)+7)/8;;
 744     if(i > buf_size){
 745         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
 746         s->bitstream_size=0;
 747         s->bitstream_index=0;
 748         return -1;
 749     }
 750
 751     if(s->bitstream_size){
 752         s->bitstream_index += i;
 753         s->bitstream_size  -= i;
 754         return input_buf_size;
 755     }else
 756         return i;
 757 }
 758
 759 static int flac_decode_close(AVCodecContext *avctx)
 760 {
 761     FLACContext *s = avctx->priv_data;
 762     int i;
 763
 764     for (i = 0; i < s->channels; i++)
 765     {
 766         av_freep(&s->decoded[i]);
 767     }
 768     av_freep(&s->bitstream);
 769
 770     return 0;
 771 }
 772
 773 static void flac_flush(AVCodecContext *avctx){
 774     FLACContext *s = avctx->priv_data;
 775
 776     s->bitstream_size=
 777     s->bitstream_index= 0;
 778 }
 779
 780 AVCodec flac_decoder = {
 781     "flac",
 782     CODEC_TYPE_AUDIO,
 783     CODEC_ID_FLAC,
 784     sizeof(FLACContext),
 785     flac_decode_init,
 786     NULL,
 787     flac_decode_close,
 788     flac_decode_frame,
 789     .flush= flac_flush,
 790 };