/* * FLAC (Free Lossless Audio Codec) decoder * Copyright (c) 2003 Alex Beregszaszi * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *//** * @file flac.c * FLAC (Free Lossless Audio Codec) decoder * @author Alex Beregszaszi * * For more information on the FLAC format, visit: *  http://flac.sourceforge.net/ * * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed * through, starting from the initial 'fLaC' signature; or by passing the * 34-byte streaminfo structure through avctx->extradata[_size] followed * by data starting with the 0xFFF8 marker. */#include <limits.h>#define ALT_BITSTREAM_READER#include "avcodec.h"#include "bitstream.h"#include "golomb.h"#include "crc.h"#undef NDEBUG#include <assert.h>#define MAX_CHANNELS 8#define MAX_BLOCKSIZE 65535#define FLAC_STREAMINFO_SIZE 34enum decorrelation_type {    INDEPENDENT,    LEFT_SIDE,    RIGHT_SIDE,    MID_SIDE,};typedef struct FLACContext {    AVCodecContext *avctx;    GetBitContext gb;    int min_blocksize, max_blocksize;    int min_framesize, max_framesize;    int samplerate, channels;    int blocksize/*, last_blocksize*/;    int bps, curr_bps;    enum decorrelation_type decorrelation;    int32_t *decoded[MAX_CHANNELS];    uint8_t *bitstream;    int bitstream_size;    int bitstream_index;    unsigned int allocated_bitstream_size;} FLACContext;#define METADATA_TYPE_STREAMINFO 0static int sample_rate_table[] ={ 0, 0, 0, 0,  8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,  0, 0, 0, 0 };static int sample_size_table[] ={ 0, 8, 12, 0, 16, 20, 24, 0 };static int blocksize_table[] = {     0,    192, 576<<0, 576<<1, 576<<2, 576<<3,      0,      0,256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7};static int64_t get_utf8(GetBitContext *gb){    int64_t val;    GET_UTF8(val, get_bits(gb, 8), return -1;)    return val;}static void metadata_streaminfo(FLACContext *s);static void allocate_buffers(FLACContext *s);static int metadata_parse(FLACContext *s);static int flac_decode_init(AVCodecContext * avctx){    FLACContext *s = avctx->priv_data;    s->avctx = avctx;    if (avctx->extradata_size > 4) {        /* initialize based on the demuxer-supplied streamdata header */        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);        if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {            metadata_streaminfo(s);            allocate_buffers(s);        } else {            metadata_parse(s);        }    }    return 0;}static void dump_headers(FLACContext *s){    av_log(s->avctx, AV_LOG_DEBUG, "  Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);    av_log(s->avctx, AV_LOG_DEBUG, "  Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);    av_log(s->avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);    av_log(s->avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);    av_log(s->avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);}static void allocate_buffers(FLACContext *s){    int i;    assert(s->max_blocksize);    if(s->max_framesize == 0 && s->max_blocksize){        s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead    }    for (i = 0; i < s->channels; i++)    {        s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);    }    s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);}static void metadata_streaminfo(FLACContext *s){    /* mandatory streaminfo */    s->min_blocksize = get_bits(&s->gb, 16);    s->max_blocksize = get_bits(&s->gb, 16);    s->min_framesize = get_bits_long(&s->gb, 24);    s->max_framesize = get_bits_long(&s->gb, 24);    s->samplerate = get_bits_long(&s->gb, 20);    s->channels = get_bits(&s->gb, 3) + 1;    s->bps = get_bits(&s->gb, 5) + 1;    s->avctx->channels = s->channels;    s->avctx->sample_rate = s->samplerate;    skip_bits(&s->gb, 36); /* total num of samples */    skip_bits(&s->gb, 64); /* md5 sum */    skip_bits(&s->gb, 64); /* md5 sum */    dump_headers(s);}/** * Parse a list of metadata blocks. This list of blocks must begin with * the fLaC marker. * @param s the flac decoding context containing the gb bit reader used to *          parse metadata * @return 1 if some metadata was read, 0 if no fLaC marker was found */static int metadata_parse(FLACContext *s){    int i, metadata_last, metadata_type, metadata_size, streaminfo_updated=0;    if (show_bits_long(&s->gb, 32) == MKBETAG('f','L','a','C')) {        skip_bits(&s->gb, 32);        av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");        do {            metadata_last = get_bits1(&s->gb);            metadata_type = get_bits(&s->gb, 7);            metadata_size = get_bits_long(&s->gb, 24);            av_log(s->avctx, AV_LOG_DEBUG,                   " metadata block: flag = %d, type = %d, size = %d\n",                   metadata_last, metadata_type, metadata_size);            if (metadata_size) {                switch (metadata_type) {                case METADATA_TYPE_STREAMINFO:                    metadata_streaminfo(s);                    streaminfo_updated = 1;                    break;                default:                    for (i=0; i<metadata_size; i++)                        skip_bits(&s->gb, 8);                }            }        } while (!metadata_last);        if (streaminfo_updated)            allocate_buffers(s);        return 1;    }    return 0;}static int decode_residuals(FLACContext *s, int channel, int pred_order){    int i, tmp, partition, method_type, rice_order;    int sample = 0, samples;    method_type = get_bits(&s->gb, 2);    if (method_type > 1){        av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);        return -1;    }    rice_order = get_bits(&s->gb, 4);    samples= s->blocksize >> rice_order;    if (pred_order > samples) {        av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n", pred_order, samples);        return -1;    }    sample=    i= pred_order;    for (partition = 0; partition < (1 << rice_order); partition++)    {        tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);        if (tmp == (method_type == 0 ? 15 : 31))        {            av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");            tmp = get_bits(&s->gb, 5);            for (; i < samples; i++, sample++)                s->decoded[channel][sample] = get_sbits(&s->gb, tmp);        }        else        {//            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);            for (; i < samples; i++, sample++){                s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);            }        }        i= 0;    }//    av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);    return 0;}static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order){    const int blocksize = s->blocksize;    int32_t *decoded = s->decoded[channel];    int a, b, c, d, i;//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");    /* warm up samples *///    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);    for (i = 0; i < pred_order; i++)    {        decoded[i] = get_sbits(&s->gb, s->curr_bps);//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);    }    if (decode_residuals(s, channel, pred_order) < 0)        return -1;    a = decoded[pred_order-1];    b = a - decoded[pred_order-2];    c = b - decoded[pred_order-2] + decoded[pred_order-3];    d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];    switch(pred_order)    {        case 0:            break;        case 1:            for (i = pred_order; i < blocksize; i++)                decoded[i] = a += decoded[i];            break;        case 2:            for (i = pred_order; i < blocksize; i++)                decoded[i] = a += b += decoded[i];            break;        case 3:            for (i = pred_order; i < blocksize; i++)                decoded[i] = a += b += c += decoded[i];            break;        case 4:            for (i = pred_order; i < blocksize; i++)                decoded[i] = a += b += c += d += decoded[i];            break;        default:            av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);            return -1;    }    return 0;}static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order){    int i, j;    int coeff_prec, qlevel;    int coeffs[pred_order];    int32_t *decoded = s->decoded[channel];//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");    /* warm up samples *///    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);    for (i = 0; i < pred_order; i++)    {        decoded[i] = get_sbits(&s->gb, s->curr_bps);//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, decoded[i]);    }    coeff_prec = get_bits(&s->gb, 4) + 1;    if (coeff_prec == 16)    {        av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");        return -1;    }//    av_log(s->avctx, AV_LOG_DEBUG, "   qlp coeff prec: %d\n", coeff_prec);    qlevel = get_sbits(&s->gb, 5);//    av_log(s->avctx, AV_LOG_DEBUG, "   quant level: %d\n", qlevel);    if(qlevel < 0){        av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);        return -1;    }    for (i = 0; i < pred_order; i++)    {        coeffs[i] = get_sbits(&s->gb, coeff_prec);//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);    }    if (decode_residuals(s, channel, pred_order) < 0)        return -1;    if (s->bps > 16) {        int64_t sum;        for (i = pred_order; i < s->blocksize; i++)        {            sum = 0;            for (j = 0; j < pred_order; j++)                sum += (int64_t)coeffs[j] * decoded[i-j-1];            decoded[i] += sum >> qlevel;        }    } else {        for (i = pred_order; i < s->blocksize-1; i += 2)        {            int c;            int d = decoded[i-pred_order];            int s0 = 0, s1 = 0;            for (j = pred_order-1; j > 0; j--)            {                c = coeffs[j];                s0 += c*d;                d = decoded[i-j];                s1 += c*d;            }            c = coeffs[0];            s0 += c*d;            d = decoded[i] += s0 >> qlevel;            s1 += c*d;            decoded[i+1] += s1 >> qlevel;        }        if (i < s->blocksize)        {            int sum = 0;            for (j = 0; j < pred_order; j++)                sum += coeffs[j] * decoded[i-j-1];