[deb_ffmpeg.git] / ffmpeg / libavcodec / flacdec.c

/*
 * 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 (Free Lossless Audio Codec) decoder
 * @author Alex Beregszaszi
 * @see 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>

#include "libavutil/avassert.h"
#include "libavutil/channel_layout.h"
#include "libavutil/crc.h"
#include "avcodec.h"
#include "internal.h"
#include "get_bits.h"
#include "bytestream.h"
#include "golomb.h"
#include "flac.h"
#include "flacdata.h"
#include "flacdsp.h"
#include "thread.h"
#include "unary.h"


typedef struct FLACContext {
    FLACSTREAMINFO

    AVCodecContext *avctx;                  ///< parent AVCodecContext
    GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame

    int blocksize;                          ///< number of samples in the current frame
    int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
    int ch_mode;                            ///< channel decorrelation type in the current frame
    int got_streaminfo;                     ///< indicates if the STREAMINFO has been read

    int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
    uint8_t *decoded_buffer;
    unsigned int decoded_buffer_size;

    FLACDSPContext dsp;
} FLACContext;

static int allocate_buffers(FLACContext *s);

static void flac_set_bps(FLACContext *s)
{
    enum AVSampleFormat req = s->avctx->request_sample_fmt;
    int need32 = s->bps > 16;
    int want32 = av_get_bytes_per_sample(req) > 2;
    int planar = av_sample_fmt_is_planar(req);

    if (need32 || want32) {
        if (planar)
            s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
        else
            s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
        s->sample_shift = 32 - s->bps;
    } else {
        if (planar)
            s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
        else
            s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
        s->sample_shift = 16 - s->bps;
    }
}

static av_cold int flac_decode_init(AVCodecContext *avctx)
{
    enum FLACExtradataFormat format;
    uint8_t *streaminfo;
    int ret;
    FLACContext *s = avctx->priv_data;
    s->avctx = avctx;

    /* for now, the raw FLAC header is allowed to be passed to the decoder as
       frame data instead of extradata. */
    if (!avctx->extradata)
        return 0;

    if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
        return AVERROR_INVALIDDATA;

    /* initialize based on the demuxer-supplied streamdata header */
    avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
    ret = allocate_buffers(s);
    if (ret < 0)
        return ret;
    flac_set_bps(s);
    ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
    s->got_streaminfo = 1;

    return 0;
}

static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
{
    av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
    av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
    av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
    av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
    av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
}

static int allocate_buffers(FLACContext *s)
{
    int buf_size;
    int ret;

    av_assert0(s->max_blocksize);

    buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
                                          AV_SAMPLE_FMT_S32P, 0);
    if (buf_size < 0)
        return buf_size;

    av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
    if (!s->decoded_buffer)
        return AVERROR(ENOMEM);

    ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
                                  s->decoded_buffer, s->channels,
                                  s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
    return ret < 0 ? ret : 0;
}

/**
 * Parse the STREAMINFO from an inline header.
 * @param s the flac decoding context
 * @param buf input buffer, starting with the "fLaC" marker
 * @param buf_size buffer size
 * @return non-zero if metadata is invalid
 */
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
{
    int metadata_type, metadata_size, ret;

    if (buf_size < FLAC_STREAMINFO_SIZE+8) {
        /* need more data */
        return 0;
    }
    flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
    if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
        metadata_size != FLAC_STREAMINFO_SIZE) {
        return AVERROR_INVALIDDATA;
    }
    avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
    ret = allocate_buffers(s);
    if (ret < 0)
        return ret;
    flac_set_bps(s);
    ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
    s->got_streaminfo = 1;

    return 0;
}

/**
 * Determine the size of an inline header.
 * @param buf input buffer, starting with the "fLaC" marker
 * @param buf_size buffer size
 * @return number of bytes in the header, or 0 if more data is needed
 */
static int get_metadata_size(const uint8_t *buf, int buf_size)
{
    int metadata_last, metadata_size;
    const uint8_t *buf_end = buf + buf_size;

    buf += 4;
    do {
        if (buf_end - buf < 4)
            return 0;
        flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
        buf += 4;
        if (buf_end - buf < metadata_size) {
            /* need more data in order to read the complete header */
            return 0;
        }
        buf += metadata_size;
    } while (!metadata_last);

    return buf_size - (buf_end - buf);
}

static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
{
    int i, tmp, partition, method_type, rice_order;
    int rice_bits, rice_esc;
    int samples;

    method_type = get_bits(&s->gb, 2);
    if (method_type > 1) {
        av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
               method_type);
        return AVERROR_INVALIDDATA;
    }

    rice_order = get_bits(&s->gb, 4);

    samples= s->blocksize >> rice_order;
    if (samples << rice_order != s->blocksize) {
        av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
               rice_order, s->blocksize);
        return AVERROR_INVALIDDATA;
    }

    if (pred_order > samples) {
        av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
               pred_order, samples);
        return AVERROR_INVALIDDATA;
    }

    rice_bits = 4 + method_type;
    rice_esc  = (1 << rice_bits) - 1;

    decoded += pred_order;
    i= pred_order;
    for (partition = 0; partition < (1 << rice_order); partition++) {
        tmp = get_bits(&s->gb, rice_bits);
        if (tmp == rice_esc) {
            tmp = get_bits(&s->gb, 5);
            for (; i < samples; i++)
                *decoded++ = get_sbits_long(&s->gb, tmp);
        } else {
            for (; i < samples; i++) {
                *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
            }
        }
        i= 0;
    }

    return 0;
}

static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
                                 int pred_order, int bps)
{
    const int blocksize = s->blocksize;
    int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
    int ret;

    /* warm up samples */
    for (i = 0; i < pred_order; i++) {
        decoded[i] = get_sbits_long(&s->gb, bps);
    }

    if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
        return ret;

    if (pred_order > 0)
        a = decoded[pred_order-1];
    if (pred_order > 1)
        b = a - decoded[pred_order-2];
    if (pred_order > 2)
        c = b - decoded[pred_order-2] + decoded[pred_order-3];
    if (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 AVERROR_INVALIDDATA;
    }

    return 0;
}

static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
                               int bps)
{
    int i, ret;
    int coeff_prec, qlevel;
    int coeffs[32];

    /* warm up samples */
    for (i = 0; i < pred_order; i++) {
        decoded[i] = get_sbits_long(&s->gb, bps);
    }

    coeff_prec = get_bits(&s->gb, 4) + 1;
    if (coeff_prec == 16) {
        av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
        return AVERROR_INVALIDDATA;
    }
    qlevel = get_sbits(&s->gb, 5);
    if (qlevel < 0) {
        av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
               qlevel);
        return AVERROR_INVALIDDATA;
    }

    for (i = 0; i < pred_order; i++) {
        coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
    }

    if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
        return ret;

    s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);

    return 0;
}

static inline int decode_subframe(FLACContext *s, int channel)
{
    int32_t *decoded = s->decoded[channel];
    int type, wasted = 0;
    int bps = s->bps;
    int i, tmp, ret;

    if (channel == 0) {
        if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
            bps++;
    } else {
        if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
            bps++;
    }

    if (get_bits1(&s->gb)) {
        av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
        return AVERROR_INVALIDDATA;
    }
    type = get_bits(&s->gb, 6);

    if (get_bits1(&s->gb)) {
        int left = get_bits_left(&s->gb);
        if ( left < 0 ||
            (left < bps && !show_bits_long(&s->gb, left)) ||
                           !show_bits_long(&s->gb, bps)) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "Invalid number of wasted bits > available bits (%d) - left=%d\n",
                   bps, left);
            return AVERROR_INVALIDDATA;
        }
        wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
        bps -= wasted;
    }
    if (bps > 32) {
        avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
        return AVERROR_PATCHWELCOME;
    }

//FIXME use av_log2 for types
    if (type == 0) {
        tmp = get_sbits_long(&s->gb, bps);
        for (i = 0; i < s->blocksize; i++)
            decoded[i] = tmp;
    } else if (type == 1) {
        for (i = 0; i < s->blocksize; i++)
            decoded[i] = get_sbits_long(&s->gb, bps);
    } else if ((type >= 8) && (type <= 12)) {
        if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
            return ret;
    } else if (type >= 32) {
        if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
            return ret;
    } else {
        av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
        return AVERROR_INVALIDDATA;
    }

    if (wasted) {
        int i;
        for (i = 0; i < s->blocksize; i++)
            decoded[i] <<= wasted;
    }

    return 0;
}

static int decode_frame(FLACContext *s)
{
    int i, ret;
    GetBitContext *gb = &s->gb;
    FLACFrameInfo fi;

    if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
        av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
        return ret;
    }

    if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
        s->channels = s->avctx->channels = fi.channels;
        ff_flac_set_channel_layout(s->avctx);
        ret = allocate_buffers(s);
        if (ret < 0)
            return ret;
    }
    s->channels = s->avctx->channels = fi.channels;
    if (!s->avctx->channel_layout)
        ff_flac_set_channel_layout(s->avctx);
    s->ch_mode = fi.ch_mode;

    if (!s->bps && !fi.bps) {
        av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
        return AVERROR_INVALIDDATA;
    }
    if (!fi.bps) {
        fi.bps = s->bps;
    } else if (s->bps && fi.bps != s->bps) {
        av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
                                       "supported\n");
        return AVERROR_INVALIDDATA;
    }

    if (!s->bps) {
        s->bps = s->avctx->bits_per_raw_sample = fi.bps;
        flac_set_bps(s);
    }

    if (!s->max_blocksize)
        s->max_blocksize = FLAC_MAX_BLOCKSIZE;
    if (fi.blocksize > s->max_blocksize) {
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
               s->max_blocksize);
        return AVERROR_INVALIDDATA;
    }
    s->blocksize = fi.blocksize;

    if (!s->samplerate && !fi.samplerate) {
        av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
                                        " or frame header\n");
        return AVERROR_INVALIDDATA;
    }
    if (fi.samplerate == 0)
        fi.samplerate = s->samplerate;
    s->samplerate = s->avctx->sample_rate = fi.samplerate;

    if (!s->got_streaminfo) {
        ret = allocate_buffers(s);
        if (ret < 0)
            return ret;
        ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
        s->got_streaminfo = 1;
        dump_headers(s->avctx, (FLACStreaminfo *)s);
    }

//    dump_headers(s->avctx, (FLACStreaminfo *)s);

    /* subframes */
    for (i = 0; i < s->channels; i++) {
        if ((ret = decode_subframe(s, i)) < 0)
            return ret;
    }

    align_get_bits(gb);

    /* frame footer */
    skip_bits(gb, 16); /* data crc */

    return 0;
}

static int flac_decode_frame(AVCodecContext *avctx, void *data,
                             int *got_frame_ptr, AVPacket *avpkt)
{
    AVFrame *frame     = data;
    ThreadFrame tframe = { .f = data };
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
    FLACContext *s = avctx->priv_data;
    int bytes_read = 0;
    int ret;

    *got_frame_ptr = 0;

    if (s->max_framesize == 0) {
        s->max_framesize =
            ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
                                       FLAC_MAX_CHANNELS, 32);
    }

    if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
        av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
        return buf_size;
    }

    if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
        av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
        return buf_size;
    }

    /* check that there is at least the smallest decodable amount of data.
       this amount corresponds to the smallest valid FLAC frame possible.
       FF F8 69 02 00 00 9A 00 00 34 46 */
    if (buf_size < FLAC_MIN_FRAME_SIZE)
        return buf_size;

    /* check for inline header */
    if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
        if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
            av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
            return ret;
        }
        return get_metadata_size(buf, buf_size);
    }

    /* decode frame */
    if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
        return ret;
    if ((ret = decode_frame(s)) < 0) {
        av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
        return ret;
    }
    bytes_read = get_bits_count(&s->gb)/8;

    if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
        av_crc(av_crc_get_table(AV_CRC_16_ANSI),
               0, buf, bytes_read)) {
        av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
        if (s->avctx->err_recognition & AV_EF_EXPLODE)
            return AVERROR_INVALIDDATA;
    }

    /* get output buffer */
    frame->nb_samples = s->blocksize;
    if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
        return ret;

    s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
                                   s->blocksize, s->sample_shift);

    if (bytes_read > buf_size) {
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
        return AVERROR_INVALIDDATA;
    }
    if (bytes_read < buf_size) {
        av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
               buf_size - bytes_read, buf_size);
    }

    *got_frame_ptr = 1;

    return bytes_read;
}

static int init_thread_copy(AVCodecContext *avctx)
{
    FLACContext *s = avctx->priv_data;
    s->decoded_buffer = NULL;
    s->decoded_buffer_size = 0;
    s->avctx = avctx;
    if (s->max_blocksize)
        return allocate_buffers(s);
    return 0;
}

static av_cold int flac_decode_close(AVCodecContext *avctx)
{
    FLACContext *s = avctx->priv_data;

    av_freep(&s->decoded_buffer);

    return 0;
}

AVCodec ff_flac_decoder = {
    .name           = "flac",
    .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_FLAC,
    .priv_data_size = sizeof(FLACContext),
    .init           = flac_decode_init,
    .close          = flac_decode_close,
    .decode         = flac_decode_frame,
    .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
                                                      AV_SAMPLE_FMT_S16P,
                                                      AV_SAMPLE_FMT_S32,
                                                      AV_SAMPLE_FMT_S32P,
                                                      AV_SAMPLE_FMT_NONE },
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* FLAC (Free Lossless Audio Codec) decoder
	3	* Copyright (c) 2003 Alex Beregszaszi
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	/**
	23	* @file
	24	* FLAC (Free Lossless Audio Codec) decoder
	25	* @author Alex Beregszaszi
	26	* @see 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 "libavutil/avassert.h"
	37	#include "libavutil/channel_layout.h"
	38	#include "libavutil/crc.h"
	39	#include "avcodec.h"
	40	#include "internal.h"
	41	#include "get_bits.h"
	42	#include "bytestream.h"
	43	#include "golomb.h"
	44	#include "flac.h"
	45	#include "flacdata.h"
	46	#include "flacdsp.h"
	47	#include "thread.h"
	48	#include "unary.h"
	49
	50
	51	typedef struct FLACContext {
	52	FLACSTREAMINFO
	53
	54	AVCodecContext *avctx; ///< parent AVCodecContext
	55	GetBitContext gb; ///< GetBitContext initialized to start at the current frame
	56
	57	int blocksize; ///< number of samples in the current frame
	58	int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
	59	int ch_mode; ///< channel decorrelation type in the current frame
	60	int got_streaminfo; ///< indicates if the STREAMINFO has been read
	61
	62	int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
	63	uint8_t *decoded_buffer;
	64	unsigned int decoded_buffer_size;
65
66	FLACDSPContext dsp;
67	} FLACContext;
68
69	static int allocate_buffers(FLACContext *s);
70
71	static void flac_set_bps(FLACContext *s)
72	{
73	enum AVSampleFormat req = s->avctx->request_sample_fmt;
74	int need32 = s->bps > 16;
75	int want32 = av_get_bytes_per_sample(req) > 2;
76	int planar = av_sample_fmt_is_planar(req);
77
78	if (need32 \|\| want32) {
79	if (planar)
80	s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
81	else
82	s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
83	s->sample_shift = 32 - s->bps;
84	} else {
85	if (planar)
86	s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
87	else
88	s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
89	s->sample_shift = 16 - s->bps;
90	}
91	}
92
93	static av_cold int flac_decode_init(AVCodecContext *avctx)
94	{
95	enum FLACExtradataFormat format;
96	uint8_t *streaminfo;
97	int ret;
98	FLACContext *s = avctx->priv_data;
99	s->avctx = avctx;
100
101	/* for now, the raw FLAC header is allowed to be passed to the decoder as
102	frame data instead of extradata. */
103	if (!avctx->extradata)
104	return 0;
105
106	if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
107	return AVERROR_INVALIDDATA;
108
109	/* initialize based on the demuxer-supplied streamdata header */
110	avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
111	ret = allocate_buffers(s);
112	if (ret < 0)
113	return ret;
114	flac_set_bps(s);
115	ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
116	s->got_streaminfo = 1;
117
118	return 0;
119	}
120
121	static void dump_headers(AVCodecContext avctx, FLACStreaminfo s)
122	{
123	av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
124	av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
125	av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
126	av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
127	av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
128	}
129
130	static int allocate_buffers(FLACContext *s)
131	{
132	int buf_size;
133	int ret;
134
135	av_assert0(s->max_blocksize);
136
137	buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
138	AV_SAMPLE_FMT_S32P, 0);
139	if (buf_size < 0)
140	return buf_size;
141
142	av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
143	if (!s->decoded_buffer)
144	return AVERROR(ENOMEM);
145
146	ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
147	s->decoded_buffer, s->channels,
148	s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
149	return ret < 0 ? ret : 0;
150	}
151
152	/**
153	* Parse the STREAMINFO from an inline header.
154	* @param s the flac decoding context
155	* @param buf input buffer, starting with the "fLaC" marker
156	* @param buf_size buffer size
157	* @return non-zero if metadata is invalid
158	*/
159	static int parse_streaminfo(FLACContext s, const uint8_t buf, int buf_size)
160	{
161	int metadata_type, metadata_size, ret;
162
163	if (buf_size < FLAC_STREAMINFO_SIZE+8) {
164	/* need more data */
165	return 0;
166	}
167	flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
168	if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO \|\|
169	metadata_size != FLAC_STREAMINFO_SIZE) {
170	return AVERROR_INVALIDDATA;
171	}
172	avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
173	ret = allocate_buffers(s);
174	if (ret < 0)
175	return ret;
176	flac_set_bps(s);
177	ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
178	s->got_streaminfo = 1;
179
180	return 0;
181	}
182
183	/**
184	* Determine the size of an inline header.
185	* @param buf input buffer, starting with the "fLaC" marker
186	* @param buf_size buffer size
187	* @return number of bytes in the header, or 0 if more data is needed
188	*/
189	static int get_metadata_size(const uint8_t *buf, int buf_size)
190	{
191	int metadata_last, metadata_size;
192	const uint8_t *buf_end = buf + buf_size;
193
194	buf += 4;
195	do {
196	if (buf_end - buf < 4)
197	return 0;
198	flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
199	buf += 4;
200	if (buf_end - buf < metadata_size) {
201	/* need more data in order to read the complete header */
202	return 0;
203	}
204	buf += metadata_size;
205	} while (!metadata_last);
206
207	return buf_size - (buf_end - buf);
208	}
209
210	static int decode_residuals(FLACContext s, int32_t decoded, int pred_order)
211	{
212	int i, tmp, partition, method_type, rice_order;
213	int rice_bits, rice_esc;
214	int samples;
215
216	method_type = get_bits(&s->gb, 2);
217	if (method_type > 1) {
218	av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
219	method_type);
220	return AVERROR_INVALIDDATA;
221	}
222
223	rice_order = get_bits(&s->gb, 4);
224
225	samples= s->blocksize >> rice_order;
226	if (samples << rice_order != s->blocksize) {
227	av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
228	rice_order, s->blocksize);
229	return AVERROR_INVALIDDATA;
230	}
231
232	if (pred_order > samples) {
233	av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
234	pred_order, samples);
235	return AVERROR_INVALIDDATA;
236	}
237
238	rice_bits = 4 + method_type;
239	rice_esc = (1 << rice_bits) - 1;
240
241	decoded += pred_order;
242	i= pred_order;
243	for (partition = 0; partition < (1 << rice_order); partition++) {
244	tmp = get_bits(&s->gb, rice_bits);
245	if (tmp == rice_esc) {
246	tmp = get_bits(&s->gb, 5);
247	for (; i < samples; i++)
248	*decoded++ = get_sbits_long(&s->gb, tmp);
249	} else {
250	for (; i < samples; i++) {
251	*decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
252	}
253	}
254	i= 0;
255	}
256
257	return 0;
258	}
259
260	static int decode_subframe_fixed(FLACContext s, int32_t decoded,
261	int pred_order, int bps)
262	{
263	const int blocksize = s->blocksize;
264	int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
265	int ret;
266
267	/* warm up samples */
268	for (i = 0; i < pred_order; i++) {
269	decoded[i] = get_sbits_long(&s->gb, bps);
270	}
271
272	if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
273	return ret;
274
275	if (pred_order > 0)
276	a = decoded[pred_order-1];
277	if (pred_order > 1)
278	b = a - decoded[pred_order-2];
279	if (pred_order > 2)
280	c = b - decoded[pred_order-2] + decoded[pred_order-3];
281	if (pred_order > 3)
282	d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
283
284	switch (pred_order) {
285	case 0:
286	break;
287	case 1:
288	for (i = pred_order; i < blocksize; i++)
289	decoded[i] = a += decoded[i];
290	break;
291	case 2:
292	for (i = pred_order; i < blocksize; i++)
293	decoded[i] = a += b += decoded[i];
294	break;
295	case 3:
296	for (i = pred_order; i < blocksize; i++)
297	decoded[i] = a += b += c += decoded[i];
298	break;
299	case 4:
300	for (i = pred_order; i < blocksize; i++)
301	decoded[i] = a += b += c += d += decoded[i];
302	break;
303	default:
304	av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
305	return AVERROR_INVALIDDATA;
306	}
307
308	return 0;
309	}
310
311	static int decode_subframe_lpc(FLACContext s, int32_t decoded, int pred_order,
312	int bps)
313	{
314	int i, ret;
315	int coeff_prec, qlevel;
316	int coeffs[32];
317
318	/* warm up samples */
319	for (i = 0; i < pred_order; i++) {
320	decoded[i] = get_sbits_long(&s->gb, bps);
321	}
322
323	coeff_prec = get_bits(&s->gb, 4) + 1;
324	if (coeff_prec == 16) {
325	av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
326	return AVERROR_INVALIDDATA;
327	}
328	qlevel = get_sbits(&s->gb, 5);
329	if (qlevel < 0) {
330	av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
331	qlevel);
332	return AVERROR_INVALIDDATA;
333	}
334
335	for (i = 0; i < pred_order; i++) {
336	coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
337	}
338
339	if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
340	return ret;
341
342	s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
343
344	return 0;
345	}
346
347	static inline int decode_subframe(FLACContext *s, int channel)
348	{
349	int32_t *decoded = s->decoded[channel];
350	int type, wasted = 0;
351	int bps = s->bps;
352	int i, tmp, ret;
353
354	if (channel == 0) {
355	if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
356	bps++;
357	} else {
358	if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE \|\| s->ch_mode == FLAC_CHMODE_MID_SIDE)
359	bps++;
360	}
361
362	if (get_bits1(&s->gb)) {
363	av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
364	return AVERROR_INVALIDDATA;
365	}
366	type = get_bits(&s->gb, 6);
367
368	if (get_bits1(&s->gb)) {
369	int left = get_bits_left(&s->gb);
370	if ( left < 0 \|\|
371	(left < bps && !show_bits_long(&s->gb, left)) \|\|
372	!show_bits_long(&s->gb, bps)) {
373	av_log(s->avctx, AV_LOG_ERROR,
374	"Invalid number of wasted bits > available bits (%d) - left=%d\n",
375	bps, left);
376	return AVERROR_INVALIDDATA;
377	}
378	wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
379	bps -= wasted;
380	}
381	if (bps > 32) {
382	avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
383	return AVERROR_PATCHWELCOME;
384	}
385
386	//FIXME use av_log2 for types
387	if (type == 0) {
388	tmp = get_sbits_long(&s->gb, bps);
389	for (i = 0; i < s->blocksize; i++)
390	decoded[i] = tmp;
391	} else if (type == 1) {
392	for (i = 0; i < s->blocksize; i++)
393	decoded[i] = get_sbits_long(&s->gb, bps);
394	} else if ((type >= 8) && (type <= 12)) {
395	if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
396	return ret;
397	} else if (type >= 32) {
398	if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
399	return ret;
400	} else {
401	av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
402	return AVERROR_INVALIDDATA;
403	}
404
405	if (wasted) {
406	int i;
407	for (i = 0; i < s->blocksize; i++)
408	decoded[i] <<= wasted;
409	}
410
411	return 0;
412	}
413
414	static int decode_frame(FLACContext *s)
415	{
416	int i, ret;
417	GetBitContext *gb = &s->gb;
418	FLACFrameInfo fi;
419
420	if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
421	av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
422	return ret;
423	}
424
425	if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
426	s->channels = s->avctx->channels = fi.channels;
427	ff_flac_set_channel_layout(s->avctx);
428	ret = allocate_buffers(s);
429	if (ret < 0)
430	return ret;
431	}
432	s->channels = s->avctx->channels = fi.channels;
433	if (!s->avctx->channel_layout)
434	ff_flac_set_channel_layout(s->avctx);
435	s->ch_mode = fi.ch_mode;
436
437	if (!s->bps && !fi.bps) {
438	av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
439	return AVERROR_INVALIDDATA;
440	}
441	if (!fi.bps) {
442	fi.bps = s->bps;
443	} else if (s->bps && fi.bps != s->bps) {
444	av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
445	"supported\n");
446	return AVERROR_INVALIDDATA;
447	}
448
449	if (!s->bps) {
450	s->bps = s->avctx->bits_per_raw_sample = fi.bps;
451	flac_set_bps(s);
452	}
453
454	if (!s->max_blocksize)
455	s->max_blocksize = FLAC_MAX_BLOCKSIZE;
456	if (fi.blocksize > s->max_blocksize) {
457	av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
458	s->max_blocksize);
459	return AVERROR_INVALIDDATA;
460	}
461	s->blocksize = fi.blocksize;
462
463	if (!s->samplerate && !fi.samplerate) {
464	av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
465	" or frame header\n");
466	return AVERROR_INVALIDDATA;
467	}
468	if (fi.samplerate == 0)
469	fi.samplerate = s->samplerate;
470	s->samplerate = s->avctx->sample_rate = fi.samplerate;
471
472	if (!s->got_streaminfo) {
473	ret = allocate_buffers(s);
474	if (ret < 0)
475	return ret;
476	ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
477	s->got_streaminfo = 1;
478	dump_headers(s->avctx, (FLACStreaminfo *)s);
479	}
480
481	// dump_headers(s->avctx, (FLACStreaminfo *)s);
482
483	/* subframes */
484	for (i = 0; i < s->channels; i++) {
485	if ((ret = decode_subframe(s, i)) < 0)
486	return ret;
487	}
488
489	align_get_bits(gb);
490
491	/* frame footer */
492	skip_bits(gb, 16); /* data crc */
493
494	return 0;
495	}
496
497	static int flac_decode_frame(AVCodecContext avctx, void data,
498	int got_frame_ptr, AVPacket avpkt)
499	{
500	AVFrame *frame = data;
501	ThreadFrame tframe = { .f = data };
502	const uint8_t *buf = avpkt->data;
503	int buf_size = avpkt->size;
504	FLACContext *s = avctx->priv_data;
505	int bytes_read = 0;
506	int ret;
507
508	*got_frame_ptr = 0;
509
510	if (s->max_framesize == 0) {
511	s->max_framesize =
512	ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
513	FLAC_MAX_CHANNELS, 32);
514	}
515
516	if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
517	av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
518	return buf_size;
519	}
520
521	if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
522	av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
523	return buf_size;
524	}
525
526	/* check that there is at least the smallest decodable amount of data.
527	this amount corresponds to the smallest valid FLAC frame possible.
528	FF F8 69 02 00 00 9A 00 00 34 46 */
529	if (buf_size < FLAC_MIN_FRAME_SIZE)
530	return buf_size;
531
532	/* check for inline header */
533	if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
534	if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
535	av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
536	return ret;
537	}
538	return get_metadata_size(buf, buf_size);
539	}
540
541	/* decode frame */
542	if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
543	return ret;
544	if ((ret = decode_frame(s)) < 0) {
545	av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
546	return ret;
547	}
548	bytes_read = get_bits_count(&s->gb)/8;
549
550	if ((s->avctx->err_recognition & (AV_EF_CRCCHECK\|AV_EF_COMPLIANT)) &&
551	av_crc(av_crc_get_table(AV_CRC_16_ANSI),
552	0, buf, bytes_read)) {
553	av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
554	if (s->avctx->err_recognition & AV_EF_EXPLODE)
555	return AVERROR_INVALIDDATA;
556	}
557
558	/* get output buffer */
559	frame->nb_samples = s->blocksize;
560	if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
561	return ret;
562
563	s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
564	s->blocksize, s->sample_shift);
565
566	if (bytes_read > buf_size) {
567	av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
568	return AVERROR_INVALIDDATA;
569	}
570	if (bytes_read < buf_size) {
571	av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
572	buf_size - bytes_read, buf_size);
573	}
574
575	*got_frame_ptr = 1;
576
577	return bytes_read;
578	}
579
580	static int init_thread_copy(AVCodecContext *avctx)
581	{
582	FLACContext *s = avctx->priv_data;
583	s->decoded_buffer = NULL;
584	s->decoded_buffer_size = 0;
585	s->avctx = avctx;
586	if (s->max_blocksize)
587	return allocate_buffers(s);
588	return 0;
589	}
590
591	static av_cold int flac_decode_close(AVCodecContext *avctx)
592	{
593	FLACContext *s = avctx->priv_data;
594
595	av_freep(&s->decoded_buffer);
596
597	return 0;
598	}
599
600	AVCodec ff_flac_decoder = {
601	.name = "flac",
602	.long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
603	.type = AVMEDIA_TYPE_AUDIO,
604	.id = AV_CODEC_ID_FLAC,
605	.priv_data_size = sizeof(FLACContext),
606	.init = flac_decode_init,
607	.close = flac_decode_close,
608	.decode = flac_decode_frame,
609	.init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
610	.capabilities = CODEC_CAP_DR1 \| CODEC_CAP_FRAME_THREADS,
611	.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
612	AV_SAMPLE_FMT_S16P,
613	AV_SAMPLE_FMT_S32,
614	AV_SAMPLE_FMT_S32P,
615	AV_SAMPLE_FMT_NONE },
616	};