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