Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

flacdec: cosmetics: use consistent coding style (K&R)

Browse Source 
Originally committed as revision 16761 to svn://svn.ffmpeg.org/ffmpeg/trunk
pull/126/head
Justin Ruggles 16 years ago
parent 62560865ff
commit 1bec121f9e
1 changed files with 106 additions and 137 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 243
      libavcodec/flacdec.c

243
libavcodec/flacdec.c
Unescape View File

@ -89,7 +89,8 @@ static const int blocksize_table[] = {
256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
}; };
static int64_t get_utf8(GetBitContext *gb){ static int64_t get_utf8(GetBitContext *gb)
{
int64_t val; int64_t val;
GET_UTF8(val, get_bits(gb, 8), return -1;) GET_UTF8(val, get_bits(gb, 8), return -1;)
return val; return val;
@ -98,7 +99,7 @@ static int64_t get_utf8(GetBitContext *gb){
static void allocate_buffers(FLACContext *s); static void allocate_buffers(FLACContext *s);
static int metadata_parse(FLACContext *s); static int metadata_parse(FLACContext *s);
static av_cold int flac_decode_init(AVCodecContext * avctx) static av_cold int flac_decode_init(AVCodecContext *avctx)
{ {
FLACContext *s = avctx->priv_data; FLACContext *s = avctx->priv_data;
s->avctx = avctx; s->avctx = avctx;
@ -127,21 +128,21 @@ static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps); av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
} }
static void allocate_buffers(FLACContext *s){ static void allocate_buffers(FLACContext *s)
{
int i; int i;
assert(s->max_blocksize); assert(s->max_blocksize);
if(s->max_framesize == 0 && 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 s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
} }
for (i = 0; i < s->channels; i++) for (i = 0; i < s->channels; i++) {
{
s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize); s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
} }
if(s->allocated_bitstream_size < s->max_framesize) if (s->allocated_bitstream_size < s->max_framesize)
s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize); s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
} }
@ -193,7 +194,7 @@ static int metadata_parse(FLACContext *s)
metadata_type = get_bits(&s->gb, 7); metadata_type = get_bits(&s->gb, 7);
metadata_size = get_bits_long(&s->gb, 24); metadata_size = get_bits_long(&s->gb, 24);
if(get_bits_count(&s->gb) + 8*metadata_size > s->gb.size_in_bits){ if (get_bits_count(&s->gb) + 8*metadata_size > s->gb.size_in_bits) {
skip_bits_long(&s->gb, initial_pos - get_bits_count(&s->gb)); skip_bits_long(&s->gb, initial_pos - get_bits_count(&s->gb));
break; break;
} }
@ -205,7 +206,7 @@ static int metadata_parse(FLACContext *s)
streaminfo_updated = 1; streaminfo_updated = 1;
default: default:
for (i=0; i<metadata_size; i++) for (i = 0; i < metadata_size; i++)
skip_bits(&s->gb, 8); skip_bits(&s->gb, 8);
} }
} }
@ -224,7 +225,7 @@ static int decode_residuals(FLACContext *s, int channel, int pred_order)
int sample = 0, samples; int sample = 0, samples;
method_type = get_bits(&s->gb, 2); method_type = get_bits(&s->gb, 2);
if (method_type > 1){ if (method_type > 1) {
av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n", method_type); av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n", method_type);
return -1; return -1;
} }
@ -239,18 +240,14 @@ static int decode_residuals(FLACContext *s, int channel, int pred_order)
sample= sample=
i= pred_order; i= pred_order;
for (partition = 0; partition < (1 << rice_order); partition++) for (partition = 0; partition < (1 << rice_order); partition++) {
{
tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5); tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
if (tmp == (method_type == 0 ? 15 : 31)) if (tmp == (method_type == 0 ? 15 : 31)) {
{
tmp = get_bits(&s->gb, 5); tmp = get_bits(&s->gb, 5);
for (; i < samples; i++, sample++) for (; i < samples; i++, sample++)
s->decoded[channel][sample] = get_sbits(&s->gb, tmp); s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
} } else {
else for (; i < samples; i++, sample++) {
{
for (; i < samples; i++, sample++){
s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0); s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
} }
} }
@ -267,46 +264,44 @@ static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
int a, b, c, d, i; int a, b, c, d, i;
/* warm up samples */ /* warm up samples */
for (i = 0; i < pred_order; i++) for (i = 0; i < pred_order; i++) {
{
decoded[i] = get_sbits(&s->gb, s->curr_bps); decoded[i] = get_sbits(&s->gb, s->curr_bps);
} }
if (decode_residuals(s, channel, pred_order) < 0) if (decode_residuals(s, channel, pred_order) < 0)
return -1; return -1;
if(pred_order > 0) if (pred_order > 0)
a = decoded[pred_order-1]; a = decoded[pred_order-1];
if(pred_order > 1) if (pred_order > 1)
b = a - decoded[pred_order-2]; b = a - decoded[pred_order-2];
if(pred_order > 2) if (pred_order > 2)
c = b - decoded[pred_order-2] + decoded[pred_order-3]; c = b - decoded[pred_order-2] + decoded[pred_order-3];
if(pred_order > 3) if (pred_order > 3)
d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4]; d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
switch(pred_order) switch (pred_order) {
{ case 0:
case 0: break;
break; case 1:
case 1: for (i = pred_order; i < blocksize; i++)
for (i = pred_order; i < blocksize; i++) decoded[i] = a += decoded[i];
decoded[i] = a += decoded[i]; break;
break; case 2:
case 2: for (i = pred_order; i < blocksize; i++)
for (i = pred_order; i < blocksize; i++) decoded[i] = a += b += decoded[i];
decoded[i] = a += b += decoded[i]; break;
break; case 3:
case 3: for (i = pred_order; i < blocksize; i++)
for (i = pred_order; i < blocksize; i++) decoded[i] = a += b += c += decoded[i];
decoded[i] = a += b += c += decoded[i]; break;
break; case 4:
case 4: for (i = pred_order; i < blocksize; i++)
for (i = pred_order; i < blocksize; i++) decoded[i] = a += b += c += d += decoded[i];
decoded[i] = a += b += c += d += decoded[i]; break;
break; default:
default: av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); return -1;
return -1;
} }
return 0; return 0;
@ -320,25 +315,22 @@ static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
int32_t *decoded = s->decoded[channel]; int32_t *decoded = s->decoded[channel];
/* warm up samples */ /* warm up samples */
for (i = 0; i < pred_order; i++) for (i = 0; i < pred_order; i++) {
{
decoded[i] = get_sbits(&s->gb, s->curr_bps); decoded[i] = get_sbits(&s->gb, s->curr_bps);
} }
coeff_prec = get_bits(&s->gb, 4) + 1; coeff_prec = get_bits(&s->gb, 4) + 1;
if (coeff_prec == 16) if (coeff_prec == 16) {
{
av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n"); av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
return -1; return -1;
} }
qlevel = get_sbits(&s->gb, 5); qlevel = get_sbits(&s->gb, 5);
if(qlevel < 0){ if (qlevel < 0) {
av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n", qlevel); av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n", qlevel);
return -1; return -1;
} }
for (i = 0; i < pred_order; i++) for (i = 0; i < pred_order; i++) {
{
coeffs[i] = get_sbits(&s->gb, coeff_prec); coeffs[i] = get_sbits(&s->gb, coeff_prec);
} }
@ -347,21 +339,18 @@ static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
if (s->bps > 16) { if (s->bps > 16) {
int64_t sum; int64_t sum;
for (i = pred_order; i < s->blocksize; i++) for (i = pred_order; i < s->blocksize; i++) {
{
sum = 0; sum = 0;
for (j = 0; j < pred_order; j++) for (j = 0; j < pred_order; j++)
sum += (int64_t)coeffs[j] * decoded[i-j-1]; sum += (int64_t)coeffs[j] * decoded[i-j-1];
decoded[i] += sum >> qlevel; decoded[i] += sum >> qlevel;
} }
} else { } else {
for (i = pred_order; i < s->blocksize-1; i += 2) for (i = pred_order; i < s->blocksize-1; i += 2) {
{
int c; int c;
int d = decoded[i-pred_order]; int d = decoded[i-pred_order];
int s0 = 0, s1 = 0; int s0 = 0, s1 = 0;
for (j = pred_order-1; j > 0; j--) for (j = pred_order-1; j > 0; j--) {
{
c = coeffs[j]; c = coeffs[j];
s0 += c*d; s0 += c*d;
d = decoded[i-j]; d = decoded[i-j];
@ -373,8 +362,7 @@ static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
s1 += c*d; s1 += c*d;
decoded[i+1] += s1 >> qlevel; decoded[i+1] += s1 >> qlevel;
} }
if (i < s->blocksize) if (i < s->blocksize) {
{
int sum = 0; int sum = 0;
for (j = 0; j < pred_order; j++) for (j = 0; j < pred_order; j++)
sum += coeffs[j] * decoded[i-j-1]; sum += coeffs[j] * decoded[i-j-1];
@ -391,23 +379,21 @@ static inline int decode_subframe(FLACContext *s, int channel)
int i, tmp; int i, tmp;
s->curr_bps = s->bps; s->curr_bps = s->bps;
if(channel == 0){ if (channel == 0) {
if(s->decorrelation == RIGHT_SIDE) if (s->decorrelation == RIGHT_SIDE)
s->curr_bps++; s->curr_bps++;
}else{ } else {
if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE) if (s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
s->curr_bps++; s->curr_bps++;
} }
if (get_bits1(&s->gb)) if (get_bits1(&s->gb)) {
{
av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n"); av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
return -1; return -1;
} }
type = get_bits(&s->gb, 6); type = get_bits(&s->gb, 6);
if (get_bits1(&s->gb)) if (get_bits1(&s->gb)) {
{
wasted = 1; wasted = 1;
while (!get_bits1(&s->gb)) while (!get_bits1(&s->gb))
wasted++; wasted++;
@ -415,35 +401,25 @@ static inline int decode_subframe(FLACContext *s, int channel)
} }
//FIXME use av_log2 for types //FIXME use av_log2 for types
if (type == 0) if (type == 0) {
{
tmp = get_sbits(&s->gb, s->curr_bps); tmp = get_sbits(&s->gb, s->curr_bps);
for (i = 0; i < s->blocksize; i++) for (i = 0; i < s->blocksize; i++)
s->decoded[channel][i] = tmp; s->decoded[channel][i] = tmp;
} } else if (type == 1) {
else if (type == 1)
{
for (i = 0; i < s->blocksize; i++) for (i = 0; i < s->blocksize; i++)
s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps); s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
} } else if ((type >= 8) && (type <= 12)) {
else if ((type >= 8) && (type <= 12))
{
if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
return -1; return -1;
} } else if (type >= 32) {
else if (type >= 32)
{
if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
return -1; return -1;
} } else {
else
{
av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n"); av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
return -1; return -1;
} }
if (wasted) if (wasted) {
{
int i; int i;
for (i = 0; i < s->blocksize; i++) for (i = 0; i < s->blocksize; i++)
s->decoded[channel][i] <<= wasted; s->decoded[channel][i] <<= wasted;
@ -466,30 +442,27 @@ static int decode_frame(FLACContext *s, int alloc_data_size)
decorrelation = INDEPENDENT; decorrelation = INDEPENDENT;
else if (assignment >=8 && assignment < 11 && s->channels == 2) else if (assignment >=8 && assignment < 11 && s->channels == 2)
decorrelation = LEFT_SIDE + assignment - 8; decorrelation = LEFT_SIDE + assignment - 8;
else else {
{
av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels); av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
return -1; return -1;
} }
sample_size_code = get_bits(&s->gb, 3); sample_size_code = get_bits(&s->gb, 3);
if(sample_size_code == 0) if (sample_size_code == 0)
bps= s->bps; bps= s->bps;
else if((sample_size_code != 3) && (sample_size_code != 7)) else if ((sample_size_code != 3) && (sample_size_code != 7))
bps = sample_size_table[sample_size_code]; bps = sample_size_table[sample_size_code];
else else {
{
av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code); av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code);
return -1; return -1;
} }
if (get_bits1(&s->gb)) if (get_bits1(&s->gb)) {
{
av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n"); av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
return -1; return -1;
} }
if(get_utf8(&s->gb) < 0){ if (get_utf8(&s->gb) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n"); av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
return -1; return -1;
} }
@ -503,17 +476,17 @@ static int decode_frame(FLACContext *s, int alloc_data_size)
else else
blocksize = blocksize_table[blocksize_code]; blocksize = blocksize_table[blocksize_code];
if(blocksize > s->max_blocksize){ if (blocksize > s->max_blocksize) {
av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize); av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
return -1; return -1;
} }
if(blocksize * s->channels * sizeof(int16_t) > alloc_data_size) if (blocksize * s->channels * sizeof(int16_t) > alloc_data_size)
return -1; return -1;
if (sample_rate_code == 0){ if (sample_rate_code == 0)
samplerate= s->samplerate; samplerate= s->samplerate;
}else if (sample_rate_code < 12) else if (sample_rate_code < 12)
samplerate = sample_rate_table[sample_rate_code]; samplerate = sample_rate_table[sample_rate_code];
else if (sample_rate_code == 12) else if (sample_rate_code == 12)
samplerate = get_bits(&s->gb, 8) * 1000; samplerate = get_bits(&s->gb, 8) * 1000;
@ -521,7 +494,7 @@ static int decode_frame(FLACContext *s, int alloc_data_size)
samplerate = get_bits(&s->gb, 16); samplerate = get_bits(&s->gb, 16);
else if (sample_rate_code == 14) else if (sample_rate_code == 14)
samplerate = get_bits(&s->gb, 16) * 10; samplerate = get_bits(&s->gb, 16) * 10;
else{ else {
av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code); av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
return -1; return -1;
} }
@ -529,7 +502,7 @@ static int decode_frame(FLACContext *s, int alloc_data_size)
skip_bits(&s->gb, 8); skip_bits(&s->gb, 8);
crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
s->gb.buffer, get_bits_count(&s->gb)/8); s->gb.buffer, get_bits_count(&s->gb)/8);
if(crc8){ if (crc8) {
av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8); av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
return -1; return -1;
} }
@ -542,8 +515,7 @@ static int decode_frame(FLACContext *s, int alloc_data_size)
// dump_headers(s->avctx, (FLACStreaminfo *)s); // dump_headers(s->avctx, (FLACStreaminfo *)s);
/* subframes */ /* subframes */
for (i = 0; i < s->channels; i++) for (i = 0; i < s->channels; i++) {
{
if (decode_subframe(s, i) < 0) if (decode_subframe(s, i) < 0)
return -1; return -1;
} }
@ -567,23 +539,23 @@ static int flac_decode_frame(AVCodecContext *avctx,
*data_size=0; *data_size=0;
if(s->max_framesize == 0){ if (s->max_framesize == 0) {
s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header
s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize); s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
} }
if(1 && s->max_framesize){//FIXME truncated if (1 && s->max_framesize) { //FIXME truncated
if(s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C')) if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize)); buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
input_buf_size= buf_size; input_buf_size= buf_size;
if(s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index) if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
return -1; return -1;
if(s->allocated_bitstream_size < s->bitstream_size + buf_size) if (s->allocated_bitstream_size < s->bitstream_size + buf_size)
s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size); s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){ if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) {
memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size); memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
s->bitstream_index=0; s->bitstream_index=0;
} }
@ -592,25 +564,25 @@ static int flac_decode_frame(AVCodecContext *avctx,
buf_size += s->bitstream_size; buf_size += s->bitstream_size;
s->bitstream_size= buf_size; s->bitstream_size= buf_size;
if(buf_size < s->max_framesize && input_buf_size){ if (buf_size < s->max_framesize && input_buf_size) {
return input_buf_size; return input_buf_size;
} }
} }
init_get_bits(&s->gb, buf, buf_size*8); init_get_bits(&s->gb, buf, buf_size*8);
if(metadata_parse(s)) if (metadata_parse(s))
goto end; goto end;
tmp = show_bits(&s->gb, 16); tmp = show_bits(&s->gb, 16);
if((tmp & 0xFFFE) != 0xFFF8){ if ((tmp & 0xFFFE) != 0xFFF8) {
av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n"); av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
while(get_bits_count(&s->gb)/8+2 < buf_size && (show_bits(&s->gb, 16) & 0xFFFE) != 0xFFF8) while (get_bits_count(&s->gb)/8+2 < buf_size && (show_bits(&s->gb, 16) & 0xFFFE) != 0xFFF8)
skip_bits(&s->gb, 8); skip_bits(&s->gb, 8);
goto end; // we may not have enough bits left to decode a frame, so try next time goto end; // we may not have enough bits left to decode a frame, so try next time
} }
skip_bits(&s->gb, 16); skip_bits(&s->gb, 16);
if (decode_frame(s, alloc_data_size) < 0){ if (decode_frame(s, alloc_data_size) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n"); av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
s->bitstream_size=0; s->bitstream_size=0;
s->bitstream_index=0; s->bitstream_index=0;
@ -619,8 +591,7 @@ static int flac_decode_frame(AVCodecContext *avctx,
#define DECORRELATE(left, right)\ #define DECORRELATE(left, right)\
assert(s->channels == 2);\ assert(s->channels == 2);\
for (i = 0; i < s->blocksize; i++)\ for (i = 0; i < s->blocksize; i++) {\
{\
int a= s->decoded[0][i];\ int a= s->decoded[0][i];\
int b= s->decoded[1][i];\ int b= s->decoded[1][i];\
*samples++ = ((left) << (24 - s->bps)) >> 8;\ *samples++ = ((left) << (24 - s->bps)) >> 8;\
@ -628,39 +599,37 @@ static int flac_decode_frame(AVCodecContext *avctx,
}\ }\
break; break;
switch(s->decorrelation) switch (s->decorrelation) {
{ case INDEPENDENT:
case INDEPENDENT: for (j = 0; j < s->blocksize; j++) {
for (j = 0; j < s->blocksize; j++) for (i = 0; i < s->channels; i++)
{ *samples++ = (s->decoded[i][j] << (24 - s->bps)) >> 8;
for (i = 0; i < s->channels; i++) }
*samples++ = (s->decoded[i][j] << (24 - s->bps)) >> 8; break;
} case LEFT_SIDE:
break; DECORRELATE(a,a-b)
case LEFT_SIDE: case RIGHT_SIDE:
DECORRELATE(a,a-b) DECORRELATE(a+b,b)
case RIGHT_SIDE: case MID_SIDE:
DECORRELATE(a+b,b) DECORRELATE( (a-=b>>1) + b, a)
case MID_SIDE:
DECORRELATE( (a-=b>>1) + b, a)
} }
*data_size = (int8_t *)samples - (int8_t *)data; *data_size = (int8_t *)samples - (int8_t *)data;
end: end:
i= (get_bits_count(&s->gb)+7)/8; i= (get_bits_count(&s->gb)+7)/8;
if(i > buf_size){ if (i > buf_size) {
av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size); av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
s->bitstream_size=0; s->bitstream_size=0;
s->bitstream_index=0; s->bitstream_index=0;
return -1; return -1;
} }
if(s->bitstream_size){ if (s->bitstream_size) {
s->bitstream_index += i; s->bitstream_index += i;
s->bitstream_size -= i; s->bitstream_size -= i;
return input_buf_size; return input_buf_size;
}else } else
return i; return i;
} }
@ -669,8 +638,7 @@ static av_cold int flac_decode_close(AVCodecContext *avctx)
FLACContext *s = avctx->priv_data; FLACContext *s = avctx->priv_data;
int i; int i;
for (i = 0; i < s->channels; i++) for (i = 0; i < s->channels; i++) {
{
av_freep(&s->decoded[i]); av_freep(&s->decoded[i]);
} }
av_freep(&s->bitstream); av_freep(&s->bitstream);
@ -678,7 +646,8 @@ static av_cold int flac_decode_close(AVCodecContext *avctx)
return 0; return 0;
} }
static void flac_flush(AVCodecContext *avctx){ static void flac_flush(AVCodecContext *avctx)
{
FLACContext *s = avctx->priv_data; FLACContext *s = avctx->priv_data;
s->bitstream_size= s->bitstream_size=

Write Preview
Loading…
Cancel
Save