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 int blocksize_table[] = {
  73      0,    192, 576<<0, 576<<1, 576<<2, 576<<3,      0,      0,
  74 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
  75 };
  76
  77 static const uint8_t table_crc8[256] = {
  78     0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
  79     0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
  80     0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,
  81     0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d,
  82     0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5,
  83     0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
  84     0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85,
  85     0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd,
  86     0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2,
  87     0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea,
  88     0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2,
  89     0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
  90     0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32,
  91     0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a,
  92     0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42,
  93     0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a,
  94     0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c,
  95     0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
  96     0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec,
  97     0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4,
  98     0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c,
  99     0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44,
 100     0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c,
 101     0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
 102     0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b,
 103     0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63,
 104     0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b,
 105     0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13,
 106     0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb,
 107     0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
 108     0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb,
 109     0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3
 110 };
 111
 112 static int64_t get_utf8(GetBitContext *gb)
 113 {
 114     uint64_t val;
 115     int ones=0, bytes;
 116
 117     while(get_bits1(gb))
 118         ones++;
 119
 120     if     (ones==0) bytes=0;
 121     else if(ones==1) return -1;
 122     else             bytes= ones - 1;
 123
 124     val= get_bits(gb, 7-ones);
 125     while(bytes--){
 126         const int tmp = get_bits(gb, 8);
 127
 128         if((tmp>>6) != 2)
 129             return -1;
 130         val<<=6;
 131         val|= tmp&0x3F;
 132     }
 133     return val;
 134 }
 135
 136 static int get_crc8(uint8_t *buf, int count){
 137     int crc=0;
 138     int i;
 139
 140     for(i=0; i<count; i++){
 141         crc = table_crc8[crc ^ buf[i]];
 142     }
 143
 144     return crc;
 145 }
 146
 147 static int flac_decode_init(AVCodecContext * avctx)
 148 {
 149     return 0;
 150 }
 151
 152 static void dump_headers(FLACContext *s)
 153 {
 154     av_log(s->avctx, AV_LOG_DEBUG, "  Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
 155     av_log(s->avctx, AV_LOG_DEBUG, "  Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
 156     av_log(s->avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
 157     av_log(s->avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
 158     av_log(s->avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
 159 }
 160
 161 static void allocate_buffers(FLACContext *s){
 162     int i;
 163
 164     assert(s->max_blocksize);
 165
 166     if(s->max_framesize == 0 && s->max_blocksize){
 167         s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
 168     }
 169
 170     for (i = 0; i < s->channels; i++)
 171     {
 172         s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
 173     }
 174
 175     s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
 176 }
 177
 178 static void metadata_streaminfo(FLACContext *s)
 179 {
 180     /* mandatory streaminfo */
 181     s->min_blocksize = get_bits(&s->gb, 16);
 182     s->max_blocksize = get_bits(&s->gb, 16);
 183
 184     s->min_framesize = get_bits_long(&s->gb, 24);
 185     s->max_framesize = get_bits_long(&s->gb, 24);
 186
 187     s->samplerate = get_bits_long(&s->gb, 20);
 188     s->channels = get_bits(&s->gb, 3) + 1;
 189     s->bps = get_bits(&s->gb, 5) + 1;
 190
 191     s->avctx->channels = s->channels;
 192     s->avctx->sample_rate = s->samplerate;
 193
 194     skip_bits(&s->gb, 36); /* total num of samples */
 195
 196     skip_bits(&s->gb, 64); /* md5 sum */
 197     skip_bits(&s->gb, 64); /* md5 sum */
 198
 199     allocate_buffers(s);
 200 }
 201
 202 static int decode_residuals(FLACContext *s, int channel, int pred_order)
 203 {
 204     int i, tmp, partition, method_type, rice_order;
 205     int sample = 0, samples;
 206
 207     method_type = get_bits(&s->gb, 2);
 208     if (method_type != 0){
 209         av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
 210         return -1;
 211     }
 212
 213     rice_order = get_bits(&s->gb, 4);
 214
 215     samples= s->blocksize >> rice_order;
 216
 217     sample=
 218     i= pred_order;
 219     for (partition = 0; partition < (1 << rice_order); partition++)
 220     {
 221         tmp = get_bits(&s->gb, 4);
 222         if (tmp == 15)
 223         {
 224             av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
 225             tmp = get_bits(&s->gb, 5);
 226             for (; i < samples; i++, sample++)
 227                 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
 228         }
 229         else
 230         {
 231 //            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
 232             for (; i < samples; i++, sample++){
 233                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 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     int decorrelation, bps, blocksize, samplerate;
 437
 438     blocksize_code = get_bits(&s->gb, 4);
 439
 440     sample_rate_code = get_bits(&s->gb, 4);
 441
 442     assignment = get_bits(&s->gb, 4); /* channel assignment */
 443     if (assignment < 8 && s->channels == assignment+1)
 444         decorrelation = INDEPENDENT;
 445     else if (assignment >=8 && assignment < 11 && s->channels == 2)
 446         decorrelation = LEFT_SIDE + assignment - 8;
 447     else
 448     {
 449         av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
 450         return -1;
 451     }
 452
 453     sample_size_code = get_bits(&s->gb, 3);
 454     if(sample_size_code == 0)
 455         bps= s->bps;
 456     else if((sample_size_code != 3) && (sample_size_code != 7))
 457         bps = sample_size_table[sample_size_code];
 458     else
 459     {
 460         av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
 461         return -1;
 462     }
 463
 464     if (get_bits1(&s->gb))
 465     {
 466         av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
 467         return -1;
 468     }
 469
 470     if(get_utf8(&s->gb) < 0){
 471         av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
 472         return -1;
 473     }
 474 #if 0
 475     if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
 476         (s->min_blocksize != s->max_blocksize)){
 477     }else{
 478     }
 479 #endif
 480
 481     if (blocksize_code == 0)
 482         blocksize = s->min_blocksize;
 483     else if (blocksize_code == 6)
 484         blocksize = get_bits(&s->gb, 8)+1;
 485     else if (blocksize_code == 7)
 486         blocksize = get_bits(&s->gb, 16)+1;
 487     else
 488         blocksize = blocksize_table[blocksize_code];
 489
 490     if(blocksize > s->max_blocksize){
 491         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
 492         return -1;
 493     }
 494
 495     if (sample_rate_code == 0){
 496         samplerate= s->samplerate;
 497     }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
 498         samplerate = sample_rate_table[sample_rate_code];
 499     else if (sample_rate_code == 12)
 500         samplerate = get_bits(&s->gb, 8) * 1000;
 501     else if (sample_rate_code == 13)
 502         samplerate = get_bits(&s->gb, 16);
 503     else if (sample_rate_code == 14)
 504         samplerate = get_bits(&s->gb, 16) * 10;
 505     else{
 506         av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
 507         return -1;
 508     }
 509
 510     skip_bits(&s->gb, 8);
 511     crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
 512     if(crc8){
 513         av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
 514         return -1;
 515     }
 516
 517     s->blocksize    = blocksize;
 518     s->samplerate   = samplerate;
 519     s->bps          = bps;
 520     s->decorrelation= decorrelation;
 521
 522 //    dump_headers(s);
 523
 524     /* subframes */
 525     for (i = 0; i < s->channels; i++)
 526     {
 527 //        av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
 528         if (decode_subframe(s, i) < 0)
 529             return -1;
 530     }
 531
 532     align_get_bits(&s->gb);
 533
 534     /* frame footer */
 535     skip_bits(&s->gb, 16); /* data crc */
 536
 537     return 0;
 538 }
 539
 540 static int flac_decode_frame(AVCodecContext *avctx,
 541                             void *data, int *data_size,
 542                             uint8_t *buf, int buf_size)
 543 {
 544     FLACContext *s = avctx->priv_data;
 545     int metadata_last, metadata_type, metadata_size;
 546     int tmp = 0, i, j = 0, input_buf_size;
 547     int16_t *samples = data, *left, *right;
 548
 549     *data_size = 0;
 550
 551     s->avctx = avctx;
 552
 553     if(s->max_framesize == 0){
 554         s->max_framesize= 8192; // should hopefully be enough for the first header
 555         s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
 556     }
 557
 558     if(1 && s->max_framesize){//FIXME truncated
 559             buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
 560             input_buf_size= buf_size;
 561
 562             if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
 563 //                printf("memmove\n");
 564                 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
 565                 s->bitstream_index=0;
 566             }
 567             memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
 568             buf= &s->bitstream[s->bitstream_index];
 569             buf_size += s->bitstream_size;
 570             s->bitstream_size= buf_size;
 571
 572             if(buf_size < s->max_framesize){
 573 //                printf("wanna more data ...\n");
 574                 return input_buf_size;
 575             }
 576     }
 577
 578     init_get_bits(&s->gb, buf, buf_size*8);
 579
 580     /* fLaC signature (be) */
 581     if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
 582     {
 583         skip_bits(&s->gb, 32);
 584
 585         av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
 586         do {
 587             metadata_last = get_bits(&s->gb, 1);
 588             metadata_type = get_bits(&s->gb, 7);
 589             metadata_size = get_bits_long(&s->gb, 24);
 590
 591             av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
 592                 metadata_last, metadata_type,
 593                 metadata_size);
 594             if(metadata_size){
 595                 switch(metadata_type)
 596                 {
 597                 case METADATA_TYPE_STREAMINFO:
 598                     metadata_streaminfo(s);
 599                     dump_headers(s);
 600                     break;
 601                 default:
 602                     for(i=0; i<metadata_size; i++)
 603                         skip_bits(&s->gb, 8);
 604                 }
 605             }
 606         } while(!metadata_last);
 607     }
 608     else
 609     {
 610
 611         tmp = show_bits(&s->gb, 16);
 612         if(tmp != 0xFFF8){
 613             av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
 614             while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
 615                 skip_bits(&s->gb, 8);
 616             goto end; // we may not have enough bits left to decode a frame, so try next time
 617         }
 618         skip_bits(&s->gb, 16);
 619         if (decode_frame(s) < 0){
 620             av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 621             s->bitstream_size=0;
 622             s->bitstream_index=0;
 623             return -1;
 624         }
 625     }
 626
 627
 628 #if 0
 629     /* fix the channel order here */
 630     if (s->order == MID_SIDE)
 631     {
 632         short *left = samples;
 633         short *right = samples + s->blocksize;
 634         for (i = 0; i < s->blocksize; i += 2)
 635         {
 636             uint32_t x = s->decoded[0][i];
 637             uint32_t y = s->decoded[0][i+1];
 638
 639             right[i] = x - (y / 2);
 640             left[i] = right[i] + y;
 641         }
 642         *data_size = 2 * s->blocksize;
 643     }
 644     else
 645     {
 646     for (i = 0; i < s->channels; i++)
 647     {
 648         switch(s->order)
 649         {
 650             case INDEPENDENT:
 651                 for (j = 0; j < s->blocksize; j++)
 652                     samples[(s->blocksize*i)+j] = s->decoded[i][j];
 653                 break;
 654             case LEFT_SIDE:
 655             case RIGHT_SIDE:
 656                 if (i == 0)
 657                     for (j = 0; j < s->blocksize; j++)
 658                         samples[(s->blocksize*i)+j] = s->decoded[0][j];
 659                 else
 660                     for (j = 0; j < s->blocksize; j++)
 661                         samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
 662                 break;
 663 //            case MID_SIDE:
 664 //                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
 665         }
 666         *data_size += s->blocksize;
 667     }
 668     }
 669 #else
 670     switch(s->decorrelation)
 671     {
 672         case INDEPENDENT:
 673             for (j = 0; j < s->blocksize; j++)
 674             {
 675                 for (i = 0; i < s->channels; i++)
 676                     *(samples++) = s->decoded[i][j];
 677             }
 678             break;
 679         case LEFT_SIDE:
 680             assert(s->channels == 2);
 681             for (i = 0; i < s->blocksize; i++)
 682             {
 683                 *(samples++) = s->decoded[0][i];
 684                 *(samples++) = s->decoded[0][i] - s->decoded[1][i];
 685             }
 686             break;
 687         case RIGHT_SIDE:
 688             assert(s->channels == 2);
 689             for (i = 0; i < s->blocksize; i++)
 690             {
 691                 *(samples++) = s->decoded[0][i] + s->decoded[1][i];
 692                 *(samples++) = s->decoded[1][i];
 693             }
 694             break;
 695         case MID_SIDE:
 696             assert(s->channels == 2);
 697             for (i = 0; i < s->blocksize; i++)
 698             {
 699                 int mid, side;
 700                 mid = s->decoded[0][i];
 701                 side = s->decoded[1][i];
 702
 703 #if 1 //needs to be checked but IMHO it should be binary identical
 704                 mid -= side>>1;
 705                 *(samples++) = mid + side;
 706                 *(samples++) = mid;
 707 #else
 708
 709                 mid <<= 1;
 710                 if (side & 1)
 711                     mid++;
 712                 *(samples++) = (mid + side) >> 1;
 713                 *(samples++) = (mid - side) >> 1;
 714 #endif
 715             }
 716             break;
 717     }
 718 #endif
 719
 720     *data_size = (int8_t *)samples - (int8_t *)data;
 721 //    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
 722
 723 //    s->last_blocksize = s->blocksize;
 724 end:
 725     i= (get_bits_count(&s->gb)+7)/8;;
 726     if(i > buf_size){
 727         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
 728         s->bitstream_size=0;
 729         s->bitstream_index=0;
 730         return -1;
 731     }
 732
 733     if(s->bitstream_size){
 734         s->bitstream_index += i;
 735         s->bitstream_size  -= i;
 736         return input_buf_size;
 737     }else
 738         return i;
 739 }
 740
 741 static int flac_decode_close(AVCodecContext *avctx)
 742 {
 743     FLACContext *s = avctx->priv_data;
 744     int i;
 745
 746     for (i = 0; i < s->channels; i++)
 747     {
 748         av_freep(&s->decoded[i]);
 749     }
 750     av_freep(&s->bitstream);
 751
 752     return 0;
 753 }
 754
 755 AVCodec flac_decoder = {
 756     "flac",
 757     CODEC_TYPE_AUDIO,
 758     CODEC_ID_FLAC,
 759     sizeof(FLACContext),
 760     flac_decode_init,
 761     NULL,
 762     flac_decode_close,
 763     flac_decode_frame,
 764 };