virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-02 03:06:28 +02:00
Code Issues Releases Activity

Merge commit 'a2ad554def214d2d03b7c16f68dc081a8622f9ca'

Browse Source 
* commit 'a2ad554def214d2d03b7c16f68dc081a8622f9ca':
  shorten: K&R formatting cosmetics

Conflicts:
	libavcodec/shorten.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2013-03-06 23:39:52 +01:00
commit 09131ebb56
1 changed files with 117 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

226
libavcodec/shorten.c
View File

@ -112,10 +112,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;
return 0; return 0;
} }
@ -126,17 +126,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 AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
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 AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
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;
@ -146,7 +149,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;
} }
@ -159,7 +162,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)
@ -167,7 +169,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;
@ -177,26 +178,24 @@ 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_U8:
case TYPE_U8: s->avctx->sample_fmt = AV_SAMPLE_FMT_U8P;
s->avctx->sample_fmt = AV_SAMPLE_FMT_U8P; mean = 0x80;
mean = 0x80; break;
break; case TYPE_S16HL:
case TYPE_S16HL: case TYPE_S16LH:
case TYPE_S16LH: s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P; break;
break; default:
default: av_log(s->avctx, AV_LOG_ERROR, "unknown audio type\n");
av_log(s->avctx, AV_LOG_ERROR, "unknown audio type\n"); return AVERROR_PATCHWELCOME;
return AVERROR_PATCHWELCOME;
} }
for (chan = 0; chan < s->channels; chan++) for (chan = 0; chan < s->channels; chan++)
@ -212,21 +211,21 @@ static int decode_wave_header(AVCodecContext *avctx, const uint8_t *header,
short wave_format; short wave_format;
const uint8_t *end= header + header_size; const uint8_t *end= header + header_size;
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 AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
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 AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
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);
if(len<0 || end - header - 8 < len) if (len<0 || end - header - 8 < len)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
header += len; header += len;
} }
@ -240,11 +239,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 AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
header += 2; // skip channels (already got from shorten header) header += 2; // skip channels (already got from shorten header)
@ -282,11 +281,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;
@ -294,7 +294,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;
} }
@ -305,11 +305,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 */
@ -330,10 +331,10 @@ static int read_header(ShortenContext *s)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
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);
@ -350,19 +351,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 > (unsigned)MAX_BLOCKSIZE) { if (!blocksize || blocksize > (unsigned)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);
@ -376,17 +377,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 AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
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 AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
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 ((ret = decode_wave_header(s->avctx, s->header, s->header_size)) < 0) if ((ret = decode_wave_header(s->avctx, s->header, s->header_size)) < 0)
@ -405,15 +409,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= 8192; // should hopefully be enough for the first header s->max_framesize = 8192; // 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) {
@ -424,29 +428,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 */
@ -468,7 +475,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;
} }
@ -484,32 +491,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 > (unsigned)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 > (unsigned)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;
@ -535,7 +542,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)
@ -544,21 +551,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;
@ -567,11 +575,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 */
@ -612,12 +620,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 AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (s->bitstream_size) { if (s->bitstream_size) {