falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

get_bits() specialization, gives 4\speedup 

Originally committed as revision 32 to svn://svn.ffmpeg.org/ffmpeg/trunk
tags/v0.5
Arpi 24 years ago
parent
2931ecb90f
commit
612476ef9b
4 changed files with 179 additions and 138 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +41
    -0
      libavcodec/common.h
  2. +79
    -79
      libavcodec/h263.c
  3. +43
    -43
      libavcodec/mpeg12.c
  4. +16
    -16
      libavcodec/msmpeg4.c

+ 41
- 0
libavcodec/common.h View File

@@ -80,6 +80,47 @@ static inline unsigned int get_bits(GetBitContext *s, int n){
return get_bits_long(s,n); return get_bits_long(s,n);
} }


static inline unsigned int get_bits1(GetBitContext *s){
if(s->bit_cnt>0){
/* most common case here */
unsigned int val = s->bit_buf >> 31;
s->bit_buf <<= 1;
s->bit_cnt--;
#ifdef STATS
st_bit_counts[st_current_index]++;
#endif
return val;
}
return get_bits_long(s,1);
}

static inline void skip_bits(GetBitContext *s, int n){
if(s->bit_cnt>=n){
/* most common case here */
s->bit_buf <<= n;
s->bit_cnt -= n;
#ifdef STATS
st_bit_counts[st_current_index] += n;
#endif
} else {
get_bits_long(s,n);
}
}

static inline void skip_bits1(GetBitContext *s){
if(s->bit_cnt>0){
/* most common case here */
s->bit_buf <<= 1;
s->bit_cnt--;
#ifdef STATS
st_bit_counts[st_current_index]++;
#endif
} else {
get_bits_long(s,1);
}
}


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,
const void *bits, int bits_wrap, int bits_size, const void *bits, int bits_wrap, int bits_size,


+ 79
- 79
libavcodec/h263.c View File

@@ -729,7 +729,7 @@ int h263_decode_mb(MpegEncContext *s,
static UINT8 quant_tab[4] = { -1, -2, 1, 2 }; static UINT8 quant_tab[4] = { -1, -2, 1, 2 };


if (s->pict_type == P_TYPE) { if (s->pict_type == P_TYPE) {
if (get_bits(&s->gb, 1)) {
if (get_bits1(&s->gb)) {
/* skip mb */ /* skip mb */
s->mb_intra = 0; s->mb_intra = 0;
for(i=0;i<6;i++) for(i=0;i<6;i++)
@@ -796,7 +796,7 @@ int h263_decode_mb(MpegEncContext *s,
} else { } else {
s->ac_pred = 0; s->ac_pred = 0;
if (s->h263_pred) { if (s->h263_pred) {
s->ac_pred = get_bits(&s->gb, 1);
s->ac_pred = get_bits1(&s->gb);
} }
cbpy = get_vlc(&s->gb, &cbpy_vlc); cbpy = get_vlc(&s->gb, &cbpy_vlc);
cbp = (cbpc & 3) | (cbpy << 2); cbp = (cbpc & 3) | (cbpy << 2);
@@ -834,7 +834,7 @@ static int h263_decode_motion(MpegEncContext * s, int pred)


if (code == 0) if (code == 0)
return pred; return pred;
sign = get_bits(&s->gb, 1);
sign = get_bits1(&s->gb);
shift = s->f_code - 1; shift = s->f_code - 1;
val = (code - 1) << shift; val = (code - 1) << shift;
if (shift > 0) if (shift > 0)
@@ -906,7 +906,7 @@ static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
return -1; return -1;
if (code == rl->n) { if (code == rl->n) {
/* escape */ /* escape */
last = get_bits(&s->gb, 1);
last = get_bits1(&s->gb);
run = get_bits(&s->gb, 6); run = get_bits(&s->gb, 6);
level = (INT8)get_bits(&s->gb, 8); level = (INT8)get_bits(&s->gb, 8);
if (s->h263_rv10 && level == -128) { if (s->h263_rv10 && level == -128) {
@@ -918,7 +918,7 @@ static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
run = rl->table_run[code]; run = rl->table_run[code];
level = rl->table_level[code]; level = rl->table_level[code];
last = code >= rl->last; last = code >= rl->last;
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} }
i += run; i += run;
@@ -952,7 +952,7 @@ static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/ if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
level = - (level ^ ((1 << code) - 1)); level = - (level ^ ((1 << code) - 1));
if (code > 8) if (code > 8)
get_bits(&s->gb, 1); /* marker */
skip_bits1(&s->gb); /* marker */
} }


pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr); pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
@@ -1009,15 +1009,15 @@ static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
return -1; return -1;
if (code == rl->n) { if (code == rl->n) {
/* escape */ /* escape */
if (get_bits(&s->gb, 1) != 0) {
if (get_bits(&s->gb, 1) != 0) {
if (get_bits1(&s->gb) != 0) {
if (get_bits1(&s->gb) != 0) {
/* third escape */ /* third escape */
last = get_bits(&s->gb, 1);
last = get_bits1(&s->gb);
run = get_bits(&s->gb, 6); run = get_bits(&s->gb, 6);
get_bits(&s->gb, 1); /* marker */
get_bits1(&s->gb); /* marker */
level = get_bits(&s->gb, 12); level = get_bits(&s->gb, 12);
level = (level << 20) >> 20; /* sign extend */ level = (level << 20) >> 20; /* sign extend */
get_bits(&s->gb, 1); /* marker */
skip_bits1(&s->gb); /* marker */
} else { } else {
/* second escape */ /* second escape */
code = get_vlc(&s->gb, &rl->vlc); code = get_vlc(&s->gb, &rl->vlc);
@@ -1027,7 +1027,7 @@ static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
level = rl->table_level[code]; level = rl->table_level[code];
last = code >= rl->last; last = code >= rl->last;
run += rl->max_run[last][level] + 1; run += rl->max_run[last][level] + 1;
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} }
} else { } else {
@@ -1039,14 +1039,14 @@ static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
level = rl->table_level[code]; level = rl->table_level[code];
last = code >= rl->last; last = code >= rl->last;
level += rl->max_level[last][run]; level += rl->max_level[last][run];
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} }
} else { } else {
run = rl->table_run[code]; run = rl->table_run[code];
level = rl->table_level[code]; level = rl->table_level[code];
last = code >= rl->last; last = code >= rl->last;
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} }
i += run; i += run;
@@ -1077,15 +1077,15 @@ int h263_decode_picture_header(MpegEncContext *s)
/* picture header */ /* picture header */
if (get_bits(&s->gb, 22) != 0x20) if (get_bits(&s->gb, 22) != 0x20)
return -1; return -1;
get_bits(&s->gb, 8); /* picture timestamp */
skip_bits(&s->gb, 8); /* picture timestamp */


if (get_bits(&s->gb, 1) != 1)
if (get_bits1(&s->gb) != 1)
return -1; /* marker */ return -1; /* marker */
if (get_bits(&s->gb, 1) != 0)
if (get_bits1(&s->gb) != 0)
return -1; /* h263 id */ return -1; /* h263 id */
get_bits(&s->gb, 1); /* split screen off */
get_bits(&s->gb, 1); /* camera off */
get_bits(&s->gb, 1); /* freeze picture release off */
skip_bits1(&s->gb); /* split screen off */
skip_bits1(&s->gb); /* camera off */
skip_bits1(&s->gb); /* freeze picture release off */


format = get_bits(&s->gb, 3); format = get_bits(&s->gb, 3);


@@ -1097,20 +1097,20 @@ int h263_decode_picture_header(MpegEncContext *s)
if (!width) if (!width)
return -1; return -1;


s->pict_type = I_TYPE + get_bits(&s->gb, 1);
s->pict_type = I_TYPE + get_bits1(&s->gb);


s->unrestricted_mv = get_bits(&s->gb, 1);
s->unrestricted_mv = get_bits1(&s->gb);
s->h263_long_vectors = s->unrestricted_mv; s->h263_long_vectors = s->unrestricted_mv;


if (get_bits(&s->gb, 1) != 0)
if (get_bits1(&s->gb) != 0)
return -1; /* SAC: off */ return -1; /* SAC: off */
if (get_bits(&s->gb, 1) != 0)
if (get_bits1(&s->gb) != 0)
return -1; /* advanced prediction mode: off */ return -1; /* advanced prediction mode: off */
if (get_bits(&s->gb, 1) != 0)
if (get_bits1(&s->gb) != 0)
return -1; /* not PB frame */ return -1; /* not PB frame */


s->qscale = get_bits(&s->gb, 5); s->qscale = get_bits(&s->gb, 5);
get_bits(&s->gb, 1); /* Continuous Presence Multipoint mode: off */
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
} else { } else {
s->h263_plus = 1; s->h263_plus = 1;
/* H.263v2 */ /* H.263v2 */
@@ -1118,24 +1118,24 @@ int h263_decode_picture_header(MpegEncContext *s)
return -1; return -1;
if (get_bits(&s->gb, 3) != 6) /* custom source format */ if (get_bits(&s->gb, 3) != 6) /* custom source format */
return -1; return -1;
get_bits(&s->gb, 12);
get_bits(&s->gb, 3);
skip_bits(&s->gb, 12);
skip_bits(&s->gb, 3);
s->pict_type = get_bits(&s->gb, 3) + 1; s->pict_type = get_bits(&s->gb, 3) + 1;
if (s->pict_type != I_TYPE && if (s->pict_type != I_TYPE &&
s->pict_type != P_TYPE) s->pict_type != P_TYPE)
return -1; return -1;
get_bits(&s->gb, 7);
get_bits(&s->gb, 4); /* aspect ratio */
skip_bits(&s->gb, 7);
skip_bits(&s->gb, 4); /* aspect ratio */
width = (get_bits(&s->gb, 9) + 1) * 4; width = (get_bits(&s->gb, 9) + 1) * 4;
get_bits(&s->gb, 1);
skip_bits1(&s->gb);
height = get_bits(&s->gb, 9) * 4; height = get_bits(&s->gb, 9) * 4;
if (height == 0) if (height == 0)
return -1; return -1;
s->qscale = get_bits(&s->gb, 5); s->qscale = get_bits(&s->gb, 5);
} }
/* PEI */ /* PEI */
while (get_bits(&s->gb, 1) != 0) {
get_bits(&s->gb, 8);
while (get_bits1(&s->gb) != 0) {
skip_bits(&s->gb, 8);
} }
s->f_code = 1; s->f_code = 1;
s->width = width; s->width = width;
@@ -1169,40 +1169,40 @@ int mpeg4_decode_picture_header(MpegEncContext * s)
int time_increment_resolution, width, height; int time_increment_resolution, width, height;


/* vol header */ /* vol header */
get_bits(&s->gb, 1); /* random access */
get_bits(&s->gb, 8); /* vo_type */
get_bits(&s->gb, 1); /* is_ol_id */
get_bits(&s->gb, 4); /* vo_ver_id */
get_bits(&s->gb, 3); /* vo_priority */
skip_bits(&s->gb, 1); /* random access */
skip_bits(&s->gb, 8); /* vo_type */
skip_bits(&s->gb, 1); /* is_ol_id */
skip_bits(&s->gb, 4); /* vo_ver_id */
skip_bits(&s->gb, 3); /* vo_priority */
get_bits(&s->gb, 4); /* aspect_ratio_info */
get_bits(&s->gb, 1); /* vol control parameter */
get_bits(&s->gb, 2); /* vol shape */
get_bits(&s->gb, 1); /* marker */
skip_bits(&s->gb, 4); /* aspect_ratio_info */
skip_bits(&s->gb, 1); /* vol control parameter */
skip_bits(&s->gb, 2); /* vol shape */
skip_bits1(&s->gb); /* marker */
time_increment_resolution = get_bits(&s->gb, 16); time_increment_resolution = get_bits(&s->gb, 16);
s->time_increment_bits = log2(time_increment_resolution - 1) + 1; s->time_increment_bits = log2(time_increment_resolution - 1) + 1;
get_bits(&s->gb, 1); /* marker */
skip_bits1(&s->gb); /* marker */


get_bits(&s->gb, 1); /* vop rate */
get_bits(&s->gb, s->time_increment_bits);
get_bits(&s->gb, 1); /* marker */
skip_bits1(&s->gb); /* vop rate */
skip_bits(&s->gb, s->time_increment_bits);
skip_bits1(&s->gb); /* marker */
width = get_bits(&s->gb, 13); width = get_bits(&s->gb, 13);
get_bits(&s->gb, 1); /* marker */
skip_bits1(&s->gb); /* marker */
height = get_bits(&s->gb, 13); height = get_bits(&s->gb, 13);
get_bits(&s->gb, 1); /* marker */
skip_bits1(&s->gb); /* marker */
get_bits(&s->gb, 1); /* interfaced */
get_bits(&s->gb, 1); /* OBMC */
get_bits(&s->gb, 2); /* vol_sprite_usage */
get_bits(&s->gb, 1); /* not_8_bit */
get_bits(&s->gb, 1); /* vol_quant_type */
get_bits(&s->gb, 1); /* vol_quarter_pixel */
get_bits(&s->gb, 1); /* complexity_estimation_disabled */
get_bits(&s->gb, 1); /* resync_marker_disabled */
get_bits(&s->gb, 1); /* data_partioning_enabled */
skip_bits1(&s->gb); /* interfaced */
skip_bits1(&s->gb); /* OBMC */
skip_bits(&s->gb, 2); /* vol_sprite_usage */
skip_bits1(&s->gb); /* not_8_bit */
skip_bits1(&s->gb); /* vol_quant_type */
skip_bits1(&s->gb); /* vol_quarter_pixel */
skip_bits1(&s->gb); /* complexity_estimation_disabled */
skip_bits1(&s->gb); /* resync_marker_disabled */
skip_bits1(&s->gb); /* data_partioning_enabled */
goto redo; goto redo;
} else if (startcode != 0x1b6) { } else if (startcode != 0x1b6) {
goto redo; goto redo;
@@ -1215,19 +1215,19 @@ int mpeg4_decode_picture_header(MpegEncContext * s)
/* XXX: parse time base */ /* XXX: parse time base */
time_incr = 0; time_incr = 0;
while (get_bits(&s->gb, 1) != 0)
while (get_bits1(&s->gb) != 0)
time_incr++; time_incr++;


get_bits(&s->gb, 1); /* marker */
get_bits(&s->gb, s->time_increment_bits);
get_bits(&s->gb, 1); /* marker */
skip_bits1(&s->gb); /* marker */
skip_bits(&s->gb, s->time_increment_bits);
skip_bits1(&s->gb); /* marker */
/* vop coded */ /* vop coded */
if (get_bits(&s->gb, 1) != 1)
if (get_bits1(&s->gb) != 1)
return -1; return -1;
if (s->pict_type == P_TYPE) { if (s->pict_type == P_TYPE) {
/* rounding type for motion estimation */ /* rounding type for motion estimation */
s->no_rounding = get_bits(&s->gb, 1);
s->no_rounding = get_bits1(&s->gb);
} }
if (get_bits(&s->gb, 3) != 0) if (get_bits(&s->gb, 3) != 0)
@@ -1249,15 +1249,15 @@ int intel_h263_decode_picture_header(MpegEncContext *s)
/* picture header */ /* picture header */
if (get_bits(&s->gb, 22) != 0x20) if (get_bits(&s->gb, 22) != 0x20)
return -1; return -1;
get_bits(&s->gb, 8); /* picture timestamp */
skip_bits(&s->gb, 8); /* picture timestamp */


if (get_bits(&s->gb, 1) != 1)
if (get_bits1(&s->gb) != 1)
return -1; /* marker */ return -1; /* marker */
if (get_bits(&s->gb, 1) != 0)
if (get_bits1(&s->gb) != 0)
return -1; /* h263 id */ return -1; /* h263 id */
get_bits(&s->gb, 1); /* split screen off */
get_bits(&s->gb, 1); /* camera off */
get_bits(&s->gb, 1); /* freeze picture release off */
skip_bits1(&s->gb); /* split screen off */
skip_bits1(&s->gb); /* camera off */
skip_bits1(&s->gb); /* freeze picture release off */


format = get_bits(&s->gb, 3); format = get_bits(&s->gb, 3);
if (format != 7) if (format != 7)
@@ -1265,27 +1265,27 @@ int intel_h263_decode_picture_header(MpegEncContext *s)


s->h263_plus = 0; s->h263_plus = 0;


s->pict_type = I_TYPE + get_bits(&s->gb, 1);
s->pict_type = I_TYPE + get_bits1(&s->gb);
s->unrestricted_mv = get_bits(&s->gb, 1);
s->unrestricted_mv = get_bits1(&s->gb);
s->h263_long_vectors = s->unrestricted_mv; s->h263_long_vectors = s->unrestricted_mv;


if (get_bits(&s->gb, 1) != 0)
if (get_bits1(&s->gb) != 0)
return -1; /* SAC: off */ return -1; /* SAC: off */
if (get_bits(&s->gb, 1) != 0)
if (get_bits1(&s->gb) != 0)
return -1; /* advanced prediction mode: off */ return -1; /* advanced prediction mode: off */
if (get_bits(&s->gb, 1) != 0)
if (get_bits1(&s->gb) != 0)
return -1; /* not PB frame */ return -1; /* not PB frame */


/* skip unknown header garbage */ /* skip unknown header garbage */
get_bits(&s->gb, 41);
skip_bits(&s->gb, 41);


s->qscale = get_bits(&s->gb, 5); s->qscale = get_bits(&s->gb, 5);
get_bits(&s->gb, 1); /* Continuous Presence Multipoint mode: off */
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */


/* PEI */ /* PEI */
while (get_bits(&s->gb, 1) != 0) {
get_bits(&s->gb, 8);
while (get_bits1(&s->gb) != 0) {
skip_bits(&s->gb, 8);
} }
s->f_code = 1; s->f_code = 1;
return 0; return 0;


+ 43
- 43
libavcodec/mpeg12.c View File

@@ -483,8 +483,8 @@ void mpeg1_init_vlc(MpegEncContext *s)


static inline int get_dmv(MpegEncContext *s) static inline int get_dmv(MpegEncContext *s)
{ {
if(get_bits(&s->gb, 1))
return 1 - (get_bits(&s->gb, 1) << 1);
if(get_bits1(&s->gb))
return 1 - (get_bits1(&s->gb) << 1);
else else
return 0; return 0;
} }
@@ -552,8 +552,8 @@ static int mpeg_decode_mb(MpegEncContext *s,
switch(s->pict_type) { switch(s->pict_type) {
default: default:
case I_TYPE: case I_TYPE:
if (get_bits(&s->gb, 1) == 0) {
if (get_bits(&s->gb, 1) == 0)
if (get_bits1(&s->gb) == 0) {
if (get_bits1(&s->gb) == 0)
return -1; return -1;
mb_type = MB_QUANT | MB_INTRA; mb_type = MB_QUANT | MB_INTRA;
} else { } else {
@@ -584,7 +584,7 @@ static int mpeg_decode_mb(MpegEncContext *s,
if (s->picture_structure == PICT_FRAME && if (s->picture_structure == PICT_FRAME &&
!s->frame_pred_frame_dct && !s->frame_pred_frame_dct &&
(mb_type & (MB_PAT | MB_INTRA))) { (mb_type & (MB_PAT | MB_INTRA))) {
s->interlaced_dct = get_bits(&s->gb, 1);
s->interlaced_dct = get_bits1(&s->gb);
#ifdef DEBUG #ifdef DEBUG
if (s->interlaced_dct) if (s->interlaced_dct)
printf("interlaced_dct\n"); printf("interlaced_dct\n");
@@ -609,7 +609,7 @@ static int mpeg_decode_mb(MpegEncContext *s,
if (s->concealment_motion_vectors) { if (s->concealment_motion_vectors) {
/* just parse them */ /* just parse them */
if (s->picture_structure != PICT_FRAME) if (s->picture_structure != PICT_FRAME)
get_bits(&s->gb, 1); /* field select */
skip_bits1(&s->gb); /* field select */
mpeg_decode_motion(s, s->mpeg_f_code[0][0], 0); mpeg_decode_motion(s, s->mpeg_f_code[0][0], 0);
mpeg_decode_motion(s, s->mpeg_f_code[0][1], 0); mpeg_decode_motion(s, s->mpeg_f_code[0][1], 0);
} }
@@ -655,7 +655,7 @@ static int mpeg_decode_mb(MpegEncContext *s,
/* MT_16X8 */ /* MT_16X8 */
s->mv_type = MV_TYPE_16X8; s->mv_type = MV_TYPE_16X8;
for(j=0;j<2;j++) { for(j=0;j<2;j++) {
s->field_select[i][j] = get_bits(&s->gb, 1);
s->field_select[i][j] = get_bits1(&s->gb);
for(k=0;k<2;k++) { for(k=0;k<2;k++) {
val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
s->last_mv[i][j][k]); s->last_mv[i][j][k]);
@@ -669,7 +669,7 @@ static int mpeg_decode_mb(MpegEncContext *s,
if (s->picture_structure == PICT_FRAME) { if (s->picture_structure == PICT_FRAME) {
s->mv_type = MV_TYPE_FIELD; s->mv_type = MV_TYPE_FIELD;
for(j=0;j<2;j++) { for(j=0;j<2;j++) {
s->field_select[i][j] = get_bits(&s->gb, 1);
s->field_select[i][j] = get_bits1(&s->gb);
val = mpeg_decode_motion(s, s->mpeg_f_code[i][0], val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
s->last_mv[i][j][0]); s->last_mv[i][j][0]);
s->last_mv[i][j][0] = val; s->last_mv[i][j][0] = val;
@@ -683,7 +683,7 @@ static int mpeg_decode_mb(MpegEncContext *s,
} }
} else { } else {
s->mv_type = MV_TYPE_16X16; s->mv_type = MV_TYPE_16X16;
s->field_select[i][0] = get_bits(&s->gb, 1);
s->field_select[i][0] = get_bits1(&s->gb);
for(k=0;k<2;k++) { for(k=0;k<2;k++) {
val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
s->last_mv[i][0][k]); s->last_mv[i][0][k]);
@@ -739,7 +739,7 @@ static int mpeg_decode_mb(MpegEncContext *s,
} }


if ((mb_type & MB_INTRA) && s->concealment_motion_vectors) { if ((mb_type & MB_INTRA) && s->concealment_motion_vectors) {
get_bits(&s->gb, 1); /* marker */
skip_bits1(&s->gb); /* marker */
} }
if (mb_type & MB_PAT) { if (mb_type & MB_PAT) {
@@ -789,7 +789,7 @@ static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
if (code == 0) { if (code == 0) {
return pred; return pred;
} }
sign = get_bits(&s->gb, 1);
sign = get_bits1(&s->gb);
shift = fcode - 1; shift = fcode - 1;
val = (code - 1) << shift; val = (code - 1) << shift;
if (shift > 0) if (shift > 0)
@@ -890,7 +890,7 @@ static int mpeg1_decode_block(MpegEncContext *s,
} else { } else {
run = rl->table_run[code]; run = rl->table_run[code];
level = rl->table_level[code]; level = rl->table_level[code];
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} }
i += run; i += run;
@@ -963,7 +963,7 @@ static int mpeg2_decode_block_non_intra(MpegEncContext *s,
} else { } else {
run = rl->table_run[code]; run = rl->table_run[code];
level = rl->table_level[code]; level = rl->table_level[code];
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} }
i += run; i += run;
@@ -1036,7 +1036,7 @@ static int mpeg2_decode_block_intra(MpegEncContext *s,
} else { } else {
run = rl->table_run[code]; run = rl->table_run[code];
level = rl->table_level[code]; level = rl->table_level[code];
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} }
i += run; i += run;
@@ -1121,9 +1121,9 @@ static int mpeg1_decode_picture(AVCodecContext *avctx,
ref = get_bits(&s->gb, 10); /* temporal ref */ ref = get_bits(&s->gb, 10); /* temporal ref */
s->pict_type = get_bits(&s->gb, 3); s->pict_type = get_bits(&s->gb, 3);
dprintf("pict_type=%d\n", s->pict_type); dprintf("pict_type=%d\n", s->pict_type);
get_bits(&s->gb, 16);
skip_bits(&s->gb, 16);
if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) { if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
s->full_pel[0] = get_bits(&s->gb, 1);
s->full_pel[0] = get_bits1(&s->gb);
f_code = get_bits(&s->gb, 3); f_code = get_bits(&s->gb, 3);
if (f_code == 0) if (f_code == 0)
return -1; return -1;
@@ -1131,7 +1131,7 @@ static int mpeg1_decode_picture(AVCodecContext *avctx,
s->mpeg_f_code[0][1] = f_code; s->mpeg_f_code[0][1] = f_code;
} }
if (s->pict_type == B_TYPE) { if (s->pict_type == B_TYPE) {
s->full_pel[1] = get_bits(&s->gb, 1);
s->full_pel[1] = get_bits1(&s->gb);
f_code = get_bits(&s->gb, 3); f_code = get_bits(&s->gb, 3);
if (f_code == 0) if (f_code == 0)
return -1; return -1;
@@ -1150,18 +1150,18 @@ static void mpeg_decode_sequence_extension(MpegEncContext *s)
int bit_rate_ext, vbv_buf_ext, low_delay; int bit_rate_ext, vbv_buf_ext, low_delay;
int frame_rate_ext_n, frame_rate_ext_d; int frame_rate_ext_n, frame_rate_ext_d;


get_bits(&s->gb, 8); /* profil and level */
get_bits(&s->gb, 1); /* progressive_sequence */
get_bits(&s->gb, 2); /* chroma_format */
skip_bits(&s->gb, 8); /* profil and level */
skip_bits(&s->gb, 1); /* progressive_sequence */
skip_bits(&s->gb, 2); /* chroma_format */
horiz_size_ext = get_bits(&s->gb, 2); horiz_size_ext = get_bits(&s->gb, 2);
vert_size_ext = get_bits(&s->gb, 2); vert_size_ext = get_bits(&s->gb, 2);
s->width |= (horiz_size_ext << 12); s->width |= (horiz_size_ext << 12);
s->height |= (vert_size_ext << 12); s->height |= (vert_size_ext << 12);
bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */ bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400; s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
get_bits(&s->gb, 1); /* marker */
skip_bits1(&s->gb); /* marker */
vbv_buf_ext = get_bits(&s->gb, 8); vbv_buf_ext = get_bits(&s->gb, 8);
low_delay = get_bits(&s->gb, 1);
low_delay = get_bits1(&s->gb);
frame_rate_ext_n = get_bits(&s->gb, 2); frame_rate_ext_n = get_bits(&s->gb, 2);
frame_rate_ext_d = get_bits(&s->gb, 5); frame_rate_ext_d = get_bits(&s->gb, 5);
if (frame_rate_ext_d >= 1) if (frame_rate_ext_d >= 1)
@@ -1174,27 +1174,27 @@ static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
{ {
int i, v; int i, v;


if (get_bits(&s->gb, 1)) {
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) { for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8); v = get_bits(&s->gb, 8);
s->intra_matrix[i] = v; s->intra_matrix[i] = v;
s->chroma_intra_matrix[i] = v; s->chroma_intra_matrix[i] = v;
} }
} }
if (get_bits(&s->gb, 1)) {
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) { for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8); v = get_bits(&s->gb, 8);
s->non_intra_matrix[i] = v; s->non_intra_matrix[i] = v;
s->chroma_non_intra_matrix[i] = v; s->chroma_non_intra_matrix[i] = v;
} }
} }
if (get_bits(&s->gb, 1)) {
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) { for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8); v = get_bits(&s->gb, 8);
s->chroma_intra_matrix[i] = v; s->chroma_intra_matrix[i] = v;
} }
} }
if (get_bits(&s->gb, 1)) {
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) { for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8); v = get_bits(&s->gb, 8);
s->chroma_non_intra_matrix[i] = v; s->chroma_non_intra_matrix[i] = v;
@@ -1211,15 +1211,15 @@ static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
s->mpeg_f_code[1][1] = get_bits(&s->gb, 4); s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
s->intra_dc_precision = get_bits(&s->gb, 2); s->intra_dc_precision = get_bits(&s->gb, 2);
s->picture_structure = get_bits(&s->gb, 2); s->picture_structure = get_bits(&s->gb, 2);
s->top_field_first = get_bits(&s->gb, 1);
s->frame_pred_frame_dct = get_bits(&s->gb, 1);
s->concealment_motion_vectors = get_bits(&s->gb, 1);
s->q_scale_type = get_bits(&s->gb, 1);
s->intra_vlc_format = get_bits(&s->gb, 1);
s->alternate_scan = get_bits(&s->gb, 1);
s->repeat_first_field = get_bits(&s->gb, 1);
s->chroma_420_type = get_bits(&s->gb, 1);
s->progressive_frame = get_bits(&s->gb, 1);
s->top_field_first = get_bits1(&s->gb);
s->frame_pred_frame_dct = get_bits1(&s->gb);
s->concealment_motion_vectors = get_bits1(&s->gb);
s->q_scale_type = get_bits1(&s->gb);
s->intra_vlc_format = get_bits1(&s->gb);
s->alternate_scan = get_bits1(&s->gb);
s->repeat_first_field = get_bits1(&s->gb);
s->chroma_420_type = get_bits1(&s->gb);
s->progressive_frame = get_bits1(&s->gb);
/* composite display not parsed */ /* composite display not parsed */
dprintf("dc_preci=%d\n", s->intra_dc_precision); dprintf("dc_preci=%d\n", s->intra_dc_precision);
dprintf("pict_structure=%d\n", s->picture_structure); dprintf("pict_structure=%d\n", s->picture_structure);
@@ -1285,8 +1285,8 @@ static int mpeg_decode_slice(AVCodecContext *avctx,


s->qscale = get_bits(&s->gb, 5); s->qscale = get_bits(&s->gb, 5);
/* extra slice info */ /* extra slice info */
while (get_bits(&s->gb, 1) != 0) {
get_bits(&s->gb, 8);
while (get_bits1(&s->gb) != 0) {
skip_bits(&s->gb, 8);
} }


for(;;) { for(;;) {
@@ -1351,12 +1351,12 @@ static int mpeg1_decode_sequence(AVCodecContext *avctx,


width = get_bits(&s->gb, 12); width = get_bits(&s->gb, 12);
height = get_bits(&s->gb, 12); height = get_bits(&s->gb, 12);
get_bits(&s->gb, 4);
skip_bits(&s->gb, 4);
s->frame_rate_index = get_bits(&s->gb, 4); s->frame_rate_index = get_bits(&s->gb, 4);
if (s->frame_rate_index == 0) if (s->frame_rate_index == 0)
return -1; return -1;
s->bit_rate = get_bits(&s->gb, 18) * 400; s->bit_rate = get_bits(&s->gb, 18) * 400;
if (get_bits(&s->gb, 1) == 0) /* marker */
if (get_bits1(&s->gb) == 0) /* marker */
return -1; return -1;
if (width <= 0 || height <= 0 || if (width <= 0 || height <= 0 ||
(width % 2) != 0 || (height % 2) != 0) (width % 2) != 0 || (height % 2) != 0)
@@ -1382,11 +1382,11 @@ static int mpeg1_decode_sequence(AVCodecContext *avctx,
s1->mpeg_enc_ctx_allocated = 1; s1->mpeg_enc_ctx_allocated = 1;
} }


get_bits(&s->gb, 10); /* vbv_buffer_size */
get_bits(&s->gb, 1);
skip_bits(&s->gb, 10); /* vbv_buffer_size */
skip_bits(&s->gb, 1);


/* get matrix */ /* get matrix */
if (get_bits(&s->gb, 1)) {
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) { for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8); v = get_bits(&s->gb, 8);
s->intra_matrix[i] = v; s->intra_matrix[i] = v;
@@ -1399,7 +1399,7 @@ static int mpeg1_decode_sequence(AVCodecContext *avctx,
s->chroma_intra_matrix[i] = v; s->chroma_intra_matrix[i] = v;
} }
} }
if (get_bits(&s->gb, 1)) {
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) { for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8); v = get_bits(&s->gb, 8);
s->non_intra_matrix[i] = v; s->non_intra_matrix[i] = v;


+ 16
- 16
libavcodec/msmpeg4.c View File

@@ -601,11 +601,11 @@ int msmpeg4_decode_init_vlc(MpegEncContext *s)
static int decode012(GetBitContext *gb) static int decode012(GetBitContext *gb)
{ {
int n; int n;
n = get_bits(gb, 1);
n = get_bits1(gb);
if (n == 0) if (n == 0)
return 0; return 0;
else else
return get_bits(gb, 1) + 1;
return get_bits1(gb) + 1;
} }


int msmpeg4_decode_picture_header(MpegEncContext * s) int msmpeg4_decode_picture_header(MpegEncContext * s)
@@ -629,17 +629,17 @@ int msmpeg4_decode_picture_header(MpegEncContext * s)
s->rl_chroma_table_index = decode012(&s->gb); s->rl_chroma_table_index = decode012(&s->gb);
s->rl_table_index = decode012(&s->gb); s->rl_table_index = decode012(&s->gb);


s->dc_table_index = get_bits(&s->gb, 1);
s->dc_table_index = get_bits1(&s->gb);
s->no_rounding = 1; s->no_rounding = 1;
} else { } else {
s->use_skip_mb_code = get_bits(&s->gb, 1);
s->use_skip_mb_code = get_bits1(&s->gb);
s->rl_table_index = decode012(&s->gb); s->rl_table_index = decode012(&s->gb);
s->rl_chroma_table_index = s->rl_table_index; s->rl_chroma_table_index = s->rl_table_index;


s->dc_table_index = get_bits(&s->gb, 1);
s->dc_table_index = get_bits1(&s->gb);


s->mv_table_index = get_bits(&s->gb, 1);
s->mv_table_index = get_bits1(&s->gb);
s->no_rounding ^= 1; s->no_rounding ^= 1;
} }
#ifdef DEBUG #ifdef DEBUG
@@ -685,7 +685,7 @@ int msmpeg4_decode_mb(MpegEncContext *s,
if (s->pict_type == P_TYPE) { if (s->pict_type == P_TYPE) {
set_stat(ST_INTER_MB); set_stat(ST_INTER_MB);
if (s->use_skip_mb_code) { if (s->use_skip_mb_code) {
if (get_bits(&s->gb, 1)) {
if (get_bits1(&s->gb)) {
/* skip mb */ /* skip mb */
s->mb_intra = 0; s->mb_intra = 0;
for(i=0;i<6;i++) for(i=0;i<6;i++)
@@ -739,7 +739,7 @@ int msmpeg4_decode_mb(MpegEncContext *s,
s->mv[0][0][1] = my; s->mv[0][0][1] = my;
} else { } else {
set_stat(ST_INTRA_MB); set_stat(ST_INTRA_MB);
s->ac_pred = get_bits(&s->gb, 1);
s->ac_pred = get_bits1(&s->gb);
} }


for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
@@ -801,10 +801,10 @@ static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
return -1; return -1;
if (code == rl->n) { if (code == rl->n) {
/* escape */ /* escape */
if (get_bits(&s->gb, 1) == 0) {
if (get_bits(&s->gb, 1) == 0) {
if (get_bits1(&s->gb) == 0) {
if (get_bits1(&s->gb) == 0) {
/* third escape */ /* third escape */
last = get_bits(&s->gb, 1);
last = get_bits1(&s->gb);
run = get_bits(&s->gb, 6); run = get_bits(&s->gb, 6);
level = get_bits(&s->gb, 8); level = get_bits(&s->gb, 8);
level = (level << 24) >> 24; /* sign extend */ level = (level << 24) >> 24; /* sign extend */
@@ -817,7 +817,7 @@ static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
level = rl->table_level[code]; level = rl->table_level[code];
last = code >= rl->last; last = code >= rl->last;
run += rl->max_run[last][level] + run_diff; run += rl->max_run[last][level] + run_diff;
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} }
} else { } else {
@@ -829,14 +829,14 @@ static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
level = rl->table_level[code]; level = rl->table_level[code];
last = code >= rl->last; last = code >= rl->last;
level += rl->max_level[last][run]; level += rl->max_level[last][run];
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} }
} else { } else {
run = rl->table_run[code]; run = rl->table_run[code];
level = rl->table_level[code]; level = rl->table_level[code];
last = code >= rl->last; last = code >= rl->last;
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} }
i += run; i += run;
@@ -875,10 +875,10 @@ static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)


if (level == DC_MAX) { if (level == DC_MAX) {
level = get_bits(&s->gb, 8); level = get_bits(&s->gb, 8);
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} else if (level != 0) { } else if (level != 0) {
if (get_bits(&s->gb, 1))
if (get_bits1(&s->gb))
level = -level; level = -level;
} }




Write Preview
Loading…
Cancel
Save