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