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