* @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>
#include "avcodec.h"
+#include "bitstream.h"
#include "golomb.h"
#undef NDEBUG
#define MAX_CHANNELS 8
#define MAX_BLOCKSIZE 65535
+#define FLAC_STREAMINFO_SIZE 34
enum decorrelation_type {
INDEPENDENT,
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 const uint8_t table_crc8[256] = {
0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
return val;
}
-static int get_crc8(uint8_t *buf, int count){
+#if 0
+static int skip_utf8(GetBitContext *gb)
+{
+ int ones=0, bytes;
+
+ while(get_bits1(gb))
+ ones++;
+
+ if (ones==0) bytes=0;
+ else if(ones==1) return -1;
+ else bytes= ones - 1;
+
+ skip_bits(gb, 7-ones);
+ while(bytes--){
+ const int tmp = get_bits(gb, 8);
+
+ if((tmp>>6) != 2)
+ return -1;
+ }
+ return 0;
+}
+#endif
+
+static int get_crc8(const uint8_t *buf, int count){
int crc=0;
int i;
return crc;
}
+static void metadata_streaminfo(FLACContext *s);
+static void dump_headers(FLACContext *s);
+
static int flac_decode_init(AVCodecContext * avctx)
{
+ FLACContext *s = avctx->priv_data;
+ s->avctx = avctx;
+
+ /* initialize based on the demuxer-supplied streamdata header */
+ if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
+ init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
+ metadata_streaminfo(s);
+ dump_headers(s);
+ }
+
return 0;
}
}
s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
-// s->bitstream= av_realloc(s->bitstream, s->max_framesize);
}
static void metadata_streaminfo(FLACContext *s)
// 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);
- if(get_bits_count(&s->gb) > s->gb.size_in_bits){
- av_log(s->avctx, AV_LOG_ERROR, "fucking FLAC\n");
- return -1;
- }
}
}
i= 0;
static int decode_frame(FLACContext *s)
{
int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
+ int decorrelation, bps, blocksize, samplerate;
blocksize_code = get_bits(&s->gb, 4);
sample_rate_code = get_bits(&s->gb, 4);
assignment = get_bits(&s->gb, 4); /* channel assignment */
- if (assignment < 8)
- {
- s->decorrelation = INDEPENDENT;
- if (s->channels != assignment+1)
- av_log(s->avctx, AV_LOG_DEBUG, "channel number and number of assigned channels differ!\n");
-// av_log(s->avctx, AV_LOG_DEBUG, "channels: %d\n", assignment+1);
- }
- else if (assignment < 11)
- {
- s->decorrelation= LEFT_SIDE + assignment - 8;
- }
+ if (assignment < 8 && s->channels == assignment+1)
+ decorrelation = INDEPENDENT;
+ else if (assignment >=8 && assignment < 11 && s->channels == 2)
+ decorrelation = LEFT_SIDE + assignment - 8;
else
{
- av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment\n");
- return -1;
- }
-
- if ((assignment >= 8) && (s->channels != 2))
- {
+ av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
return -1;
}
sample_size_code = get_bits(&s->gb, 3);
- if (sample_size_code != 0)
- s->bps = sample_size_table[sample_size_code];
-
- if ((sample_size_code == 3) || (sample_size_code == 7))
+ if(sample_size_code == 0)
+ bps= s->bps;
+ else if((sample_size_code != 3) && (sample_size_code != 7))
+ bps = sample_size_table[sample_size_code];
+ else
{
av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
return -1;
if (get_bits1(&s->gb))
{
av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
-// return -1;
+ return -1;
}
+ if(get_utf8(&s->gb) < 0){
+ av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
+ return -1;
+ }
+#if 0
if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
(s->min_blocksize != s->max_blocksize)){
- if(get_utf8(&s->gb) < 0){
- av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
- return -1;
- }
}else{
- if(get_utf8(&s->gb) < 0){
- av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
- return -1;
- }
}
-
+#endif
+
if (blocksize_code == 0)
- s->blocksize = s->min_blocksize;
- else if (blocksize_code == 1)
- s->blocksize = 192;
- else if (blocksize_code <= 5)
- s->blocksize = 576 << (blocksize_code - 2);
+ blocksize = s->min_blocksize;
else if (blocksize_code == 6)
- s->blocksize = get_bits(&s->gb, 8)+1;
+ blocksize = get_bits(&s->gb, 8)+1;
else if (blocksize_code == 7)
- s->blocksize = get_bits(&s->gb, 16)+1;
- else if (blocksize_code >= 8)
- s->blocksize = 256 << (blocksize_code - 8);
+ blocksize = get_bits(&s->gb, 16)+1;
+ else
+ blocksize = blocksize_table[blocksize_code];
- if(s->blocksize > s->max_blocksize){
- av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", s->blocksize, s->max_blocksize);
+ if(blocksize > s->max_blocksize){
+ av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
return -1;
}
if (sample_rate_code == 0){
- //Streaminfo
+ samplerate= s->samplerate;
}else if ((sample_rate_code > 3) && (sample_rate_code < 12))
- s->samplerate = sample_rate_table[sample_rate_code];
+ samplerate = sample_rate_table[sample_rate_code];
else if (sample_rate_code == 12)
- s->samplerate = get_bits(&s->gb, 8) * 1000;
+ samplerate = get_bits(&s->gb, 8) * 1000;
else if (sample_rate_code == 13)
- s->samplerate = get_bits(&s->gb, 16);
+ samplerate = get_bits(&s->gb, 16);
else if (sample_rate_code == 14)
- s->samplerate = get_bits(&s->gb, 16) * 10;
+ samplerate = get_bits(&s->gb, 16) * 10;
else{
av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
return -1;
skip_bits(&s->gb, 8);
crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
if(crc8){
- av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
+ av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
return -1;
}
+
+ s->blocksize = blocksize;
+ s->samplerate = samplerate;
+ s->bps = bps;
+ s->decorrelation= decorrelation;
// dump_headers(s);
{
FLACContext *s = avctx->priv_data;
int metadata_last, metadata_type, metadata_size;
- int tmp = 0, i, j = 0, input_buf_size;
- int16_t *samples = data, *left, *right;
+ int tmp = 0, i, j = 0, input_buf_size = 0;
+ int16_t *samples = data;
- *data_size = 0;
-
- s->avctx = avctx;
-
if(s->max_framesize == 0){
- s->max_framesize= 8192; // should hopefully be enough for the first header
+ s->max_framesize= 65536; // should hopefully be enough for the first header
s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
}
if(1 && s->max_framesize){//FIXME truncated
- buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
+ buf_size= FFMAX(FFMIN(buf_size, s->max_framesize - s->bitstream_size), 0);
input_buf_size= buf_size;
if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
if(metadata_size){
switch(metadata_type)
{
- case METADATA_TYPE_STREAMINFO:
+ case METADATA_TYPE_STREAMINFO:{
metadata_streaminfo(s);
+
+ /* Buffer might have been reallocated, reinit bitreader */
+ if(buf != &s->bitstream[s->bitstream_index])
+ {
+ int bits_count = get_bits_count(&s->gb);
+ buf= &s->bitstream[s->bitstream_index];
+ init_get_bits(&s->gb, buf, buf_size*8);
+ skip_bits(&s->gb, bits_count);
+ }
+
dump_headers(s);
- break;
+ break;}
default:
for(i=0; i<metadata_size; i++)
skip_bits(&s->gb, 8);
return 0;
}
+static void flac_flush(AVCodecContext *avctx){
+ FLACContext *s = avctx->priv_data;
+
+ s->bitstream_size=
+ s->bitstream_index= 0;
+}
+
AVCodec flac_decoder = {
"flac",
CODEC_TYPE_AUDIO,
NULL,
flac_decode_close,
flac_decode_frame,
+ .flush= flac_flush,
};