generic-library/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

shorten: K&R formatting cosmetics

Browse Source
This commit is contained in:
Luca Barbato 2013-03-05 16:11:28 +01:00
parent c10da30d84
commit a2ad554def
1 changed files with 112 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

217
libavcodec/shorten.c
View File

@ -108,10 +108,10 @@ typedef struct ShortenContext {
int got_quit_command; int got_quit_command;
} ShortenContext; } ShortenContext;
static av_cold int shorten_decode_init(AVCodecContext * avctx) static av_cold int shorten_decode_init(AVCodecContext *avctx)
{ {
ShortenContext *s = avctx->priv_data; ShortenContext *s = avctx->priv_data;
s->avctx = avctx; s->avctx = avctx;
avctx->sample_fmt = AV_SAMPLE_FMT_S16P; avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
return 0; return 0;
@ -123,17 +123,20 @@ static int allocate_buffers(ShortenContext *s)
int *coeffs; int *coeffs;
void *tmp_ptr; void *tmp_ptr;
for (chan=0; chan<s->channels; chan++) { for (chan = 0; chan < s->channels; chan++) {
if(FFMAX(1, s->nmean) >= UINT_MAX/sizeof(int32_t)){ if (FFMAX(1, s->nmean) >= UINT_MAX / sizeof(int32_t)) {
av_log(s->avctx, AV_LOG_ERROR, "nmean too large\n"); av_log(s->avctx, AV_LOG_ERROR, "nmean too large\n");
return -1; return -1;
} }
if(s->blocksize + s->nwrap >= UINT_MAX/sizeof(int32_t) || s->blocksize + s->nwrap <= (unsigned)s->nwrap){ if (s->blocksize + s->nwrap >= UINT_MAX / sizeof(int32_t) ||
av_log(s->avctx, AV_LOG_ERROR, "s->blocksize + s->nwrap too large\n"); s->blocksize + s->nwrap <= (unsigned)s->nwrap) {
av_log(s->avctx, AV_LOG_ERROR,
"s->blocksize + s->nwrap too large\n");
return -1; return -1;
} }
tmp_ptr = av_realloc(s->offset[chan], sizeof(int32_t)*FFMAX(1, s->nmean)); tmp_ptr =
av_realloc(s->offset[chan], sizeof(int32_t) * FFMAX(1, s->nmean));
if (!tmp_ptr) if (!tmp_ptr)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
s->offset[chan] = tmp_ptr; s->offset[chan] = tmp_ptr;
@ -143,7 +146,7 @@ static int allocate_buffers(ShortenContext *s)
if (!tmp_ptr) if (!tmp_ptr)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
s->decoded_base[chan] = tmp_ptr; s->decoded_base[chan] = tmp_ptr;
for (i=0; i<s->nwrap; i++) for (i = 0; i < s->nwrap; i++)
s->decoded_base[chan][i] = 0; s->decoded_base[chan][i] = 0;
s->decoded[chan] = s->decoded_base[chan] + s->nwrap; s->decoded[chan] = s->decoded_base[chan] + s->nwrap;
} }
@ -156,7 +159,6 @@ static int allocate_buffers(ShortenContext *s)
return 0; return 0;
} }
static inline unsigned int get_uint(ShortenContext *s, int k) static inline unsigned int get_uint(ShortenContext *s, int k)
{ {
if (s->version != 0) if (s->version != 0)
@ -164,7 +166,6 @@ static inline unsigned int get_uint(ShortenContext *s, int k)
return get_ur_golomb_shorten(&s->gb, k); return get_ur_golomb_shorten(&s->gb, k);
} }
static void fix_bitshift(ShortenContext *s, int32_t *buffer) static void fix_bitshift(ShortenContext *s, int32_t *buffer)
{ {
int i; int i;
@ -174,22 +175,20 @@ static void fix_bitshift(ShortenContext *s, int32_t *buffer)
buffer[i] <<= s->bitshift; buffer[i] <<= s->bitshift;
} }
static int init_offset(ShortenContext *s) static int init_offset(ShortenContext *s)
{ {
int32_t mean = 0; int32_t mean = 0;
int chan, i; int chan, i;
int nblock = FFMAX(1, s->nmean); int nblock = FFMAX(1, s->nmean);
/* initialise offset */ /* initialise offset */
switch (s->internal_ftype) switch (s->internal_ftype) {
{ case TYPE_S16HL:
case TYPE_S16HL: case TYPE_S16LH:
case TYPE_S16LH: mean = 0;
mean = 0; break;
break; default:
default: av_log(s->avctx, AV_LOG_ERROR, "unknown audio type");
av_log(s->avctx, AV_LOG_ERROR, "unknown audio type"); return AVERROR_INVALIDDATA;
return AVERROR_INVALIDDATA;
} }
for (chan = 0; chan < s->channels; chan++) for (chan = 0; chan < s->channels; chan++)
@ -204,21 +203,20 @@ static int decode_wave_header(AVCodecContext *avctx, const uint8_t *header,
int len; int len;
short wave_format; short wave_format;
if (bytestream_get_le32(&header) != MKTAG('R', 'I', 'F', 'F')) {
if (bytestream_get_le32(&header) != MKTAG('R','I','F','F')) {
av_log(avctx, AV_LOG_ERROR, "missing RIFF tag\n"); av_log(avctx, AV_LOG_ERROR, "missing RIFF tag\n");
return -1; return -1;
} }
header += 4; /* chunk size */; header += 4; /* chunk size */
if (bytestream_get_le32(&header) != MKTAG('W','A','V','E')) { if (bytestream_get_le32(&header) != MKTAG('W', 'A', 'V', 'E')) {
av_log(avctx, AV_LOG_ERROR, "missing WAVE tag\n"); av_log(avctx, AV_LOG_ERROR, "missing WAVE tag\n");
return -1; return -1;
} }
while (bytestream_get_le32(&header) != MKTAG('f','m','t',' ')) { while (bytestream_get_le32(&header) != MKTAG('f', 'm', 't', ' ')) {
len = bytestream_get_le32(&header); len = bytestream_get_le32(&header);
header += len; header += len;
} }
len = bytestream_get_le32(&header); len = bytestream_get_le32(&header);
@ -231,11 +229,11 @@ static int decode_wave_header(AVCodecContext *avctx, const uint8_t *header,
wave_format = bytestream_get_le16(&header); wave_format = bytestream_get_le16(&header);
switch (wave_format) { switch (wave_format) {
case WAVE_FORMAT_PCM: case WAVE_FORMAT_PCM:
break; break;
default: default:
av_log(avctx, AV_LOG_ERROR, "unsupported wave format\n"); av_log(avctx, AV_LOG_ERROR, "unsupported wave format\n");
return -1; return -1;
} }
header += 2; // skip channels (already got from shorten header) header += 2; // skip channels (already got from shorten header)
@ -284,11 +282,12 @@ static int decode_subframe_lpc(ShortenContext *s, int command, int channel,
/* read/validate prediction order */ /* read/validate prediction order */
pred_order = get_ur_golomb_shorten(&s->gb, LPCQSIZE); pred_order = get_ur_golomb_shorten(&s->gb, LPCQSIZE);
if (pred_order > s->nwrap) { if (pred_order > s->nwrap) {
av_log(s->avctx, AV_LOG_ERROR, "invalid pred_order %d\n", pred_order); av_log(s->avctx, AV_LOG_ERROR, "invalid pred_order %d\n",
pred_order);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
/* read LPC coefficients */ /* read LPC coefficients */
for (i=0; i<pred_order; i++) for (i = 0; i < pred_order; i++)
s->coeffs[i] = get_sr_golomb_shorten(&s->gb, LPCQUANT); s->coeffs[i] = get_sr_golomb_shorten(&s->gb, LPCQUANT);
coeffs = s->coeffs; coeffs = s->coeffs;
@ -296,7 +295,7 @@ static int decode_subframe_lpc(ShortenContext *s, int command, int channel,
} else { } else {
/* fixed LPC coeffs */ /* fixed LPC coeffs */
pred_order = command; pred_order = command;
coeffs = fixed_coeffs[pred_order-1]; coeffs = fixed_coeffs[pred_order - 1];
qshift = 0; qshift = 0;
} }
@ -307,11 +306,12 @@ static int decode_subframe_lpc(ShortenContext *s, int command, int channel,
/* decode residual and do LPC prediction */ /* decode residual and do LPC prediction */
init_sum = pred_order ? (command == FN_QLPC ? s->lpcqoffset : 0) : coffset; init_sum = pred_order ? (command == FN_QLPC ? s->lpcqoffset : 0) : coffset;
for (i=0; i < s->blocksize; i++) { for (i = 0; i < s->blocksize; i++) {
sum = init_sum; sum = init_sum;
for (j=0; j<pred_order; j++) for (j = 0; j < pred_order; j++)
sum += coeffs[j] * s->decoded[channel][i-j-1]; sum += coeffs[j] * s->decoded[channel][i - j - 1];
s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) + (sum >> qshift); s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) +
(sum >> qshift);
} }
/* add offset to current samples */ /* add offset to current samples */
@ -332,10 +332,10 @@ static int read_header(ShortenContext *s)
return -1; return -1;
} }
s->lpcqoffset = 0; s->lpcqoffset = 0;
s->blocksize = DEFAULT_BLOCK_SIZE; s->blocksize = DEFAULT_BLOCK_SIZE;
s->nmean = -1; s->nmean = -1;
s->version = get_bits(&s->gb, 8); s->version = get_bits(&s->gb, 8);
s->internal_ftype = get_uint(s, TYPESIZE); s->internal_ftype = get_uint(s, TYPESIZE);
s->channels = get_uint(s, CHANSIZE); s->channels = get_uint(s, CHANSIZE);
@ -352,19 +352,19 @@ static int read_header(ShortenContext *s)
blocksize = get_uint(s, av_log2(DEFAULT_BLOCK_SIZE)); blocksize = get_uint(s, av_log2(DEFAULT_BLOCK_SIZE));
if (!blocksize || blocksize > MAX_BLOCKSIZE) { if (!blocksize || blocksize > MAX_BLOCKSIZE) {
av_log(s->avctx, AV_LOG_ERROR, "invalid or unsupported block size: %d\n", av_log(s->avctx, AV_LOG_ERROR,
"invalid or unsupported block size: %d\n",
blocksize); blocksize);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
s->blocksize = blocksize; s->blocksize = blocksize;
maxnlpc = get_uint(s, LPCQSIZE); maxnlpc = get_uint(s, LPCQSIZE);
s->nmean = get_uint(s, 0); s->nmean = get_uint(s, 0);
skip_bytes = get_uint(s, NSKIPSIZE); skip_bytes = get_uint(s, NSKIPSIZE);
for (i=0; i<skip_bytes; i++) { for (i = 0; i < skip_bytes; i++)
skip_bits(&s->gb, 8); skip_bits(&s->gb, 8);
}
} }
s->nwrap = FFMAX(NWRAP, maxnlpc); s->nwrap = FFMAX(NWRAP, maxnlpc);
@ -378,17 +378,20 @@ static int read_header(ShortenContext *s)
s->lpcqoffset = V2LPCQOFFSET; s->lpcqoffset = V2LPCQOFFSET;
if (get_ur_golomb_shorten(&s->gb, FNSIZE) != FN_VERBATIM) { if (get_ur_golomb_shorten(&s->gb, FNSIZE) != FN_VERBATIM) {
av_log(s->avctx, AV_LOG_ERROR, "missing verbatim section at beginning of stream\n"); av_log(s->avctx, AV_LOG_ERROR,
"missing verbatim section at beginning of stream\n");
return -1; return -1;
} }
s->header_size = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE); s->header_size = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
if (s->header_size >= OUT_BUFFER_SIZE || s->header_size < CANONICAL_HEADER_SIZE) { if (s->header_size >= OUT_BUFFER_SIZE ||
av_log(s->avctx, AV_LOG_ERROR, "header is wrong size: %d\n", s->header_size); s->header_size < CANONICAL_HEADER_SIZE) {
av_log(s->avctx, AV_LOG_ERROR, "header is wrong size: %d\n",
s->header_size);
return -1; return -1;
} }
for (i=0; i<s->header_size; i++) for (i = 0; i < s->header_size; i++)
s->header[i] = (char)get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE); s->header[i] = (char)get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
if (decode_wave_header(s->avctx, s->header, s->header_size) < 0) if (decode_wave_header(s->avctx, s->header, s->header_size) < 0)
@ -407,15 +410,15 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
{ {
AVFrame *frame = data; AVFrame *frame = data;
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
ShortenContext *s = avctx->priv_data; ShortenContext *s = avctx->priv_data;
int i, input_buf_size = 0; int i, input_buf_size = 0;
int ret; int ret;
/* allocate internal bitstream buffer */ /* allocate internal bitstream buffer */
if(s->max_framesize == 0){ if (s->max_framesize == 0) {
void *tmp_ptr; void *tmp_ptr;
s->max_framesize= 1024; // should hopefully be enough for the first header s->max_framesize = 1024; // should hopefully be enough for the first header
tmp_ptr = av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, tmp_ptr = av_fast_realloc(s->bitstream, &s->allocated_bitstream_size,
s->max_framesize); s->max_framesize);
if (!tmp_ptr) { if (!tmp_ptr) {
@ -426,29 +429,32 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
} }
/* append current packet data to bitstream buffer */ /* append current packet data to bitstream buffer */
if(1 && s->max_framesize){//FIXME truncated if (1 && s->max_framesize) { //FIXME truncated
buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size); buf_size = FFMIN(buf_size, s->max_framesize - s->bitstream_size);
input_buf_size= buf_size; input_buf_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 >
memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size); s->allocated_bitstream_size) {
s->bitstream_index=0; memmove(s->bitstream, &s->bitstream[s->bitstream_index],
s->bitstream_size);
s->bitstream_index = 0;
} }
if (buf) if (buf)
memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size); memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf,
buf= &s->bitstream[s->bitstream_index]; buf_size);
buf_size += s->bitstream_size; buf = &s->bitstream[s->bitstream_index];
s->bitstream_size= buf_size; buf_size += s->bitstream_size;
s->bitstream_size = buf_size;
/* do not decode until buffer has at least max_framesize bytes or /* do not decode until buffer has at least max_framesize bytes or
the end of the file has been reached */ * the end of the file has been reached */
if (buf_size < s->max_framesize && avpkt->data) { if (buf_size < s->max_framesize && avpkt->data) {
*got_frame_ptr = 0; *got_frame_ptr = 0;
return input_buf_size; return input_buf_size;
} }
} }
/* init and position bitstream reader */ /* init and position bitstream reader */
init_get_bits(&s->gb, buf, buf_size*8); init_get_bits(&s->gb, buf, buf_size * 8);
skip_bits(&s->gb, s->bitindex); skip_bits(&s->gb, s->bitindex);
/* process header or next subblock */ /* process header or next subblock */
@ -470,7 +476,7 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
unsigned cmd; unsigned cmd;
int len; int len;
if (get_bits_left(&s->gb) < 3+FNSIZE) { if (get_bits_left(&s->gb) < 3 + FNSIZE) {
*got_frame_ptr = 0; *got_frame_ptr = 0;
break; break;
} }
@ -486,32 +492,32 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
if (!is_audio_command[cmd]) { if (!is_audio_command[cmd]) {
/* process non-audio command */ /* process non-audio command */
switch (cmd) { switch (cmd) {
case FN_VERBATIM: case FN_VERBATIM:
len = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE); len = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
while (len--) { while (len--)
get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE); get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
} break;
break; case FN_BITSHIFT:
case FN_BITSHIFT: s->bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE);
s->bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE); break;
break; case FN_BLOCKSIZE: {
case FN_BLOCKSIZE: { int blocksize = get_uint(s, av_log2(s->blocksize));
int blocksize = get_uint(s, av_log2(s->blocksize)); if (blocksize > s->blocksize) {
if (blocksize > s->blocksize) { av_log(avctx, AV_LOG_ERROR,
av_log(avctx, AV_LOG_ERROR, "Increasing block size is not supported\n"); "Increasing block size is not supported\n");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
}
if (!blocksize || blocksize > MAX_BLOCKSIZE) {
av_log(avctx, AV_LOG_ERROR, "invalid or unsupported "
"block size: %d\n", blocksize);
return AVERROR(EINVAL);
}
s->blocksize = blocksize;
break;
} }
case FN_QUIT: if (!blocksize || blocksize > MAX_BLOCKSIZE) {
s->got_quit_command = 1; av_log(avctx, AV_LOG_ERROR, "invalid or unsupported "
break; "block size: %d\n", blocksize);
return AVERROR(EINVAL);
}
s->blocksize = blocksize;
break;
}
case FN_QUIT:
s->got_quit_command = 1;
break;
} }
if (cmd == FN_BLOCKSIZE || cmd == FN_QUIT) { if (cmd == FN_BLOCKSIZE || cmd == FN_QUIT) {
*got_frame_ptr = 0; *got_frame_ptr = 0;
@ -537,7 +543,7 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
coffset = s->offset[channel][0]; coffset = s->offset[channel][0];
else { else {
int32_t sum = (s->version < 2) ? 0 : s->nmean / 2; int32_t sum = (s->version < 2) ? 0 : s->nmean / 2;
for (i=0; i<s->nmean; i++) for (i = 0; i < s->nmean; i++)
sum += s->offset[channel][i]; sum += s->offset[channel][i];
coffset = sum / s->nmean; coffset = sum / s->nmean;
if (s->version >= 2) if (s->version >= 2)
@ -546,21 +552,22 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
/* decode samples for this channel */ /* decode samples for this channel */
if (cmd == FN_ZERO) { if (cmd == FN_ZERO) {
for (i=0; i<s->blocksize; i++) for (i = 0; i < s->blocksize; i++)
s->decoded[channel][i] = 0; s->decoded[channel][i] = 0;
} else { } else {
if ((ret = decode_subframe_lpc(s, cmd, channel, residual_size, coffset)) < 0) if ((ret = decode_subframe_lpc(s, cmd, channel,
residual_size, coffset)) < 0)
return ret; return ret;
} }
/* update means with info from the current block */ /* update means with info from the current block */
if (s->nmean > 0) { if (s->nmean > 0) {
int32_t sum = (s->version < 2) ? 0 : s->blocksize / 2; int32_t sum = (s->version < 2) ? 0 : s->blocksize / 2;
for (i=0; i<s->blocksize; i++) for (i = 0; i < s->blocksize; i++)
sum += s->decoded[channel][i]; sum += s->decoded[channel][i];
for (i=1; i<s->nmean; i++) for (i = 1; i < s->nmean; i++)
s->offset[channel][i-1] = s->offset[channel][i]; s->offset[channel][i - 1] = s->offset[channel][i];
if (s->version < 2) if (s->version < 2)
s->offset[channel][s->nmean - 1] = sum / s->blocksize; s->offset[channel][s->nmean - 1] = sum / s->blocksize;
@ -569,11 +576,11 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
} }
/* copy wrap samples for use with next block */ /* copy wrap samples for use with next block */
for (i=-s->nwrap; i<0; i++) for (i = -s->nwrap; i < 0; i++)
s->decoded[channel][i] = s->decoded[channel][i + s->blocksize]; s->decoded[channel][i] = s->decoded[channel][i + s->blocksize];
/* shift samples to add in unused zero bits which were removed /* shift samples to add in unused zero bits which were removed
during encoding */ * during encoding */
fix_bitshift(s, s->decoded[channel]); fix_bitshift(s, s->decoded[channel]);
/* if this is the last channel in the block, output the samples */ /* if this is the last channel in the block, output the samples */
@ -597,12 +604,12 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
*got_frame_ptr = 0; *got_frame_ptr = 0;
finish_frame: finish_frame:
s->bitindex = get_bits_count(&s->gb) - 8*((get_bits_count(&s->gb))/8); s->bitindex = get_bits_count(&s->gb) - 8 * (get_bits_count(&s->gb) / 8);
i= (get_bits_count(&s->gb))/8; i = get_bits_count(&s->gb) / 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) {