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