virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-02-04 06:08:26 +02:00
Code Issues Releases Activity

* DV decoder simplifications. Now it looks to be 6% faster. At least

Browse Source 
on my desktop.
     * Misc. DV cleanups and fixes.

Originally committed as revision 2892 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Roman Shaposhnik 2004-03-14 22:09:58 +00:00
parent b51469a0c5
commit 380fd6b1b4
3 changed files with 73 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
libavcodec/common.h
View File

@ -919,6 +919,11 @@ static inline int get_bits_left(GetBitContext *s)
return s->size_in_bits - get_bits_count(s); return s->size_in_bits - get_bits_count(s);
} }
static inline int get_bits_size(GetBitContext *s)
{
return s->size_in_bits;
}
int check_marker(GetBitContext *s, const char *msg); int check_marker(GetBitContext *s, const char *msg);
void align_get_bits(GetBitContext *s); void align_get_bits(GetBitContext *s);
int init_vlc(VLC *vlc, int nb_bits, int nb_codes, int init_vlc(VLC *vlc, int nb_bits, int nb_codes,

175
libavcodec/dv.c
View File

@ -59,7 +59,7 @@ typedef struct DVVideoDecodeContext {
#endif #endif
/* XXX: also include quantization */ /* XXX: also include quantization */
static RL_VLC_ELEM *dv_rl_vlc[1]; static RL_VLC_ELEM *dv_rl_vlc;
/* VLC encoding lookup table */ /* VLC encoding lookup table */
static struct dv_vlc_pair { static struct dv_vlc_pair {
uint32_t vlc; uint32_t vlc;
@ -111,8 +111,8 @@ static int dvvideo_init(AVCodecContext *avctx)
init_vlc(&dv_vlc, TEX_VLC_BITS, NB_DV_VLC, init_vlc(&dv_vlc, TEX_VLC_BITS, NB_DV_VLC,
dv_vlc_len, 1, 1, dv_vlc_bits, 2, 2); dv_vlc_len, 1, 1, dv_vlc_bits, 2, 2);
dv_rl_vlc[0] = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM)); dv_rl_vlc = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
if (!dv_rl_vlc[0]) { if (!dv_rl_vlc) {
av_free(dv_vlc_map); av_free(dv_vlc_map);
return -ENOMEM; return -ENOMEM;
} }
@ -124,18 +124,15 @@ static int dvvideo_init(AVCodecContext *avctx)
if(len<0){ //more bits needed if(len<0){ //more bits needed
run= 0; run= 0;
level= code; level= code;
} else if (code == (NB_DV_VLC - 1)) {
/* EOB */
run = 0;
level = 256;
} else { } else {
run= dv_vlc_run[code] + 1; run= dv_vlc_run[code] + 1;
level= dv_vlc_level[code]; level= dv_vlc_level[code];
} }
dv_rl_vlc[0][i].len = len; dv_rl_vlc[i].len = len;
dv_rl_vlc[0][i].level = level; dv_rl_vlc[i].level = level;
dv_rl_vlc[0][i].run = run; dv_rl_vlc[i].run = run;
} }
free_vlc(&dv_vlc);
for (i = 0; i < NB_DV_VLC - 1; i++) { for (i = 0; i < NB_DV_VLC - 1; i++) {
if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE || dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE) if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE || dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
@ -208,7 +205,6 @@ typedef struct BlockInfo {
const uint8_t *shift_table; const uint8_t *shift_table;
const uint8_t *scan_table; const uint8_t *scan_table;
uint8_t pos; /* position in block */ uint8_t pos; /* position in block */
uint8_t eob_reached; /* true if EOB has been reached */
uint8_t dct_mode; uint8_t dct_mode;
uint8_t partial_bit_count; uint8_t partial_bit_count;
uint16_t partial_bit_buffer; uint16_t partial_bit_buffer;
@ -229,16 +225,17 @@ static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
#endif #endif
/* decode ac coefs */ /* decode ac coefs */
static void dv_decode_ac(DVVideoDecodeContext *s, static void dv_decode_ac(DVVideoDecodeContext *s, BlockInfo *mb, DCTELEM *block)
BlockInfo *mb, DCTELEM *block, int last_index)
{ {
int last_index = get_bits_size(&s->gb);
int last_re_index; int last_re_index;
int shift_offset = mb->shift_offset; int shift_offset = mb->shift_offset;
const uint8_t *scan_table = mb->scan_table; const uint8_t *scan_table = mb->scan_table;
const uint8_t *shift_table = mb->shift_table; const uint8_t *shift_table = mb->shift_table;
int pos = mb->pos; int pos = mb->pos;
int level, pos1, sign, run; int level, pos1, run;
int partial_bit_count; int partial_bit_count;
int sign = 0;
#ifndef ALT_BITSTREAM_READER //FIXME #ifndef ALT_BITSTREAM_READER //FIXME
int re_index=0; int re_index=0;
int re1_index=0; int re1_index=0;
@ -254,7 +251,7 @@ static void dv_decode_ac(DVVideoDecodeContext *s,
if (partial_bit_count > 0) { if (partial_bit_count > 0) {
uint8_t buf[4]; uint8_t buf[4];
uint32_t v; uint32_t v;
int l, l1; int l;
GetBitContext gb1; GetBitContext gb1;
/* build the dummy bit buffer */ /* build the dummy bit buffer */
@ -275,7 +272,7 @@ static void dv_decode_ac(DVVideoDecodeContext *s,
{ {
OPEN_READER(re1, &gb1); OPEN_READER(re1, &gb1);
UPDATE_CACHE(re1, &gb1); UPDATE_CACHE(re1, &gb1);
GET_RL_VLC(level, run, re1, &gb1, dv_rl_vlc[0], GET_RL_VLC(level, run, re1, &gb1, dv_rl_vlc,
TEX_VLC_BITS, 2); TEX_VLC_BITS, 2);
l = re1_index; l = re1_index;
CLOSE_READER(re1, &gb1); CLOSE_READER(re1, &gb1);
@ -283,12 +280,14 @@ static void dv_decode_ac(DVVideoDecodeContext *s,
#ifdef VLC_DEBUG #ifdef VLC_DEBUG
printf("****run=%d level=%d size=%d\n", run, level, l); printf("****run=%d level=%d size=%d\n", run, level, l);
#endif #endif
/* compute codeword length */ /* compute codeword length -- if too long, we cannot parse */
l1 = (level != 256 && level != 0);
/* if too long, we cannot parse */
l -= partial_bit_count; l -= partial_bit_count;
if ((re_index + l + l1) > last_index) if ((re_index + l + (level != 0)) > last_index) {
mb->partial_bit_count += (last_index - re_index);
mb->partial_bit_buffer = v >> (16 - mb->partial_bit_count);
return; return;
}
/* skip read bits */ /* skip read bits */
last_re_index = 0; /* avoid warning */ last_re_index = 0; /* avoid warning */
re_index += l; re_index += l;
@ -307,62 +306,45 @@ static void dv_decode_ac(DVVideoDecodeContext *s,
pos, SHOW_UBITS(re, &s->gb, 16), re_index); pos, SHOW_UBITS(re, &s->gb, 16), re_index);
#endif #endif
last_re_index = re_index; last_re_index = re_index;
GET_RL_VLC(level, run, re, &s->gb, dv_rl_vlc[0], GET_RL_VLC(level, run, re, &s->gb, dv_rl_vlc,
TEX_VLC_BITS, 2); TEX_VLC_BITS, 2);
handle_vlc: handle_vlc:
#ifdef VLC_DEBUG #ifdef VLC_DEBUG
printf("run=%d level=%d\n", run, level); printf("run=%d level=%d\n", run, level);
#endif #endif
if (level == 256) { if (level) {
if (re_index > last_index) {
cannot_read:
/* put position before read code */
re_index = last_re_index;
mb->eob_reached = 0;
break;
}
/* EOB */
mb->eob_reached = 1;
break;
} else if (level != 0) {
if ((re_index + 1) > last_index)
goto cannot_read;
sign = SHOW_SBITS(re, &s->gb, 1); sign = SHOW_SBITS(re, &s->gb, 1);
level = (level ^ sign) - sign;
LAST_SKIP_BITS(re, &s->gb, 1); LAST_SKIP_BITS(re, &s->gb, 1);
pos += run;
/* error */
if (pos >= 64) {
goto read_error;
} }
if (re_index > last_index) {
/* should be < 16 bits otherwise a codeword could have been parsed */
re_index = last_re_index;
UPDATE_CACHE(re, &s->gb);
mb->partial_bit_count = last_index - re_index;
mb->partial_bit_buffer = SHOW_UBITS(re, &s->gb, mb->partial_bit_count);
re_index = last_index;
break;
}
pos += run;
if (pos >= 64)
break;
if (level) {
level = (level ^ sign) - sign;
pos1 = scan_table[pos]; pos1 = scan_table[pos];
level = level << (shift_table[pos1] + shift_offset); level = level << (shift_table[pos1] + shift_offset);
block[pos1] = level; block[pos1] = level;
// printf("run=%d level=%d shift=%d\n", run, level, shift_table[pos1]); // printf("run=%d level=%d shift=%d\n", run, level, shift_table[pos1]);
} else {
if (re_index > last_index)
goto cannot_read;
/* level is zero: means run without coding. No
sign is coded */
pos += run;
/* error */
if (pos >= 64) {
read_error:
#if defined(VLC_DEBUG) || 1
av_log(NULL, AV_LOG_ERROR, "error pos=%d\n", pos);
#endif
/* for errors, we consider the eob is reached */
mb->eob_reached = 1;
break;
}
} }
} }
CLOSE_READER(re, &s->gb); CLOSE_READER(re, &s->gb);
mb->pos = pos; mb->pos = pos;
} }
static inline void bit_copy(PutBitContext *pb, GetBitContext *gb, int bits_left) static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
{ {
int bits_left = get_bits_left(gb);
while (bits_left >= 16) { while (bits_left >= 16) {
put_bits(pb, 16, get_bits(gb, 16)); put_bits(pb, 16, get_bits(gb, 16));
bits_left -= 16; bits_left -= 16;
@ -380,16 +362,14 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
int quant, dc, dct_mode, class1, j; int quant, dc, dct_mode, class1, j;
int mb_index, mb_x, mb_y, v, last_index; int mb_index, mb_x, mb_y, v, last_index;
DCTELEM *block, *block1; DCTELEM *block, *block1;
int c_offset, bits_left; int c_offset;
uint8_t *y_ptr; uint8_t *y_ptr;
BlockInfo mb_data[5 * 6], *mb, *mb1; BlockInfo mb_data[5 * 6], *mb, *mb1;
void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block); void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
uint8_t *buf_ptr; uint8_t *buf_ptr;
PutBitContext pb, vs_pb; PutBitContext pb, vs_pb;
uint8_t mb_bit_buffer[80 + 4]; /* allow some slack */ uint8_t mb_bit_buffer[80 + 4]; /* allow some slack */
int mb_bit_count;
uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */ uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */
int vs_bit_count;
memset(s->block, 0, sizeof(s->block)); memset(s->block, 0, sizeof(s->block));
@ -398,18 +378,16 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
block1 = &s->block[0][0]; block1 = &s->block[0][0];
mb1 = mb_data; mb1 = mb_data;
init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80); init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
vs_bit_count = 0; for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
for(mb_index = 0; mb_index < 5; mb_index++) {
/* skip header */ /* skip header */
quant = buf_ptr[3] & 0x0f; quant = buf_ptr[3] & 0x0f;
buf_ptr += 4; buf_ptr += 4;
init_put_bits(&pb, mb_bit_buffer, 80); init_put_bits(&pb, mb_bit_buffer, 80);
mb_bit_count = 0;
mb = mb1; mb = mb1;
block = block1; block = block1;
for(j = 0;j < 6; j++) { for(j = 0;j < 6; j++) {
/* NOTE: size is not important here */ last_index = block_sizes[j];
init_get_bits(&s->gb, buf_ptr, 14*8); init_get_bits(&s->gb, buf_ptr, last_index);
/* get the dc */ /* get the dc */
dc = get_bits(&s->gb, 9); dc = get_bits(&s->gb, 9);
@ -426,7 +404,6 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
standard IDCT */ standard IDCT */
dc += 1024; dc += 1024;
block[0] = dc; block[0] = dc;
last_index = block_sizes[j];
buf_ptr += last_index >> 3; buf_ptr += last_index >> 3;
mb->pos = 0; mb->pos = 0;
mb->partial_bit_count = 0; mb->partial_bit_count = 0;
@ -434,81 +411,57 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
#ifdef VLC_DEBUG #ifdef VLC_DEBUG
printf("MB block: %d, %d ", mb_index, j); printf("MB block: %d, %d ", mb_index, j);
#endif #endif
dv_decode_ac(s, mb, block, last_index); dv_decode_ac(s, mb, block);
/* write the remaining bits in a new buffer only if the /* write the remaining bits in a new buffer only if the
block is finished */ block is finished */
bits_left = last_index - get_bits_count(&s->gb); if (mb->pos >= 64)
if (mb->eob_reached) { bit_copy(&pb, &s->gb);
mb->partial_bit_count = 0;
mb_bit_count += bits_left;
bit_copy(&pb, &s->gb, bits_left);
} else {
/* should be < 16 bits otherwise a codeword could have
been parsed */
mb->partial_bit_count = bits_left;
mb->partial_bit_buffer = get_bits(&s->gb, bits_left);
}
block += 64; block += 64;
mb++; mb++;
} }
flush_put_bits(&pb);
/* pass 2 : we can do it just after */ /* pass 2 : we can do it just after */
#ifdef VLC_DEBUG #ifdef VLC_DEBUG
printf("***pass 2 size=%d MB#=%d\n", mb_bit_count, mb_index); printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
#endif #endif
block = block1; block = block1;
mb = mb1; mb = mb1;
init_get_bits(&s->gb, mb_bit_buffer, 80*8); init_get_bits(&s->gb, mb_bit_buffer, put_bits_count(&pb));
for(j = 0;j < 6; j++) { flush_put_bits(&pb);
if (!mb->eob_reached && get_bits_count(&s->gb) < mb_bit_count) { for(j = 0;j < 6; j++, block += 64, mb++) {
dv_decode_ac(s, mb, block, mb_bit_count); if (mb->pos < 64 && get_bits_left(&s->gb) > 0) {
dv_decode_ac(s, mb, block);
/* if still not finished, no need to parse other blocks */ /* if still not finished, no need to parse other blocks */
if (!mb->eob_reached) { if (mb->pos < 64)
/* we could not parse the current AC coefficient, break;
so we add the remaining bytes */
bits_left = mb_bit_count - get_bits_count(&s->gb);
if (bits_left > 0) {
mb->partial_bit_count += bits_left;
mb->partial_bit_buffer =
(mb->partial_bit_buffer << bits_left) |
get_bits(&s->gb, bits_left);
} }
goto next_mb;
}
}
block += 64;
mb++;
} }
/* all blocks are finished, so the extra bytes can be used at /* all blocks are finished, so the extra bytes can be used at
the video segment level */ the video segment level */
bits_left = mb_bit_count - get_bits_count(&s->gb); if (j >= 6)
vs_bit_count += bits_left; bit_copy(&vs_pb, &s->gb);
bit_copy(&vs_pb, &s->gb, bits_left);
next_mb:
mb1 += 6;
block1 += 6 * 64;
} }
/* we need a pass other the whole video segment */ /* we need a pass other the whole video segment */
flush_put_bits(&vs_pb);
#ifdef VLC_DEBUG #ifdef VLC_DEBUG
printf("***pass 3 size=%d\n", vs_bit_count); printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
#endif #endif
block = &s->block[0][0]; block = &s->block[0][0];
mb = mb_data; mb = mb_data;
init_get_bits(&s->gb, vs_bit_buffer, 5 * 80*8); init_get_bits(&s->gb, vs_bit_buffer, put_bits_count(&vs_pb));
flush_put_bits(&vs_pb);
for(mb_index = 0; mb_index < 5; mb_index++) { for(mb_index = 0; mb_index < 5; mb_index++) {
for(j = 0;j < 6; j++) { for(j = 0;j < 6; j++) {
if (!mb->eob_reached) { if (mb->pos < 64) {
#ifdef VLC_DEBUG #ifdef VLC_DEBUG
printf("start %d:%d\n", mb_index, j); printf("start %d:%d\n", mb_index, j);
#endif #endif
dv_decode_ac(s, mb, block, vs_bit_count); dv_decode_ac(s, mb, block);
} }
if (mb->pos >= 64 && mb->pos < 127)
av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
block += 64; block += 64;
mb++; mb++;
} }

2
libavcodec/dvdata.h
View File

@ -218,7 +218,7 @@ static const uint8_t dv_vlc_run[409] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 127,
}; };
static const uint8_t dv_vlc_level[409] = { static const uint8_t dv_vlc_level[409] = {