summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/libffmpeg/diff_to_ffmpeg_cvs.txt3857
-rw-r--r--src/libffmpeg/libavcodec/h263.c1115
-rw-r--r--src/libffmpeg/libavcodec/mpeg12.c875
-rw-r--r--src/libffmpeg/libavcodec/mpegvideo.h4
-rw-r--r--src/libffmpeg/libavcodec/msmpeg4.c609
5 files changed, 5147 insertions, 1313 deletions
diff --git a/src/libffmpeg/diff_to_ffmpeg_cvs.txt b/src/libffmpeg/diff_to_ffmpeg_cvs.txt
index 530d59f06..79be6a68d 100644
--- a/src/libffmpeg/diff_to_ffmpeg_cvs.txt
+++ b/src/libffmpeg/diff_to_ffmpeg_cvs.txt
@@ -51,6 +51,7 @@
+# endif
# endif
# include <assert.h>
+
--- /home/melanson/temp/ffmpeg/libavcodec/dsputil.h 2005-05-05 20:53:13.734834856 -0600
+++ libavcodec/dsputil.h 2005-05-05 21:30:43.776776488 -0600
@@ -31,6 +31,9 @@
@@ -97,6 +98,1802 @@
/* Start codes. */
#define SEQ_END_CODE 0x000001b7
#define SEQ_START_CODE 0x000001b3
+@@ -65,21 +65,6 @@
+ int component);
+ static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code); // RAL: f_code parameter added
+ #endif //CONFIG_ENCODERS
+-static inline int mpeg1_decode_block_inter(MpegEncContext *s,
+- DCTELEM *block,
+- int n);
+-static inline int mpeg1_decode_block_intra(MpegEncContext *s,
+- DCTELEM *block,
+- int n);
+-static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n);
+-static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
+- DCTELEM *block,
+- int n);
+-static inline int mpeg2_decode_block_intra(MpegEncContext *s,
+- DCTELEM *block,
+- int n);
+-static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, DCTELEM *block, int n);
+-static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, DCTELEM *block, int n);
+ static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
+ static void exchange_uv(MpegEncContext *s);
+
+@@ -1054,479 +1039,430 @@
+ #define MT_16X8 2
+ #define MT_DMV 3
+
+-static int mpeg_decode_mb(MpegEncContext *s,
+- DCTELEM block[12][64])
++static inline int decode_dc(GetBitContext *gb, int component)
+ {
+- int i, j, k, cbp, val, mb_type, motion_type;
+- const int mb_block_count = 4 + (1<< s->chroma_format);
++ int code, diff;
+
+- dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
++ if (component == 0) {
++ code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
++ } else {
++ code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
++ }
++ if (code < 0){
++ av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
++ return 0xffff;
++ }
++ if (code == 0) {
++ diff = 0;
++ } else {
++ diff = get_xbits(gb, code);
++ }
++ return diff;
++}
+
+- assert(s->mb_skipped==0);
++static inline int mpeg1_decode_block_intra(MpegEncContext *s,
++ DCTELEM *block,
++ int n)
++{
++ int level, dc, diff, i, j, run;
++ int component;
++ RLTable *rl = &rl_mpeg1;
++ uint8_t * const scantable= s->intra_scantable.permutated;
++ const uint16_t *quant_matrix= s->intra_matrix;
++ const int qscale= s->qscale;
+
+- if (s->mb_skip_run-- != 0) {
+- if(s->pict_type == I_TYPE){
+- av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
+- return -1;
+- }
+-
+- /* skip mb */
+- s->mb_intra = 0;
+- for(i=0;i<12;i++)
+- s->block_last_index[i] = -1;
+- if(s->picture_structure == PICT_FRAME)
+- s->mv_type = MV_TYPE_16X16;
+- else
+- s->mv_type = MV_TYPE_FIELD;
+- if (s->pict_type == P_TYPE) {
+- /* if P type, zero motion vector is implied */
+- s->mv_dir = MV_DIR_FORWARD;
+- s->mv[0][0][0] = s->mv[0][0][1] = 0;
+- s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
+- s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
+- s->field_select[0][0]= s->picture_structure - 1;
+- s->mb_skipped = 1;
+- s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
+- } else {
+- int mb_type;
++ /* DC coef */
++ component = (n <= 3 ? 0 : n - 4 + 1);
++ diff = decode_dc(&s->gb, component);
++ if (diff >= 0xffff)
++ return -1;
++ dc = s->last_dc[component];
++ dc += diff;
++ s->last_dc[component] = dc;
++ block[0] = dc<<3;
++ dprintf("dc=%d diff=%d\n", dc, diff);
++ i = 0;
++ {
++ OPEN_READER(re, &s->gb);
++ /* now quantify & encode AC coefs */
++ for(;;) {
++ UPDATE_CACHE(re, &s->gb);
++ GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
+
+- if(s->mb_x)
+- mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1];
+- else
+- mb_type= s->current_picture.mb_type[ s->mb_width + (s->mb_y-1)*s->mb_stride - 1]; // FIXME not sure if this is allowed in mpeg at all,
+- if(IS_INTRA(mb_type))
++ if(level == 127){
++ break;
++ } else if(level != 0) {
++ i += run;
++ j = scantable[i];
++ level= (level*qscale*quant_matrix[j])>>4;
++ level= (level-1)|1;
++ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
++ LAST_SKIP_BITS(re, &s->gb, 1);
++ } else {
++ /* escape */
++ run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
++ UPDATE_CACHE(re, &s->gb);
++ level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
++ if (level == -128) {
++ level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
++ } else if (level == 0) {
++ level = SHOW_UBITS(re, &s->gb, 8) ; LAST_SKIP_BITS(re, &s->gb, 8);
++ }
++ i += run;
++ j = scantable[i];
++ if(level<0){
++ level= -level;
++ level= (level*qscale*quant_matrix[j])>>4;
++ level= (level-1)|1;
++ level= -level;
++ }else{
++ level= (level*qscale*quant_matrix[j])>>4;
++ level= (level-1)|1;
++ }
++ }
++ if (i > 63){
++ av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
+ return -1;
+-
+- /* if B type, reuse previous vectors and directions */
+- s->mv[0][0][0] = s->last_mv[0][0][0];
+- s->mv[0][0][1] = s->last_mv[0][0][1];
+- s->mv[1][0][0] = s->last_mv[1][0][0];
+- s->mv[1][0][1] = s->last_mv[1][0][1];
+-
+- s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]=
+- mb_type | MB_TYPE_SKIP;
+-// assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
++ }
+
+- if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0)
+- s->mb_skipped = 1;
++ block[j] = level;
+ }
+-
+- return 0;
++ CLOSE_READER(re, &s->gb);
+ }
++ s->block_last_index[n] = i;
++ return 0;
++}
+
+- switch(s->pict_type) {
+- default:
+- case I_TYPE:
+- if (get_bits1(&s->gb) == 0) {
+- if (get_bits1(&s->gb) == 0){
+- av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
++static inline int mpeg1_decode_block_inter(MpegEncContext *s,
++ DCTELEM *block,
++ int n)
++{
++ int level, i, j, run;
++ RLTable *rl = &rl_mpeg1;
++ uint8_t * const scantable= s->intra_scantable.permutated;
++ const uint16_t *quant_matrix= s->inter_matrix;
++ const int qscale= s->qscale;
++
++ {
++ OPEN_READER(re, &s->gb);
++ i = -1;
++ /* special case for the first coef. no need to add a second vlc table */
++ UPDATE_CACHE(re, &s->gb);
++ if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
++ level= (3*qscale*quant_matrix[0])>>5;
++ level= (level-1)|1;
++ if(GET_CACHE(re, &s->gb)&0x40000000)
++ level= -level;
++ block[0] = level;
++ i++;
++ SKIP_BITS(re, &s->gb, 2);
++ if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
++ goto end;
++ }
++
++ /* now quantify & encode AC coefs */
++ for(;;) {
++ GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
++
++ if(level != 0) {
++ i += run;
++ j = scantable[i];
++ level= ((level*2+1)*qscale*quant_matrix[j])>>5;
++ level= (level-1)|1;
++ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
++ SKIP_BITS(re, &s->gb, 1);
++ } else {
++ /* escape */
++ run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
++ UPDATE_CACHE(re, &s->gb);
++ level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
++ if (level == -128) {
++ level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
++ } else if (level == 0) {
++ level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8);
++ }
++ i += run;
++ j = scantable[i];
++ if(level<0){
++ level= -level;
++ level= ((level*2+1)*qscale*quant_matrix[j])>>5;
++ level= (level-1)|1;
++ level= -level;
++ }else{
++ level= ((level*2+1)*qscale*quant_matrix[j])>>5;
++ level= (level-1)|1;
++ }
++ }
++ if (i > 63){
++ av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
+ return -1;
+ }
+- mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
+- } else {
+- mb_type = MB_TYPE_INTRA;
+- }
+- break;
+- case P_TYPE:
+- mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
+- if (mb_type < 0){
+- av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
+- return -1;
+- }
+- mb_type = ptype2mb_type[ mb_type ];
+- break;
+- case B_TYPE:
+- mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
+- if (mb_type < 0){
+- av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
+- return -1;
++
++ block[j] = level;
++ if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
++ break;
++ UPDATE_CACHE(re, &s->gb);
+ }
+- mb_type = btype2mb_type[ mb_type ];
+- break;
++end:
++ LAST_SKIP_BITS(re, &s->gb, 2);
++ CLOSE_READER(re, &s->gb);
+ }
+- dprintf("mb_type=%x\n", mb_type);
+-// motion_type = 0; /* avoid warning */
+- if (IS_INTRA(mb_type)) {
+- s->dsp.clear_blocks(s->block[0]);
+-
+- if(!s->chroma_y_shift){
+- s->dsp.clear_blocks(s->block[6]);
+- }
+-
+- /* compute dct type */
+- if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
+- !s->frame_pred_frame_dct) {
+- s->interlaced_dct = get_bits1(&s->gb);
+- }
++ s->block_last_index[n] = i;
++ return 0;
++}
+
+- if (IS_QUANT(mb_type))
+- s->qscale = get_qscale(s);
+-
+- if (s->concealment_motion_vectors) {
+- /* just parse them */
+- if (s->picture_structure != PICT_FRAME)
+- skip_bits1(&s->gb); /* field select */
+-
+- s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
+- mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
+- s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
+- mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
++static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n)
++{
++ int level, i, j, run;
++ RLTable *rl = &rl_mpeg1;
++ uint8_t * const scantable= s->intra_scantable.permutated;
++ const int qscale= s->qscale;
+
+- skip_bits1(&s->gb); /* marker */
+- }else
+- memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
+- s->mb_intra = 1;
+-#ifdef HAVE_XVMC
+- //one 1 we memcpy blocks in xvmcvideo
+- if(s->avctx->xvmc_acceleration > 1){
+- XVMC_pack_pblocks(s,-1);//inter are always full blocks
+- if(s->swap_uv){
+- exchange_uv(s);
+- }
++ {
++ OPEN_READER(re, &s->gb);
++ i = -1;
++ /* special case for the first coef. no need to add a second vlc table */
++ UPDATE_CACHE(re, &s->gb);
++ if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
++ level= (3*qscale)>>1;
++ level= (level-1)|1;
++ if(GET_CACHE(re, &s->gb)&0x40000000)
++ level= -level;
++ block[0] = level;
++ i++;
++ SKIP_BITS(re, &s->gb, 2);
++ if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
++ goto end;
+ }
+-#endif
+
+- if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
+- if(s->flags2 & CODEC_FLAG2_FAST){
+- for(i=0;i<6;i++) {
+- mpeg2_fast_decode_block_intra(s, s->pblocks[i], i);
++ /* now quantify & encode AC coefs */
++ for(;;) {
++ GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
++
++ if(level != 0) {
++ i += run;
++ j = scantable[i];
++ level= ((level*2+1)*qscale)>>1;
++ level= (level-1)|1;
++ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
++ SKIP_BITS(re, &s->gb, 1);
++ } else {
++ /* escape */
++ run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
++ UPDATE_CACHE(re, &s->gb);
++ level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
++ if (level == -128) {
++ level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
++ } else if (level == 0) {
++ level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8);
+ }
+- }else{
+- for(i=0;i<mb_block_count;i++) {
+- if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
+- return -1;
++ i += run;
++ j = scantable[i];
++ if(level<0){
++ level= -level;
++ level= ((level*2+1)*qscale)>>1;
++ level= (level-1)|1;
++ level= -level;
++ }else{
++ level= ((level*2+1)*qscale)>>1;
++ level= (level-1)|1;
+ }
+ }
+- } else {
+- for(i=0;i<6;i++) {
+- if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
+- return -1;
+- }
++
++ block[j] = level;
++ if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
++ break;
++ UPDATE_CACHE(re, &s->gb);
+ }
+- } else {
+- if (mb_type & MB_TYPE_ZERO_MV){
+- assert(mb_type & MB_TYPE_CBP);
++end:
++ LAST_SKIP_BITS(re, &s->gb, 2);
++ CLOSE_READER(re, &s->gb);
++ }
++ s->block_last_index[n] = i;
++ return 0;
++}
+
+- /* compute dct type */
+- if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
+- !s->frame_pred_frame_dct) {
+- s->interlaced_dct = get_bits1(&s->gb);
+- }
+
+- if (IS_QUANT(mb_type))
+- s->qscale = get_qscale(s);
++static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
++ DCTELEM *block,
++ int n)
++{
++ int level, i, j, run;
++ RLTable *rl = &rl_mpeg1;
++ uint8_t * const scantable= s->intra_scantable.permutated;
++ const uint16_t *quant_matrix;
++ const int qscale= s->qscale;
++ int mismatch;
+
+- s->mv_dir = MV_DIR_FORWARD;
+- if(s->picture_structure == PICT_FRAME)
+- s->mv_type = MV_TYPE_16X16;
+- else{
+- s->mv_type = MV_TYPE_FIELD;
+- mb_type |= MB_TYPE_INTERLACED;
+- s->field_select[0][0]= s->picture_structure - 1;
++ mismatch = 1;
++
++ {
++ OPEN_READER(re, &s->gb);
++ i = -1;
++ if (n < 4)
++ quant_matrix = s->inter_matrix;
++ else
++ quant_matrix = s->chroma_inter_matrix;
++
++ /* special case for the first coef. no need to add a second vlc table */
++ UPDATE_CACHE(re, &s->gb);
++ if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
++ level= (3*qscale*quant_matrix[0])>>5;
++ if(GET_CACHE(re, &s->gb)&0x40000000)
++ level= -level;
++ block[0] = level;
++ mismatch ^= level;
++ i++;
++ SKIP_BITS(re, &s->gb, 2);
++ if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
++ goto end;
++ }
++
++ /* now quantify & encode AC coefs */
++ for(;;) {
++ GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
++
++ if(level != 0) {
++ i += run;
++ j = scantable[i];
++ level= ((level*2+1)*qscale*quant_matrix[j])>>5;
++ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
++ SKIP_BITS(re, &s->gb, 1);
++ } else {
++ /* escape */
++ run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
++ UPDATE_CACHE(re, &s->gb);
++ level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
++
++ i += run;
++ j = scantable[i];
++ if(level<0){
++ level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
++ level= -level;
++ }else{
++ level= ((level*2+1)*qscale*quant_matrix[j])>>5;
++ }
+ }
+- s->last_mv[0][0][0] = 0;
+- s->last_mv[0][0][1] = 0;
+- s->last_mv[0][1][0] = 0;
+- s->last_mv[0][1][1] = 0;
+- s->mv[0][0][0] = 0;
+- s->mv[0][0][1] = 0;
+- }else{
+- assert(mb_type & MB_TYPE_L0L1);
+-//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
+- /* get additionnal motion vector type */
+- if (s->frame_pred_frame_dct)
+- motion_type = MT_FRAME;
+- else{
+- motion_type = get_bits(&s->gb, 2);
++ if (i > 63){
++ av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
++ return -1;
+ }
++
++ mismatch ^= level;
++ block[j] = level;
++ if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
++ break;
++ UPDATE_CACHE(re, &s->gb);
++ }
++end:
++ LAST_SKIP_BITS(re, &s->gb, 2);
++ CLOSE_READER(re, &s->gb);
++ }
++ block[63] ^= (mismatch & 1);
++
++ s->block_last_index[n] = i;
++ return 0;
++}
+
+- /* compute dct type */
+- if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
+- !s->frame_pred_frame_dct && HAS_CBP(mb_type)) {
+- s->interlaced_dct = get_bits1(&s->gb);
+- }
++static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
++ DCTELEM *block,
++ int n)
++{
++ int level, i, j, run;
++ RLTable *rl = &rl_mpeg1;
++ uint8_t * const scantable= s->intra_scantable.permutated;
++ const int qscale= s->qscale;
++ int v;
++ OPEN_READER(re, &s->gb);
++ i = -1;
+
+- if (IS_QUANT(mb_type))
+- s->qscale = get_qscale(s);
++ /* special case for the first coef. no need to add a second vlc table */
++ UPDATE_CACHE(re, &s->gb);
++ if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
++ level= (3*qscale)>>1;
++ if(GET_CACHE(re, &s->gb)&0x40000000)
++ level= -level;
++ block[0] = level;
++ i++;
++ SKIP_BITS(re, &s->gb, 2);
++ if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
++ goto end;
++ }
+
+- /* motion vectors */
+- s->mv_dir = 0;
+- for(i=0;i<2;i++) {
+- if (USES_LIST(mb_type, i)) {
+- s->mv_dir |= (MV_DIR_FORWARD >> i);
+- dprintf("motion_type=%d\n", motion_type);
+- switch(motion_type) {
+- case MT_FRAME: /* or MT_16X8 */
+- if (s->picture_structure == PICT_FRAME) {
+- /* MT_FRAME */
+- mb_type |= MB_TYPE_16x16;
+- s->mv_type = MV_TYPE_16X16;
+- s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
+- mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
+- s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
+- mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
+- /* full_pel: only for mpeg1 */
+- if (s->full_pel[i]){
+- s->mv[i][0][0] <<= 1;
+- s->mv[i][0][1] <<= 1;
+- }
+- } else {
+- /* MT_16X8 */
+- mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
+- s->mv_type = MV_TYPE_16X8;
+- for(j=0;j<2;j++) {
+- s->field_select[i][j] = get_bits1(&s->gb);
+- for(k=0;k<2;k++) {
+- val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
+- s->last_mv[i][j][k]);
+- s->last_mv[i][j][k] = val;
+- s->mv[i][j][k] = val;
+- }
+- }
+- }
+- break;
+- case MT_FIELD:
+- s->mv_type = MV_TYPE_FIELD;
+- if (s->picture_structure == PICT_FRAME) {
+- mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
+- for(j=0;j<2;j++) {
+- s->field_select[i][j] = get_bits1(&s->gb);
+- val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
+- s->last_mv[i][j][0]);
+- s->last_mv[i][j][0] = val;
+- s->mv[i][j][0] = val;
+- dprintf("fmx=%d\n", val);
+- val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
+- s->last_mv[i][j][1] >> 1);
+- s->last_mv[i][j][1] = val << 1;
+- s->mv[i][j][1] = val;
+- dprintf("fmy=%d\n", val);
+- }
+- } else {
+- mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
+- s->field_select[i][0] = get_bits1(&s->gb);
+- for(k=0;k<2;k++) {
+- val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
+- s->last_mv[i][0][k]);
+- s->last_mv[i][0][k] = val;
+- s->last_mv[i][1][k] = val;
+- s->mv[i][0][k] = val;
+- }
+- }
+- break;
+- case MT_DMV:
+- {
+- int dmx, dmy, mx, my, m;
+-
+- mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
+- s->last_mv[i][0][0]);
+- s->last_mv[i][0][0] = mx;
+- s->last_mv[i][1][0] = mx;
+- dmx = get_dmv(s);
+- my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
+- s->last_mv[i][0][1] >> 1);
+- dmy = get_dmv(s);
+- s->mv_type = MV_TYPE_DMV;
+-
+-
+- s->last_mv[i][0][1] = my<<1;
+- s->last_mv[i][1][1] = my<<1;
+-
+- s->mv[i][0][0] = mx;
+- s->mv[i][0][1] = my;
+- s->mv[i][1][0] = mx;//not used
+- s->mv[i][1][1] = my;//not used
+-
+- if (s->picture_structure == PICT_FRAME) {
+- mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
+-
+- //m = 1 + 2 * s->top_field_first;
+- m = s->top_field_first ? 1 : 3;
+-
+- /* top -> top pred */
+- s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
+- s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
+- m = 4 - m;
+- s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
+- s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
+- } else {
+- mb_type |= MB_TYPE_16x16;
+-
+- s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
+- s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
+- if(s->picture_structure == PICT_TOP_FIELD)
+- s->mv[i][2][1]--;
+- else
+- s->mv[i][2][1]++;
+- }
+- }
+- break;
+- default:
+- av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
+- return -1;
+- }
+- }
+- }
+- }
+-
+- s->mb_intra = 0;
+- if (HAS_CBP(mb_type)) {
+- s->dsp.clear_blocks(s->block[0]);
++ /* now quantify & encode AC coefs */
++ for(;;) {
++ GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
+
+- if(!s->chroma_y_shift){
+- s->dsp.clear_blocks(s->block[6]);
+- }
+-
+- cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
+- if (cbp < 0 || ((cbp == 0) && (s->chroma_format < 2)) ){
+- av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
+- return -1;
+- }
+- if(mb_block_count > 6){
+- cbp<<= mb_block_count-6;
+- cbp |= get_bits(&s->gb, mb_block_count-6);
+- }
+-
+-#ifdef HAVE_XVMC
+- //on 1 we memcpy blocks in xvmcvideo
+- if(s->avctx->xvmc_acceleration > 1){
+- XVMC_pack_pblocks(s,cbp);
+- if(s->swap_uv){
+- exchange_uv(s);
+- }
+- }
+-#endif
++ if(level != 0) {
++ i += run;
++ j = scantable[i];
++ level= ((level*2+1)*qscale)>>1;
++ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
++ SKIP_BITS(re, &s->gb, 1);
++ } else {
++ /* escape */
++ run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
++ UPDATE_CACHE(re, &s->gb);
++ level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
+
+- if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
+- if(s->flags2 & CODEC_FLAG2_FAST){
+- for(i=0;i<6;i++) {
+- if(cbp & 32) {
+- mpeg2_fast_decode_block_non_intra(s, s->pblocks[i], i);
+- } else {
+- s->block_last_index[i] = -1;
+- }
+- cbp+=cbp;
+- }
+- }else{
+- cbp<<= 12-mb_block_count;
+-
+- for(i=0;i<mb_block_count;i++) {
+- if ( cbp & (1<<11) ) {
+- if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
+- return -1;
+- } else {
+- s->block_last_index[i] = -1;
+- }
+- cbp+=cbp;
+- }
+- }
+- } else {
+- if(s->flags2 & CODEC_FLAG2_FAST){
+- for(i=0;i<6;i++) {
+- if (cbp & 32) {
+- mpeg1_fast_decode_block_inter(s, s->pblocks[i], i);
+- } else {
+- s->block_last_index[i] = -1;
+- }
+- cbp+=cbp;
+- }
+- }else{
+- for(i=0;i<6;i++) {
+- if (cbp & 32) {
+- if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0)
+- return -1;
+- } else {
+- s->block_last_index[i] = -1;
+- }
+- cbp+=cbp;
+- }
+- }
++ i += run;
++ j = scantable[i];
++ if(level<0){
++ level= ((-level*2+1)*qscale)>>1;
++ level= -level;
++ }else{
++ level= ((level*2+1)*qscale)>>1;
+ }
+- }else{
+- for(i=0;i<6;i++)
+- s->block_last_index[i] = -1;
+ }
++
++ block[j] = level;
++ if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
++ break;
++ UPDATE_CACHE(re, &s->gb);
+ }
+-
+- s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
+-
++end:
++ LAST_SKIP_BITS(re, &s->gb, 2);
++ CLOSE_READER(re, &s->gb);
++ s->block_last_index[n] = i;
+ return 0;
+ }
+
+-/* as h263, but only 17 codes */
+-static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
+-{
+- int code, sign, val, l, shift;
+-
+- code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
+- if (code == 0) {
+- return pred;
+- }
+- if (code < 0) {
+- return 0xffff;
+- }
+-
+- sign = get_bits1(&s->gb);
+- shift = fcode - 1;
+- val = code;
+- if (shift) {
+- val = (val - 1) << shift;
+- val |= get_bits(&s->gb, shift);
+- val++;
+- }
+- if (sign)
+- val = -val;
+- val += pred;
+-
+- /* modulo decoding */
+- l= INT_BIT - 5 - shift;
+- val = (val<<l)>>l;
+- return val;
+-}
+-
+-static inline int decode_dc(GetBitContext *gb, int component)
+-{
+- int code, diff;
+-
+- if (component == 0) {
+- code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
+- } else {
+- code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
+- }
+- if (code < 0){
+- av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
+- return 0xffff;
+- }
+- if (code == 0) {
+- diff = 0;
+- } else {
+- diff = get_xbits(gb, code);
+- }
+- return diff;
+-}
+
+-static inline int mpeg1_decode_block_intra(MpegEncContext *s,
++static inline int mpeg2_decode_block_intra(MpegEncContext *s,
+ DCTELEM *block,
+ int n)
+ {
+ int level, dc, diff, i, j, run;
+ int component;
+- RLTable *rl = &rl_mpeg1;
++ RLTable *rl;
+ uint8_t * const scantable= s->intra_scantable.permutated;
+- const uint16_t *quant_matrix= s->intra_matrix;
++ const uint16_t *quant_matrix;
+ const int qscale= s->qscale;
++ int mismatch;
+
+ /* DC coef */
+- component = (n <= 3 ? 0 : n - 4 + 1);
++ if (n < 4){
++ quant_matrix = s->intra_matrix;
++ component = 0;
++ }else{
++ quant_matrix = s->chroma_intra_matrix;
++ component = (n&1) + 1;
++ }
+ diff = decode_dc(&s->gb, component);
+ if (diff >= 0xffff)
+ return -1;
+ dc = s->last_dc[component];
+ dc += diff;
+ s->last_dc[component] = dc;
+- block[0] = dc<<3;
+- dprintf("dc=%d diff=%d\n", dc, diff);
++ block[0] = dc << (3 - s->intra_dc_precision);
++ dprintf("dc=%d\n", block[0]);
++ mismatch = block[0] ^ 1;
+ i = 0;
++ if (s->intra_vlc_format)
++ rl = &rl_mpeg2;
++ else
++ rl = &rl_mpeg1;
++
+ {
+ OPEN_READER(re, &s->gb);
+ /* now quantify & encode AC coefs */
+@@ -1540,487 +1476,536 @@
+ i += run;
+ j = scantable[i];
+ level= (level*qscale*quant_matrix[j])>>4;
+- level= (level-1)|1;
+ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+ LAST_SKIP_BITS(re, &s->gb, 1);
+ } else {
+ /* escape */
+ run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
+ UPDATE_CACHE(re, &s->gb);
+- level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
+- if (level == -128) {
+- level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
+- } else if (level == 0) {
+- level = SHOW_UBITS(re, &s->gb, 8) ; LAST_SKIP_BITS(re, &s->gb, 8);
+- }
++ level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
+ i += run;
+ j = scantable[i];
+ if(level<0){
+- level= -level;
+- level= (level*qscale*quant_matrix[j])>>4;
+- level= (level-1)|1;
++ level= (-level*qscale*quant_matrix[j])>>4;
+ level= -level;
+ }else{
+ level= (level*qscale*quant_matrix[j])>>4;
+- level= (level-1)|1;
+ }
+ }
+ if (i > 63){
+ av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
+ return -1;
+ }
+-
++
++ mismatch^= level;
+ block[j] = level;
+ }
+ CLOSE_READER(re, &s->gb);
+ }
++ block[63]^= mismatch&1;
++
+ s->block_last_index[n] = i;
+- return 0;
++ return 0;
+ }
+
+-static inline int mpeg1_decode_block_inter(MpegEncContext *s,
++static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
+ DCTELEM *block,
+ int n)
+ {
+- int level, i, j, run;
+- RLTable *rl = &rl_mpeg1;
+- uint8_t * const scantable= s->intra_scantable.permutated;
+- const uint16_t *quant_matrix= s->inter_matrix;
++ int level, dc, diff, j, run;
++ int component;
++ RLTable *rl;
++ uint8_t * scantable= s->intra_scantable.permutated;
++ const uint16_t *quant_matrix;
+ const int qscale= s->qscale;
+
+- {
+- OPEN_READER(re, &s->gb);
+- i = -1;
+- /* special case for the first coef. no need to add a second vlc table */
+- UPDATE_CACHE(re, &s->gb);
+- if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
+- level= (3*qscale*quant_matrix[0])>>5;
+- level= (level-1)|1;
+- if(GET_CACHE(re, &s->gb)&0x40000000)
+- level= -level;
+- block[0] = level;
+- i++;
+- SKIP_BITS(re, &s->gb, 2);
+- if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
+- goto end;
+- }
++ /* DC coef */
++ if (n < 4){
++ quant_matrix = s->intra_matrix;
++ component = 0;
++ }else{
++ quant_matrix = s->chroma_intra_matrix;
++ component = (n&1) + 1;
++ }
++ diff = decode_dc(&s->gb, component);
++ if (diff >= 0xffff)
++ return -1;
++ dc = s->last_dc[component];
++ dc += diff;
++ s->last_dc[component] = dc;
++ block[0] = dc << (3 - s->intra_dc_precision);
++ if (s->intra_vlc_format)
++ rl = &rl_mpeg2;
++ else
++ rl = &rl_mpeg1;
+
++ {
++ OPEN_READER(re, &s->gb);
+ /* now quantify & encode AC coefs */
+ for(;;) {
++ UPDATE_CACHE(re, &s->gb);
+ GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
+
+- if(level != 0) {
+- i += run;
+- j = scantable[i];
+- level= ((level*2+1)*qscale*quant_matrix[j])>>5;
+- level= (level-1)|1;
++ if(level == 127){
++ break;
++ } else if(level != 0) {
++ scantable += run;
++ j = *scantable;
++ level= (level*qscale*quant_matrix[j])>>4;
+ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+- SKIP_BITS(re, &s->gb, 1);
++ LAST_SKIP_BITS(re, &s->gb, 1);
+ } else {
+ /* escape */
+ run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
+ UPDATE_CACHE(re, &s->gb);
+- level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
+- if (level == -128) {
+- level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
+- } else if (level == 0) {
+- level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8);
+- }
+- i += run;
+- j = scantable[i];
++ level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
++ scantable += run;
++ j = *scantable;
+ if(level<0){
+- level= -level;
+- level= ((level*2+1)*qscale*quant_matrix[j])>>5;
+- level= (level-1)|1;
++ level= (-level*qscale*quant_matrix[j])>>4;
+ level= -level;
+ }else{
+- level= ((level*2+1)*qscale*quant_matrix[j])>>5;
+- level= (level-1)|1;
++ level= (level*qscale*quant_matrix[j])>>4;
+ }
+ }
+- if (i > 63){
+- av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
+- return -1;
+- }
+-
++
+ block[j] = level;
+- if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
+- break;
+- UPDATE_CACHE(re, &s->gb);
+ }
+-end:
+- LAST_SKIP_BITS(re, &s->gb, 2);
+ CLOSE_READER(re, &s->gb);
+ }
+- s->block_last_index[n] = i;
++
++ s->block_last_index[n] = scantable - s->intra_scantable.permutated;
+ return 0;
+ }
+
+-static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n)
++static int mpeg_decode_mb(MpegEncContext *s,
++ DCTELEM block[12][64])
+ {
+- int level, i, j, run;
+- RLTable *rl = &rl_mpeg1;
+- uint8_t * const scantable= s->intra_scantable.permutated;
+- const int qscale= s->qscale;
++ int i, j, k, cbp, val, mb_type, motion_type;
++ const int mb_block_count = 4 + (1<< s->chroma_format);
+
+- {
+- OPEN_READER(re, &s->gb);
+- i = -1;
+- /* special case for the first coef. no need to add a second vlc table */
+- UPDATE_CACHE(re, &s->gb);
+- if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
+- level= (3*qscale)>>1;
+- level= (level-1)|1;
+- if(GET_CACHE(re, &s->gb)&0x40000000)
+- level= -level;
+- block[0] = level;
+- i++;
+- SKIP_BITS(re, &s->gb, 2);
+- if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
+- goto end;
+- }
++ dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
+
+- /* now quantify & encode AC coefs */
+- for(;;) {
+- GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
++ assert(s->mb_skipped==0);
++
++ if (s->mb_skip_run-- != 0) {
++ if(s->pict_type == I_TYPE){
++ av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
++ return -1;
++ }
++
++ /* skip mb */
++ s->mb_intra = 0;
++ for(i=0;i<12;i++)
++ s->block_last_index[i] = -1;
++ if(s->picture_structure == PICT_FRAME)
++ s->mv_type = MV_TYPE_16X16;
++ else
++ s->mv_type = MV_TYPE_FIELD;
++ if (s->pict_type == P_TYPE) {
++ /* if P type, zero motion vector is implied */
++ s->mv_dir = MV_DIR_FORWARD;
++ s->mv[0][0][0] = s->mv[0][0][1] = 0;
++ s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
++ s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
++ s->field_select[0][0]= s->picture_structure - 1;
++ s->mb_skipped = 1;
++ s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
++ } else {
++ int mb_type;
+
+- if(level != 0) {
+- i += run;
+- j = scantable[i];
+- level= ((level*2+1)*qscale)>>1;
+- level= (level-1)|1;
+- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+- SKIP_BITS(re, &s->gb, 1);
+- } else {
+- /* escape */
+- run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
+- UPDATE_CACHE(re, &s->gb);
+- level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
+- if (level == -128) {
+- level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
+- } else if (level == 0) {
+- level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8);
+- }
+- i += run;
+- j = scantable[i];
+- if(level<0){
+- level= -level;
+- level= ((level*2+1)*qscale)>>1;
+- level= (level-1)|1;
+- level= -level;
+- }else{
+- level= ((level*2+1)*qscale)>>1;
+- level= (level-1)|1;
+- }
+- }
++ if(s->mb_x)
++ mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1];
++ else
++ mb_type= s->current_picture.mb_type[ s->mb_width + (s->mb_y-1)*s->mb_stride - 1]; // FIXME not sure if this is allowed in mpeg at all,
++ if(IS_INTRA(mb_type))
++ return -1;
++
++ /* if B type, reuse previous vectors and directions */
++ s->mv[0][0][0] = s->last_mv[0][0][0];
++ s->mv[0][0][1] = s->last_mv[0][0][1];
++ s->mv[1][0][0] = s->last_mv[1][0][0];
++ s->mv[1][0][1] = s->last_mv[1][0][1];
+
+- block[j] = level;
+- if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
+- break;
+- UPDATE_CACHE(re, &s->gb);
++ s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]=
++ mb_type | MB_TYPE_SKIP;
++// assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
++
++ if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0)
++ s->mb_skipped = 1;
+ }
+-end:
+- LAST_SKIP_BITS(re, &s->gb, 2);
+- CLOSE_READER(re, &s->gb);
+- }
+- s->block_last_index[n] = i;
+- return 0;
+-}
+
++ return 0;
++ }
+
+-static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
+- DCTELEM *block,
+- int n)
+-{
+- int level, i, j, run;
+- RLTable *rl = &rl_mpeg1;
+- uint8_t * const scantable= s->intra_scantable.permutated;
+- const uint16_t *quant_matrix;
+- const int qscale= s->qscale;
+- int mismatch;
+-
+- mismatch = 1;
+-
+- {
+- OPEN_READER(re, &s->gb);
+- i = -1;
+- if (n < 4)
+- quant_matrix = s->inter_matrix;
+- else
+- quant_matrix = s->chroma_inter_matrix;
+-
+- /* special case for the first coef. no need to add a second vlc table */
+- UPDATE_CACHE(re, &s->gb);
+- if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
+- level= (3*qscale*quant_matrix[0])>>5;
+- if(GET_CACHE(re, &s->gb)&0x40000000)
+- level= -level;
+- block[0] = level;
+- mismatch ^= level;
+- i++;
+- SKIP_BITS(re, &s->gb, 2);
+- if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
+- goto end;
++ switch(s->pict_type) {
++ default:
++ case I_TYPE:
++ if (get_bits1(&s->gb) == 0) {
++ if (get_bits1(&s->gb) == 0){
++ av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
++ return -1;
++ }
++ mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
++ } else {
++ mb_type = MB_TYPE_INTRA;
++ }
++ break;
++ case P_TYPE:
++ mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
++ if (mb_type < 0){
++ av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
++ return -1;
++ }
++ mb_type = ptype2mb_type[ mb_type ];
++ break;
++ case B_TYPE:
++ mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
++ if (mb_type < 0){
++ av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
++ return -1;
++ }
++ mb_type = btype2mb_type[ mb_type ];
++ break;
++ }
++ dprintf("mb_type=%x\n", mb_type);
++// motion_type = 0; /* avoid warning */
++ if (IS_INTRA(mb_type)) {
++ s->dsp.clear_blocks(s->block[0]);
++
++ if(!s->chroma_y_shift){
++ s->dsp.clear_blocks(s->block[6]);
++ }
++
++ /* compute dct type */
++ if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
++ !s->frame_pred_frame_dct) {
++ s->interlaced_dct = get_bits1(&s->gb);
+ }
+
+- /* now quantify & encode AC coefs */
+- for(;;) {
+- GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
++ if (IS_QUANT(mb_type))
++ s->qscale = get_qscale(s);
++
++ if (s->concealment_motion_vectors) {
++ /* just parse them */
++ if (s->picture_structure != PICT_FRAME)
++ skip_bits1(&s->gb); /* field select */
+
+- if(level != 0) {
+- i += run;
+- j = scantable[i];
+- level= ((level*2+1)*qscale*quant_matrix[j])>>5;
+- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+- SKIP_BITS(re, &s->gb, 1);
+- } else {
+- /* escape */
+- run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
+- UPDATE_CACHE(re, &s->gb);
+- level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
++ s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
++ mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
++ s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
++ mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
+
+- i += run;
+- j = scantable[i];
+- if(level<0){
+- level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
+- level= -level;
+- }else{
+- level= ((level*2+1)*qscale*quant_matrix[j])>>5;
++ skip_bits1(&s->gb); /* marker */
++ }else
++ memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
++ s->mb_intra = 1;
++#ifdef HAVE_XVMC
++ //one 1 we memcpy blocks in xvmcvideo
++ if(s->avctx->xvmc_acceleration > 1){
++ XVMC_pack_pblocks(s,-1);//inter are always full blocks
++ if(s->swap_uv){
++ exchange_uv(s);
++ }
++ }
++#endif
++
++ if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
++ if(s->flags2 & CODEC_FLAG2_FAST){
++ for(i=0;i<6;i++) {
++ mpeg2_fast_decode_block_intra(s, s->pblocks[i], i);
++ }
++ }else{
++ for(i=0;i<mb_block_count;i++) {
++ if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
++ return -1;
+ }
+ }
+- if (i > 63){
+- av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
+- return -1;
++ } else {
++ for(i=0;i<6;i++) {
++ if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
++ return -1;
+ }
+-
+- mismatch ^= level;
+- block[j] = level;
+- if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
+- break;
+- UPDATE_CACHE(re, &s->gb);
+ }
+-end:
+- LAST_SKIP_BITS(re, &s->gb, 2);
+- CLOSE_READER(re, &s->gb);
+- }
+- block[63] ^= (mismatch & 1);
+-
+- s->block_last_index[n] = i;
+- return 0;
+-}
++ } else {
++ if (mb_type & MB_TYPE_ZERO_MV){
++ assert(mb_type & MB_TYPE_CBP);
+
+-static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
+- DCTELEM *block,
+- int n)
+-{
+- int level, i, j, run;
+- RLTable *rl = &rl_mpeg1;
+- uint8_t * const scantable= s->intra_scantable.permutated;
+- const int qscale= s->qscale;
+- int v;
+- OPEN_READER(re, &s->gb);
+- i = -1;
++ /* compute dct type */
++ if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
++ !s->frame_pred_frame_dct) {
++ s->interlaced_dct = get_bits1(&s->gb);
++ }
+
+- /* special case for the first coef. no need to add a second vlc table */
+- UPDATE_CACHE(re, &s->gb);
+- if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
+- level= (3*qscale)>>1;
+- if(GET_CACHE(re, &s->gb)&0x40000000)
+- level= -level;
+- block[0] = level;
+- i++;
+- SKIP_BITS(re, &s->gb, 2);
+- if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
+- goto end;
+- }
++ if (IS_QUANT(mb_type))
++ s->qscale = get_qscale(s);
+
+- /* now quantify & encode AC coefs */
+- for(;;) {
+- GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
+-
+- if(level != 0) {
+- i += run;
+- j = scantable[i];
+- level= ((level*2+1)*qscale)>>1;
+- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+- SKIP_BITS(re, &s->gb, 1);
+- } else {
+- /* escape */
+- run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
+- UPDATE_CACHE(re, &s->gb);
+- level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
++ s->mv_dir = MV_DIR_FORWARD;
++ if(s->picture_structure == PICT_FRAME)
++ s->mv_type = MV_TYPE_16X16;
++ else{
++ s->mv_type = MV_TYPE_FIELD;
++ mb_type |= MB_TYPE_INTERLACED;
++ s->field_select[0][0]= s->picture_structure - 1;
++ }
++ s->last_mv[0][0][0] = 0;
++ s->last_mv[0][0][1] = 0;
++ s->last_mv[0][1][0] = 0;
++ s->last_mv[0][1][1] = 0;
++ s->mv[0][0][0] = 0;
++ s->mv[0][0][1] = 0;
++ }else{
++ assert(mb_type & MB_TYPE_L0L1);
++//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
++ /* get additionnal motion vector type */
++ if (s->frame_pred_frame_dct)
++ motion_type = MT_FRAME;
++ else{
++ motion_type = get_bits(&s->gb, 2);
++ }
+
+- i += run;
+- j = scantable[i];
+- if(level<0){
+- level= ((-level*2+1)*qscale)>>1;
+- level= -level;
+- }else{
+- level= ((level*2+1)*qscale)>>1;
++ /* compute dct type */
++ if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
++ !s->frame_pred_frame_dct && HAS_CBP(mb_type)) {
++ s->interlaced_dct = get_bits1(&s->gb);
++ }
++
++ if (IS_QUANT(mb_type))
++ s->qscale = get_qscale(s);
++
++ /* motion vectors */
++ s->mv_dir = 0;
++ for(i=0;i<2;i++) {
++ if (USES_LIST(mb_type, i)) {
++ s->mv_dir |= (MV_DIR_FORWARD >> i);
++ dprintf("motion_type=%d\n", motion_type);
++ switch(motion_type) {
++ case MT_FRAME: /* or MT_16X8 */
++ if (s->picture_structure == PICT_FRAME) {
++ /* MT_FRAME */
++ mb_type |= MB_TYPE_16x16;
++ s->mv_type = MV_TYPE_16X16;
++ s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
++ mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
++ s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
++ mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
++ /* full_pel: only for mpeg1 */
++ if (s->full_pel[i]){
++ s->mv[i][0][0] <<= 1;
++ s->mv[i][0][1] <<= 1;
++ }
++ } else {
++ /* MT_16X8 */
++ mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
++ s->mv_type = MV_TYPE_16X8;
++ for(j=0;j<2;j++) {
++ s->field_select[i][j] = get_bits1(&s->gb);
++ for(k=0;k<2;k++) {
++ val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
++ s->last_mv[i][j][k]);
++ s->last_mv[i][j][k] = val;
++ s->mv[i][j][k] = val;
++ }
++ }
++ }
++ break;
++ case MT_FIELD:
++ s->mv_type = MV_TYPE_FIELD;
++ if (s->picture_structure == PICT_FRAME) {
++ mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
++ for(j=0;j<2;j++) {
++ s->field_select[i][j] = get_bits1(&s->gb);
++ val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
++ s->last_mv[i][j][0]);
++ s->last_mv[i][j][0] = val;
++ s->mv[i][j][0] = val;
++ dprintf("fmx=%d\n", val);
++ val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
++ s->last_mv[i][j][1] >> 1);
++ s->last_mv[i][j][1] = val << 1;
++ s->mv[i][j][1] = val;
++ dprintf("fmy=%d\n", val);
++ }
++ } else {
++ mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
++ s->field_select[i][0] = get_bits1(&s->gb);
++ for(k=0;k<2;k++) {
++ val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
++ s->last_mv[i][0][k]);
++ s->last_mv[i][0][k] = val;
++ s->last_mv[i][1][k] = val;
++ s->mv[i][0][k] = val;
++ }
++ }
++ break;
++ case MT_DMV:
++ {
++ int dmx, dmy, mx, my, m;
++
++ mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
++ s->last_mv[i][0][0]);
++ s->last_mv[i][0][0] = mx;
++ s->last_mv[i][1][0] = mx;
++ dmx = get_dmv(s);
++ my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
++ s->last_mv[i][0][1] >> 1);
++ dmy = get_dmv(s);
++ s->mv_type = MV_TYPE_DMV;
++
++
++ s->last_mv[i][0][1] = my<<1;
++ s->last_mv[i][1][1] = my<<1;
++
++ s->mv[i][0][0] = mx;
++ s->mv[i][0][1] = my;
++ s->mv[i][1][0] = mx;//not used
++ s->mv[i][1][1] = my;//not used
++
++ if (s->picture_structure == PICT_FRAME) {
++ mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
++
++ //m = 1 + 2 * s->top_field_first;
++ m = s->top_field_first ? 1 : 3;
++
++ /* top -> top pred */
++ s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
++ s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
++ m = 4 - m;
++ s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
++ s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
++ } else {
++ mb_type |= MB_TYPE_16x16;
++
++ s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
++ s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
++ if(s->picture_structure == PICT_TOP_FIELD)
++ s->mv[i][2][1]--;
++ else
++ s->mv[i][2][1]++;
++ }
++ }
++ break;
++ default:
++ av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
++ return -1;
++ }
++ }
+ }
+ }
+
+- block[j] = level;
+- if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
+- break;
+- UPDATE_CACHE(re, &s->gb);
+- }
+-end:
+- LAST_SKIP_BITS(re, &s->gb, 2);
+- CLOSE_READER(re, &s->gb);
+- s->block_last_index[n] = i;
+- return 0;
+-}
+-
++ s->mb_intra = 0;
++ if (HAS_CBP(mb_type)) {
++ s->dsp.clear_blocks(s->block[0]);
++
++ if(!s->chroma_y_shift){
++ s->dsp.clear_blocks(s->block[6]);
++ }
+
+-static inline int mpeg2_decode_block_intra(MpegEncContext *s,
+- DCTELEM *block,
+- int n)
+-{
+- int level, dc, diff, i, j, run;
+- int component;
+- RLTable *rl;
+- uint8_t * const scantable= s->intra_scantable.permutated;
+- const uint16_t *quant_matrix;
+- const int qscale= s->qscale;
+- int mismatch;
++ cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
++ if (cbp < 0 || ((cbp == 0) && (s->chroma_format < 2)) ){
++ av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
++ return -1;
++ }
++ if(mb_block_count > 6){
++ cbp<<= mb_block_count-6;
++ cbp |= get_bits(&s->gb, mb_block_count-6);
++ }
+
+- /* DC coef */
+- if (n < 4){
+- quant_matrix = s->intra_matrix;
+- component = 0;
+- }else{
+- quant_matrix = s->chroma_intra_matrix;
+- component = (n&1) + 1;
+- }
+- diff = decode_dc(&s->gb, component);
+- if (diff >= 0xffff)
+- return -1;
+- dc = s->last_dc[component];
+- dc += diff;
+- s->last_dc[component] = dc;
+- block[0] = dc << (3 - s->intra_dc_precision);
+- dprintf("dc=%d\n", block[0]);
+- mismatch = block[0] ^ 1;
+- i = 0;
+- if (s->intra_vlc_format)
+- rl = &rl_mpeg2;
+- else
+- rl = &rl_mpeg1;
++#ifdef HAVE_XVMC
++ //on 1 we memcpy blocks in xvmcvideo
++ if(s->avctx->xvmc_acceleration > 1){
++ XVMC_pack_pblocks(s,cbp);
++ if(s->swap_uv){
++ exchange_uv(s);
++ }
++ }
++#endif
+
+- {
+- OPEN_READER(re, &s->gb);
+- /* now quantify & encode AC coefs */
+- for(;;) {
+- UPDATE_CACHE(re, &s->gb);
+- GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
+-
+- if(level == 127){
+- break;
+- } else if(level != 0) {
+- i += run;
+- j = scantable[i];
+- level= (level*qscale*quant_matrix[j])>>4;
+- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+- LAST_SKIP_BITS(re, &s->gb, 1);
++ if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
++ if(s->flags2 & CODEC_FLAG2_FAST){
++ for(i=0;i<6;i++) {
++ if(cbp & 32) {
++ mpeg2_fast_decode_block_non_intra(s, s->pblocks[i], i);
++ } else {
++ s->block_last_index[i] = -1;
++ }
++ cbp+=cbp;
++ }
++ }else{
++ cbp<<= 12-mb_block_count;
++
++ for(i=0;i<mb_block_count;i++) {
++ if ( cbp & (1<<11) ) {
++ if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
++ return -1;
++ } else {
++ s->block_last_index[i] = -1;
++ }
++ cbp+=cbp;
++ }
++ }
+ } else {
+- /* escape */
+- run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
+- UPDATE_CACHE(re, &s->gb);
+- level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
+- i += run;
+- j = scantable[i];
+- if(level<0){
+- level= (-level*qscale*quant_matrix[j])>>4;
+- level= -level;
++ if(s->flags2 & CODEC_FLAG2_FAST){
++ for(i=0;i<6;i++) {
++ if (cbp & 32) {
++ mpeg1_fast_decode_block_inter(s, s->pblocks[i], i);
++ } else {
++ s->block_last_index[i] = -1;
++ }
++ cbp+=cbp;
++ }
+ }else{
+- level= (level*qscale*quant_matrix[j])>>4;
++ for(i=0;i<6;i++) {
++ if (cbp & 32) {
++ if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0)
++ return -1;
++ } else {
++ s->block_last_index[i] = -1;
++ }
++ cbp+=cbp;
++ }
+ }
+ }
+- if (i > 63){
+- av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
+- return -1;
+- }
+-
+- mismatch^= level;
+- block[j] = level;
++ }else{
++ for(i=0;i<6;i++)
++ s->block_last_index[i] = -1;
+ }
+- CLOSE_READER(re, &s->gb);
+ }
+- block[63]^= mismatch&1;
+-
+- s->block_last_index[n] = i;
++
++ s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
++
+ return 0;
+ }
+
+-static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
+- DCTELEM *block,
+- int n)
++/* as h263, but only 17 codes */
++static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
+ {
+- int level, dc, diff, j, run;
+- int component;
+- RLTable *rl;
+- uint8_t * scantable= s->intra_scantable.permutated;
+- const uint16_t *quant_matrix;
+- const int qscale= s->qscale;
++ int code, sign, val, l, shift;
+
+- /* DC coef */
+- if (n < 4){
+- quant_matrix = s->intra_matrix;
+- component = 0;
+- }else{
+- quant_matrix = s->chroma_intra_matrix;
+- component = (n&1) + 1;
++ code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
++ if (code == 0) {
++ return pred;
++ }
++ if (code < 0) {
++ return 0xffff;
+ }
+- diff = decode_dc(&s->gb, component);
+- if (diff >= 0xffff)
+- return -1;
+- dc = s->last_dc[component];
+- dc += diff;
+- s->last_dc[component] = dc;
+- block[0] = dc << (3 - s->intra_dc_precision);
+- if (s->intra_vlc_format)
+- rl = &rl_mpeg2;
+- else
+- rl = &rl_mpeg1;
+
+- {
+- OPEN_READER(re, &s->gb);
+- /* now quantify & encode AC coefs */
+- for(;;) {
+- UPDATE_CACHE(re, &s->gb);
+- GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
+-
+- if(level == 127){
+- break;
+- } else if(level != 0) {
+- scantable += run;
+- j = *scantable;
+- level= (level*qscale*quant_matrix[j])>>4;
+- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+- LAST_SKIP_BITS(re, &s->gb, 1);
+- } else {
+- /* escape */
+- run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
+- UPDATE_CACHE(re, &s->gb);
+- level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
+- scantable += run;
+- j = *scantable;
+- if(level<0){
+- level= (-level*qscale*quant_matrix[j])>>4;
+- level= -level;
+- }else{
+- level= (level*qscale*quant_matrix[j])>>4;
+- }
+- }
+-
+- block[j] = level;
+- }
+- CLOSE_READER(re, &s->gb);
++ sign = get_bits1(&s->gb);
++ shift = fcode - 1;
++ val = code;
++ if (shift) {
++ val = (val - 1) << shift;
++ val |= get_bits(&s->gb, shift);
++ val++;
+ }
++ if (sign)
++ val = -val;
++ val += pred;
+
+- s->block_last_index[n] = scantable - s->intra_scantable.permutated;
+- return 0;
++ /* modulo decoding */
++ l= INT_BIT - 5 - shift;
++ val = (val<<l)>>l;
++ return val;
+ }
+
+ typedef struct Mpeg1Context {
--- /home/melanson/temp/ffmpeg/libavcodec/mpegvideo.c 2005-05-05 20:53:15.787522800 -0600
+++ libavcodec/mpegvideo.c 2005-05-05 21:35:14.680592848 -0600
@@ -38,6 +38,14 @@
@@ -404,6 +2201,17 @@
}
--- /home/melanson/temp/ffmpeg/libavcodec/msmpeg4.c 2005-05-05 20:53:15.794521736 -0600
+++ libavcodec/msmpeg4.c 2005-05-05 21:30:43.786774968 -0600
+@@ -59,9 +59,7 @@
+ static uint32_t v2_dc_lum_table[512][2];
+ static uint32_t v2_dc_chroma_table[512][2];
+
+-static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
+-static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
+- int n, int coded, const uint8_t *scantable);
++static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr);
+ static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
+ static int msmpeg4_decode_motion(MpegEncContext * s,
+ int *mx_ptr, int *my_ptr);
@@ -179,8 +179,11 @@
break;
#if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC9_DECODER)
@@ -415,6 +2223,646 @@
+#endif /* #if 0 */
break;
#endif
+
+@@ -536,6 +534,129 @@
+ }
+ }
+
++/* Encoding of a block. Very similar to MPEG4 except for a different
++ escape coding (same as H263) and more vlc tables.
++ */
++static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
++{
++ int level, run, last, i, j, last_index;
++ int last_non_zero, sign, slevel;
++ int code, run_diff, dc_pred_dir;
++ const RLTable *rl;
++ const uint8_t *scantable;
++
++ if (s->mb_intra) {
++ set_stat(ST_DC);
++ msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
++ i = 1;
++ if (n < 4) {
++ rl = &rl_table[s->rl_table_index];
++ } else {
++ rl = &rl_table[3 + s->rl_chroma_table_index];
++ }
++ run_diff = 0;
++ scantable= s->intra_scantable.permutated;
++ set_stat(ST_INTRA_AC);
++ } else {
++ i = 0;
++ rl = &rl_table[3 + s->rl_table_index];
++ if(s->msmpeg4_version<=2)
++ run_diff = 0;
++ else
++ run_diff = 1;
++ scantable= s->inter_scantable.permutated;
++ set_stat(ST_INTER_AC);
++ }
++
++ /* recalculate block_last_index for M$ wmv1 */
++ if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
++ for(last_index=63; last_index>=0; last_index--){
++ if(block[scantable[last_index]]) break;
++ }
++ s->block_last_index[n]= last_index;
++ }else
++ last_index = s->block_last_index[n];
++ /* AC coefs */
++ last_non_zero = i - 1;
++ for (; i <= last_index; i++) {
++ j = scantable[i];
++ level = block[j];
++ if (level) {
++ run = i - last_non_zero - 1;
++ last = (i == last_index);
++ sign = 0;
++ slevel = level;
++ if (level < 0) {
++ sign = 1;
++ level = -level;
++ }
++
++ if(level<=MAX_LEVEL && run<=MAX_RUN){
++ s->ac_stats[s->mb_intra][n>3][level][run][last]++;
++ }
++#if 0
++else
++ s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
++#endif
++ code = get_rl_index(rl, last, run, level);
++ put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
++ if (code == rl->n) {
++ int level1, run1;
++
++ level1 = level - rl->max_level[last][run];
++ if (level1 < 1)
++ goto esc2;
++ code = get_rl_index(rl, last, run, level1);
++ if (code == rl->n) {
++ esc2:
++ put_bits(&s->pb, 1, 0);
++ if (level > MAX_LEVEL)
++ goto esc3;
++ run1 = run - rl->max_run[last][level] - run_diff;
++ if (run1 < 0)
++ goto esc3;
++ code = get_rl_index(rl, last, run1, level);
++ if (code == rl->n) {
++ esc3:
++ /* third escape */
++ put_bits(&s->pb, 1, 0);
++ put_bits(&s->pb, 1, last);
++ if(s->msmpeg4_version>=4){
++ if(s->esc3_level_length==0){
++ s->esc3_level_length=8;
++ s->esc3_run_length= 6;
++ if(s->qscale<8)
++ put_bits(&s->pb, 6, 3);
++ else
++ put_bits(&s->pb, 8, 3);
++ }
++ put_bits(&s->pb, s->esc3_run_length, run);
++ put_bits(&s->pb, 1, sign);
++ put_bits(&s->pb, s->esc3_level_length, level);
++ }else{
++ put_bits(&s->pb, 6, run);
++ put_bits(&s->pb, 8, slevel & 0xff);
++ }
++ } else {
++ /* second escape */
++ put_bits(&s->pb, 1, 1);
++ put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
++ put_bits(&s->pb, 1, sign);
++ }
++ } else {
++ /* first escape */
++ put_bits(&s->pb, 1, 1);
++ put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
++ put_bits(&s->pb, 1, sign);
++ }
++ } else {
++ put_bits(&s->pb, 1, sign);
++ }
++ last_non_zero = i;
++ }
++ }
++}
++
+ void msmpeg4_encode_mb(MpegEncContext * s,
+ DCTELEM block[6][64],
+ int motion_x, int motion_y)
+@@ -915,129 +1036,6 @@
+ }
+ }
+
+-/* Encoding of a block. Very similar to MPEG4 except for a different
+- escape coding (same as H263) and more vlc tables.
+- */
+-static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
+-{
+- int level, run, last, i, j, last_index;
+- int last_non_zero, sign, slevel;
+- int code, run_diff, dc_pred_dir;
+- const RLTable *rl;
+- const uint8_t *scantable;
+-
+- if (s->mb_intra) {
+- set_stat(ST_DC);
+- msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
+- i = 1;
+- if (n < 4) {
+- rl = &rl_table[s->rl_table_index];
+- } else {
+- rl = &rl_table[3 + s->rl_chroma_table_index];
+- }
+- run_diff = 0;
+- scantable= s->intra_scantable.permutated;
+- set_stat(ST_INTRA_AC);
+- } else {
+- i = 0;
+- rl = &rl_table[3 + s->rl_table_index];
+- if(s->msmpeg4_version<=2)
+- run_diff = 0;
+- else
+- run_diff = 1;
+- scantable= s->inter_scantable.permutated;
+- set_stat(ST_INTER_AC);
+- }
+-
+- /* recalculate block_last_index for M$ wmv1 */
+- if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
+- for(last_index=63; last_index>=0; last_index--){
+- if(block[scantable[last_index]]) break;
+- }
+- s->block_last_index[n]= last_index;
+- }else
+- last_index = s->block_last_index[n];
+- /* AC coefs */
+- last_non_zero = i - 1;
+- for (; i <= last_index; i++) {
+- j = scantable[i];
+- level = block[j];
+- if (level) {
+- run = i - last_non_zero - 1;
+- last = (i == last_index);
+- sign = 0;
+- slevel = level;
+- if (level < 0) {
+- sign = 1;
+- level = -level;
+- }
+-
+- if(level<=MAX_LEVEL && run<=MAX_RUN){
+- s->ac_stats[s->mb_intra][n>3][level][run][last]++;
+- }
+-#if 0
+-else
+- s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
+-#endif
+- code = get_rl_index(rl, last, run, level);
+- put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+- if (code == rl->n) {
+- int level1, run1;
+-
+- level1 = level - rl->max_level[last][run];
+- if (level1 < 1)
+- goto esc2;
+- code = get_rl_index(rl, last, run, level1);
+- if (code == rl->n) {
+- esc2:
+- put_bits(&s->pb, 1, 0);
+- if (level > MAX_LEVEL)
+- goto esc3;
+- run1 = run - rl->max_run[last][level] - run_diff;
+- if (run1 < 0)
+- goto esc3;
+- code = get_rl_index(rl, last, run1, level);
+- if (code == rl->n) {
+- esc3:
+- /* third escape */
+- put_bits(&s->pb, 1, 0);
+- put_bits(&s->pb, 1, last);
+- if(s->msmpeg4_version>=4){
+- if(s->esc3_level_length==0){
+- s->esc3_level_length=8;
+- s->esc3_run_length= 6;
+- if(s->qscale<8)
+- put_bits(&s->pb, 6, 3);
+- else
+- put_bits(&s->pb, 8, 3);
+- }
+- put_bits(&s->pb, s->esc3_run_length, run);
+- put_bits(&s->pb, 1, sign);
+- put_bits(&s->pb, s->esc3_level_length, level);
+- }else{
+- put_bits(&s->pb, 6, run);
+- put_bits(&s->pb, 8, slevel & 0xff);
+- }
+- } else {
+- /* second escape */
+- put_bits(&s->pb, 1, 1);
+- put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+- put_bits(&s->pb, 1, sign);
+- }
+- } else {
+- /* first escape */
+- put_bits(&s->pb, 1, 1);
+- put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+- put_bits(&s->pb, 1, sign);
+- }
+- } else {
+- put_bits(&s->pb, 1, sign);
+- }
+- last_non_zero = i;
+- }
+- }
+-}
+-
+ /****************************************/
+ /* decoding stuff */
+
+@@ -1482,188 +1480,9 @@
+ return val;
+ }
+
+-static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
+-{
+- int cbp, code, i;
+-
+- if (s->pict_type == P_TYPE) {
+- if (s->use_skip_mb_code) {
+- if (get_bits1(&s->gb)) {
+- /* skip mb */
+- s->mb_intra = 0;
+- for(i=0;i<6;i++)
+- s->block_last_index[i] = -1;
+- s->mv_dir = MV_DIR_FORWARD;
+- s->mv_type = MV_TYPE_16X16;
+- s->mv[0][0][0] = 0;
+- s->mv[0][0][1] = 0;
+- s->mb_skipped = 1;
+- return 0;
+- }
+- }
+-
+- if(s->msmpeg4_version==2)
+- code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
+- else
+- code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
+- if(code<0 || code>7){
+- av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
+- return -1;
+- }
+-
+- s->mb_intra = code >>2;
+-
+- cbp = code & 0x3;
+- } else {
+- s->mb_intra = 1;
+- if(s->msmpeg4_version==2)
+- cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
+- else
+- cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
+- if(cbp<0 || cbp>3){
+- av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
+- return -1;
+- }
+- }
+-
+- if (!s->mb_intra) {
+- int mx, my, cbpy;
+-
+- cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
+- if(cbpy<0){
+- av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
+- return -1;
+- }
+-
+- cbp|= cbpy<<2;
+- if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
+-
+- h263_pred_motion(s, 0, 0, &mx, &my);
+- mx= msmpeg4v2_decode_motion(s, mx, 1);
+- my= msmpeg4v2_decode_motion(s, my, 1);
+-
+- s->mv_dir = MV_DIR_FORWARD;
+- s->mv_type = MV_TYPE_16X16;
+- s->mv[0][0][0] = mx;
+- s->mv[0][0][1] = my;
+- } else {
+- if(s->msmpeg4_version==2){
+- s->ac_pred = get_bits1(&s->gb);
+- cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
+- } else{
+- s->ac_pred = 0;
+- cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
+- if(s->pict_type==P_TYPE) cbp^=0x3C;
+- }
+- }
+-
+- s->dsp.clear_blocks(s->block[0]);
+- for (i = 0; i < 6; i++) {
+- if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
+- {
+- av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
+- return -1;
+- }
+- }
+- return 0;
+-}
+-
+-static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
+-{
+- int cbp, code, i;
+- uint8_t *coded_val;
+- uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
+-
+- if (s->pict_type == P_TYPE) {
+- set_stat(ST_INTER_MB);
+- if (s->use_skip_mb_code) {
+- if (get_bits1(&s->gb)) {
+- /* skip mb */
+- s->mb_intra = 0;
+- for(i=0;i<6;i++)
+- s->block_last_index[i] = -1;
+- s->mv_dir = MV_DIR_FORWARD;
+- s->mv_type = MV_TYPE_16X16;
+- s->mv[0][0][0] = 0;
+- s->mv[0][0][1] = 0;
+- s->mb_skipped = 1;
+- *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
+-
+- return 0;
+- }
+- }
+-
+- code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
+- if (code < 0)
+- return -1;
+- //s->mb_intra = (code & 0x40) ? 0 : 1;
+- s->mb_intra = (~code & 0x40) >> 6;
+-
+- cbp = code & 0x3f;
+- } else {
+- set_stat(ST_INTRA_MB);
+- s->mb_intra = 1;
+- code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
+- if (code < 0)
+- return -1;
+- /* predict coded block pattern */
+- cbp = 0;
+- for(i=0;i<6;i++) {
+- int val = ((code >> (5 - i)) & 1);
+- if (i < 4) {
+- int pred = coded_block_pred(s, i, &coded_val);
+- val = val ^ pred;
+- *coded_val = val;
+- }
+- cbp |= val << (5 - i);
+- }
+- }
+-
+- if (!s->mb_intra) {
+- int mx, my;
+-//printf("P at %d %d\n", s->mb_x, s->mb_y);
+- if(s->per_mb_rl_table && cbp){
+- s->rl_table_index = decode012(&s->gb);
+- s->rl_chroma_table_index = s->rl_table_index;
+- }
+- set_stat(ST_MV);
+- h263_pred_motion(s, 0, 0, &mx, &my);
+- if (msmpeg4_decode_motion(s, &mx, &my) < 0)
+- return -1;
+- s->mv_dir = MV_DIR_FORWARD;
+- s->mv_type = MV_TYPE_16X16;
+- s->mv[0][0][0] = mx;
+- s->mv[0][0][1] = my;
+- *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
+- } else {
+-//printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24));
+- set_stat(ST_INTRA_MB);
+- s->ac_pred = get_bits1(&s->gb);
+- *mb_type_ptr = MB_TYPE_INTRA;
+- if(s->inter_intra_pred){
+- s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
+-// printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
+- }
+- if(s->per_mb_rl_table && cbp){
+- s->rl_table_index = decode012(&s->gb);
+- s->rl_chroma_table_index = s->rl_table_index;
+- }
+- }
+-
+- s->dsp.clear_blocks(s->block[0]);
+- for (i = 0; i < 6; i++) {
+- if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
+- {
+- av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
+- return -1;
+- }
+- }
+-
+- return 0;
+-}
+-//#define ERROR_DETAILS
+-static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
+- int n, int coded, const uint8_t *scan_table)
++//#define ERROR_DETAILS
++static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
++ int n, int coded, const uint8_t *scan_table)
+ {
+ int level, i, last, run, run_diff;
+ int dc_pred_dir;
+@@ -1912,6 +1731,186 @@
+ return 0;
+ }
+
++static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
++{
++ int cbp, code, i;
++
++ if (s->pict_type == P_TYPE) {
++ if (s->use_skip_mb_code) {
++ if (get_bits1(&s->gb)) {
++ /* skip mb */
++ s->mb_intra = 0;
++ for(i=0;i<6;i++)
++ s->block_last_index[i] = -1;
++ s->mv_dir = MV_DIR_FORWARD;
++ s->mv_type = MV_TYPE_16X16;
++ s->mv[0][0][0] = 0;
++ s->mv[0][0][1] = 0;
++ s->mb_skipped = 1;
++ return 0;
++ }
++ }
++
++ if(s->msmpeg4_version==2)
++ code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
++ else
++ code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
++ if(code<0 || code>7){
++ av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
++ return -1;
++ }
++
++ s->mb_intra = code >>2;
++
++ cbp = code & 0x3;
++ } else {
++ s->mb_intra = 1;
++ if(s->msmpeg4_version==2)
++ cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
++ else
++ cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
++ if(cbp<0 || cbp>3){
++ av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
++ return -1;
++ }
++ }
++
++ if (!s->mb_intra) {
++ int mx, my, cbpy;
++
++ cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
++ if(cbpy<0){
++ av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
++ return -1;
++ }
++
++ cbp|= cbpy<<2;
++ if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
++
++ h263_pred_motion(s, 0, 0, &mx, &my);
++ mx= msmpeg4v2_decode_motion(s, mx, 1);
++ my= msmpeg4v2_decode_motion(s, my, 1);
++
++ s->mv_dir = MV_DIR_FORWARD;
++ s->mv_type = MV_TYPE_16X16;
++ s->mv[0][0][0] = mx;
++ s->mv[0][0][1] = my;
++ } else {
++ if(s->msmpeg4_version==2){
++ s->ac_pred = get_bits1(&s->gb);
++ cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
++ } else{
++ s->ac_pred = 0;
++ cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
++ if(s->pict_type==P_TYPE) cbp^=0x3C;
++ }
++ }
++
++ s->dsp.clear_blocks(s->block[0]);
++ for (i = 0; i < 6; i++) {
++ if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
++ {
++ av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
++ return -1;
++ }
++ }
++ return 0;
++}
++
++static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
++{
++ int cbp, code, i;
++ uint8_t *coded_val;
++ uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
++
++ if (s->pict_type == P_TYPE) {
++ set_stat(ST_INTER_MB);
++ if (s->use_skip_mb_code) {
++ if (get_bits1(&s->gb)) {
++ /* skip mb */
++ s->mb_intra = 0;
++ for(i=0;i<6;i++)
++ s->block_last_index[i] = -1;
++ s->mv_dir = MV_DIR_FORWARD;
++ s->mv_type = MV_TYPE_16X16;
++ s->mv[0][0][0] = 0;
++ s->mv[0][0][1] = 0;
++ s->mb_skipped = 1;
++ *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
++
++ return 0;
++ }
++ }
++
++ code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
++ if (code < 0)
++ return -1;
++ //s->mb_intra = (code & 0x40) ? 0 : 1;
++ s->mb_intra = (~code & 0x40) >> 6;
++
++ cbp = code & 0x3f;
++ } else {
++ set_stat(ST_INTRA_MB);
++ s->mb_intra = 1;
++ code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
++ if (code < 0)
++ return -1;
++ /* predict coded block pattern */
++ cbp = 0;
++ for(i=0;i<6;i++) {
++ int val = ((code >> (5 - i)) & 1);
++ if (i < 4) {
++ int pred = coded_block_pred(s, i, &coded_val);
++ val = val ^ pred;
++ *coded_val = val;
++ }
++ cbp |= val << (5 - i);
++ }
++ }
++
++ if (!s->mb_intra) {
++ int mx, my;
++//printf("P at %d %d\n", s->mb_x, s->mb_y);
++ if(s->per_mb_rl_table && cbp){
++ s->rl_table_index = decode012(&s->gb);
++ s->rl_chroma_table_index = s->rl_table_index;
++ }
++ set_stat(ST_MV);
++ h263_pred_motion(s, 0, 0, &mx, &my);
++ if (msmpeg4_decode_motion(s, &mx, &my) < 0)
++ return -1;
++ s->mv_dir = MV_DIR_FORWARD;
++ s->mv_type = MV_TYPE_16X16;
++ s->mv[0][0][0] = mx;
++ s->mv[0][0][1] = my;
++ *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
++ } else {
++//printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24));
++ set_stat(ST_INTRA_MB);
++ s->ac_pred = get_bits1(&s->gb);
++ *mb_type_ptr = MB_TYPE_INTRA;
++ if(s->inter_intra_pred){
++ s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
++// printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
++ }
++ if(s->per_mb_rl_table && cbp){
++ s->rl_table_index = decode012(&s->gb);
++ s->rl_chroma_table_index = s->rl_table_index;
++ }
++ }
++
++ s->dsp.clear_blocks(s->block[0]);
++ for (i = 0; i < 6; i++) {
++ if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
++ {
++ av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
++ return -1;
++ }
++ }
++
++ return 0;
++}
++
+ static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
+ {
+ int level, pred;
--- libavcodec/dsputil.c 6 May 2005 04:19:18 -0000 1.38
+++ libavcodec/dsputil.c 7 May 2005 16:24:36 -0000
@@ -371,6 +371,8 @@
@@ -428,6 +2876,1400 @@
--- libavcodec/h263.c 6 May 2005 04:19:18 -0000 1.44
+++ libavcodec/h263.c 7 May 2005 17:03:48 -0000
+@@ -57,18 +57,12 @@
+ static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
+ int n);
+ static void h263p_encode_umotion(MpegEncContext * s, int val);
+-static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
+- int n, int dc, uint8_t *scan_table,
+- PutBitContext *dc_pb, PutBitContext *ac_pb);
+ #endif
+
+ static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
+ static int h263p_decode_umotion(MpegEncContext * s, int pred);
+ static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
+ int n, int coded);
+-static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
+-static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
+- int n, int coded, int intra, int rvlc);
+ static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
+ uint8_t *scan_table);
+ static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
+@@ -77,7 +71,6 @@
+ static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
+ #endif //CONFIG_ENCODERS
+ static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
+-static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
+
+ #ifdef CONFIG_ENCODERS
+ static uint8_t uni_DCtab_lum_len[512];
+@@ -664,6 +657,85 @@
+ }
+ }
+
++/**
++ * predicts the dc.
++ * encoding quantized level -> quantized diff
++ * decoding quantized diff -> quantized level
++ * @param n block index (0-3 are luma, 4-5 are chroma)
++ * @param dir_ptr pointer to an integer where the prediction direction will be stored
++ */
++static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
++{
++ int a, b, c, wrap, pred, scale, ret;
++ uint16_t *dc_val;
++
++ /* find prediction */
++ if (n < 4) {
++ scale = s->y_dc_scale;
++ } else {
++ scale = s->c_dc_scale;
++ }
++ if(IS_3IV1)
++ scale= 8;
++
++ wrap= s->block_wrap[n];
++ dc_val = s->dc_val[0] + s->block_index[n];
++
++ /* B C
++ * A X
++ */
++ a = dc_val[ - 1];
++ b = dc_val[ - 1 - wrap];
++ c = dc_val[ - wrap];
++
++ /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
++ if(s->first_slice_line && n!=3){
++ if(n!=2) b=c= 1024;
++ if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
++ }
++ if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
++ if(n==0 || n==4 || n==5)
++ b=1024;
++ }
++
++ if (abs(a - b) < abs(b - c)) {
++ pred = c;
++ *dir_ptr = 1; /* top */
++ } else {
++ pred = a;
++ *dir_ptr = 0; /* left */
++ }
++ /* we assume pred is positive */
++ pred = FASTDIV((pred + (scale >> 1)), scale);
++
++ if(encoding){
++ ret = level - pred;
++ }else{
++ level += pred;
++ ret= level;
++ if(s->error_resilience>=3){
++ if(level<0){
++ av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
++ return -1;
++ }
++ if(level*scale > 2048 + scale){
++ av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
++ return -1;
++ }
++ }
++ }
++ level *=scale;
++ if(level&(~2047)){
++ if(level<0)
++ level=0;
++ else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
++ level=2047;
++ }
++ dc_val[0]= level;
++
++ return ret;
++}
++
+ #ifdef CONFIG_ENCODERS
+
+ static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
+@@ -793,6 +865,179 @@
+ return cbp;
+ }
+
++/**
++ * encodes the dc value.
++ * @param n block index (0-3 are luma, 4-5 are chroma)
++ */
++static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
++{
++#if 1
++// if(level<-255 || level>255) printf("dc overflow\n");
++ level+=256;
++ if (n < 4) {
++ /* luminance */
++ put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
++ } else {
++ /* chrominance */
++ put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
++ }
++#else
++ int size, v;
++ /* find number of bits */
++ size = 0;
++ v = abs(level);
++ while (v) {
++ v >>= 1;
++ size++;
++ }
++
++ if (n < 4) {
++ /* luminance */
++ put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
++ } else {
++ /* chrominance */
++ put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
++ }
++
++ /* encode remaining bits */
++ if (size > 0) {
++ if (level < 0)
++ level = (-level) ^ ((1 << size) - 1);
++ put_bits(&s->pb, size, level);
++ if (size > 8)
++ put_bits(&s->pb, 1, 1);
++ }
++#endif
++}
++
++static inline int mpeg4_get_dc_length(int level, int n){
++ if (n < 4) {
++ return uni_DCtab_lum_len[level + 256];
++ } else {
++ return uni_DCtab_chrom_len[level + 256];
++ }
++}
++
++/**
++ * encodes a 8x8 block
++ * @param n block index (0-3 are luma, 4-5 are chroma)
++ */
++static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
++ uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
++{
++ int i, last_non_zero;
++#if 0 //variables for the outcommented version
++ int code, sign, last;
++#endif
++ const RLTable *rl;
++ uint32_t *bits_tab;
++ uint8_t *len_tab;
++ const int last_index = s->block_last_index[n];
++
++ if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
++ /* mpeg4 based DC predictor */
++ mpeg4_encode_dc(dc_pb, intra_dc, n);
++ if(last_index<1) return;
++ i = 1;
++ rl = &rl_intra;
++ bits_tab= uni_mpeg4_intra_rl_bits;
++ len_tab = uni_mpeg4_intra_rl_len;
++ } else {
++ if(last_index<0) return;
++ i = 0;
++ rl = &rl_inter;
++ bits_tab= uni_mpeg4_inter_rl_bits;
++ len_tab = uni_mpeg4_inter_rl_len;
++ }
++
++ /* AC coefs */
++ last_non_zero = i - 1;
++#if 1
++ for (; i < last_index; i++) {
++ int level = block[ scan_table[i] ];
++ if (level) {
++ int run = i - last_non_zero - 1;
++ level+=64;
++ if((level&(~127)) == 0){
++ const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
++ put_bits(ac_pb, len_tab[index], bits_tab[index]);
++ }else{ //ESC3
++ put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
++ }
++ last_non_zero = i;
++ }
++ }
++ /*if(i<=last_index)*/{
++ int level = block[ scan_table[i] ];
++ int run = i - last_non_zero - 1;
++ level+=64;
++ if((level&(~127)) == 0){
++ const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
++ put_bits(ac_pb, len_tab[index], bits_tab[index]);
++ }else{ //ESC3
++ put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
++ }
++ }
++#else
++ for (; i <= last_index; i++) {
++ const int slevel = block[ scan_table[i] ];
++ if (slevel) {
++ int level;
++ int run = i - last_non_zero - 1;
++ last = (i == last_index);
++ sign = 0;
++ level = slevel;
++ if (level < 0) {
++ sign = 1;
++ level = -level;
++ }
++ code = get_rl_index(rl, last, run, level);
++ put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
++ if (code == rl->n) {
++ int level1, run1;
++ level1 = level - rl->max_level[last][run];
++ if (level1 < 1)
++ goto esc2;
++ code = get_rl_index(rl, last, run, level1);
++ if (code == rl->n) {
++ esc2:
++ put_bits(ac_pb, 1, 1);
++ if (level > MAX_LEVEL)
++ goto esc3;
++ run1 = run - rl->max_run[last][level] - 1;
++ if (run1 < 0)
++ goto esc3;
++ code = get_rl_index(rl, last, run1, level);
++ if (code == rl->n) {
++ esc3:
++ /* third escape */
++ put_bits(ac_pb, 1, 1);
++ put_bits(ac_pb, 1, last);
++ put_bits(ac_pb, 6, run);
++ put_bits(ac_pb, 1, 1);
++ put_bits(ac_pb, 12, slevel & 0xfff);
++ put_bits(ac_pb, 1, 1);
++ } else {
++ /* second escape */
++ put_bits(ac_pb, 1, 0);
++ put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
++ put_bits(ac_pb, 1, sign);
++ }
++ } else {
++ /* first escape */
++ put_bits(ac_pb, 1, 0);
++ put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
++ put_bits(ac_pb, 1, sign);
++ }
++ } else {
++ put_bits(ac_pb, 1, sign);
++ }
++ last_non_zero = i;
++ }
++ }
++#endif
++}
++
+ static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
+ uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
+ int i;
+@@ -2478,85 +2723,6 @@
+ }
+
+ /**
+- * predicts the dc.
+- * encoding quantized level -> quantized diff
+- * decoding quantized diff -> quantized level
+- * @param n block index (0-3 are luma, 4-5 are chroma)
+- * @param dir_ptr pointer to an integer where the prediction direction will be stored
+- */
+-static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
+-{
+- int a, b, c, wrap, pred, scale, ret;
+- uint16_t *dc_val;
+-
+- /* find prediction */
+- if (n < 4) {
+- scale = s->y_dc_scale;
+- } else {
+- scale = s->c_dc_scale;
+- }
+- if(IS_3IV1)
+- scale= 8;
+-
+- wrap= s->block_wrap[n];
+- dc_val = s->dc_val[0] + s->block_index[n];
+-
+- /* B C
+- * A X
+- */
+- a = dc_val[ - 1];
+- b = dc_val[ - 1 - wrap];
+- c = dc_val[ - wrap];
+-
+- /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
+- if(s->first_slice_line && n!=3){
+- if(n!=2) b=c= 1024;
+- if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
+- }
+- if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
+- if(n==0 || n==4 || n==5)
+- b=1024;
+- }
+-
+- if (abs(a - b) < abs(b - c)) {
+- pred = c;
+- *dir_ptr = 1; /* top */
+- } else {
+- pred = a;
+- *dir_ptr = 0; /* left */
+- }
+- /* we assume pred is positive */
+- pred = FASTDIV((pred + (scale >> 1)), scale);
+-
+- if(encoding){
+- ret = level - pred;
+- }else{
+- level += pred;
+- ret= level;
+- if(s->error_resilience>=3){
+- if(level<0){
+- av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
+- return -1;
+- }
+- if(level*scale > 2048 + scale){
+- av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
+- return -1;
+- }
+- }
+- }
+- level *=scale;
+- if(level&(~2047)){
+- if(level<0)
+- level=0;
+- else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
+- level=2047;
+- }
+- dc_val[0]= level;
+-
+- return ret;
+-}
+-
+-/**
+ * predicts the ac.
+ * @param n block index (0-3 are luma, 4-5 are chroma)
+ * @param dir the ac prediction direction
+@@ -2618,179 +2784,6 @@
+
+ #ifdef CONFIG_ENCODERS
+
+-/**
+- * encodes the dc value.
+- * @param n block index (0-3 are luma, 4-5 are chroma)
+- */
+-static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
+-{
+-#if 1
+-// if(level<-255 || level>255) printf("dc overflow\n");
+- level+=256;
+- if (n < 4) {
+- /* luminance */
+- put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
+- } else {
+- /* chrominance */
+- put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
+- }
+-#else
+- int size, v;
+- /* find number of bits */
+- size = 0;
+- v = abs(level);
+- while (v) {
+- v >>= 1;
+- size++;
+- }
+-
+- if (n < 4) {
+- /* luminance */
+- put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
+- } else {
+- /* chrominance */
+- put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
+- }
+-
+- /* encode remaining bits */
+- if (size > 0) {
+- if (level < 0)
+- level = (-level) ^ ((1 << size) - 1);
+- put_bits(&s->pb, size, level);
+- if (size > 8)
+- put_bits(&s->pb, 1, 1);
+- }
+-#endif
+-}
+-
+-static inline int mpeg4_get_dc_length(int level, int n){
+- if (n < 4) {
+- return uni_DCtab_lum_len[level + 256];
+- } else {
+- return uni_DCtab_chrom_len[level + 256];
+- }
+-}
+-
+-/**
+- * encodes a 8x8 block
+- * @param n block index (0-3 are luma, 4-5 are chroma)
+- */
+-static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
+- uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
+-{
+- int i, last_non_zero;
+-#if 0 //variables for the outcommented version
+- int code, sign, last;
+-#endif
+- const RLTable *rl;
+- uint32_t *bits_tab;
+- uint8_t *len_tab;
+- const int last_index = s->block_last_index[n];
+-
+- if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
+- /* mpeg4 based DC predictor */
+- mpeg4_encode_dc(dc_pb, intra_dc, n);
+- if(last_index<1) return;
+- i = 1;
+- rl = &rl_intra;
+- bits_tab= uni_mpeg4_intra_rl_bits;
+- len_tab = uni_mpeg4_intra_rl_len;
+- } else {
+- if(last_index<0) return;
+- i = 0;
+- rl = &rl_inter;
+- bits_tab= uni_mpeg4_inter_rl_bits;
+- len_tab = uni_mpeg4_inter_rl_len;
+- }
+-
+- /* AC coefs */
+- last_non_zero = i - 1;
+-#if 1
+- for (; i < last_index; i++) {
+- int level = block[ scan_table[i] ];
+- if (level) {
+- int run = i - last_non_zero - 1;
+- level+=64;
+- if((level&(~127)) == 0){
+- const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
+- put_bits(ac_pb, len_tab[index], bits_tab[index]);
+- }else{ //ESC3
+- put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
+- }
+- last_non_zero = i;
+- }
+- }
+- /*if(i<=last_index)*/{
+- int level = block[ scan_table[i] ];
+- int run = i - last_non_zero - 1;
+- level+=64;
+- if((level&(~127)) == 0){
+- const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
+- put_bits(ac_pb, len_tab[index], bits_tab[index]);
+- }else{ //ESC3
+- put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
+- }
+- }
+-#else
+- for (; i <= last_index; i++) {
+- const int slevel = block[ scan_table[i] ];
+- if (slevel) {
+- int level;
+- int run = i - last_non_zero - 1;
+- last = (i == last_index);
+- sign = 0;
+- level = slevel;
+- if (level < 0) {
+- sign = 1;
+- level = -level;
+- }
+- code = get_rl_index(rl, last, run, level);
+- put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+- if (code == rl->n) {
+- int level1, run1;
+- level1 = level - rl->max_level[last][run];
+- if (level1 < 1)
+- goto esc2;
+- code = get_rl_index(rl, last, run, level1);
+- if (code == rl->n) {
+- esc2:
+- put_bits(ac_pb, 1, 1);
+- if (level > MAX_LEVEL)
+- goto esc3;
+- run1 = run - rl->max_run[last][level] - 1;
+- if (run1 < 0)
+- goto esc3;
+- code = get_rl_index(rl, last, run1, level);
+- if (code == rl->n) {
+- esc3:
+- /* third escape */
+- put_bits(ac_pb, 1, 1);
+- put_bits(ac_pb, 1, last);
+- put_bits(ac_pb, 6, run);
+- put_bits(ac_pb, 1, 1);
+- put_bits(ac_pb, 12, slevel & 0xfff);
+- put_bits(ac_pb, 1, 1);
+- } else {
+- /* second escape */
+- put_bits(ac_pb, 1, 0);
+- put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+- put_bits(ac_pb, 1, sign);
+- }
+- } else {
+- /* first escape */
+- put_bits(ac_pb, 1, 0);
+- put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+- put_bits(ac_pb, 1, sign);
+- }
+- } else {
+- put_bits(ac_pb, 1, sign);
+- }
+- last_non_zero = i;
+- }
+- }
+-#endif
+-}
+-
+ static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
+ uint8_t *scan_table)
+ {
+@@ -3392,10 +3385,57 @@
+ }
+
+ /**
+- * decodes first partition.
+- * @return number of MBs decoded or <0 if an error occured
++ * decodes the dc value.
++ * @param n block index (0-3 are luma, 4-5 are chroma)
++ * @param dir_ptr the prediction direction will be stored here
++ * @return the quantized dc
+ */
+-static int mpeg4_decode_partition_a(MpegEncContext *s){
++static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
++{
++ int level, code;
++
++ if (n < 4)
++ code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
++ else
++ code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
++ if (code < 0 || code > 9 /* && s->nbit<9 */){
++ av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
++ return -1;
++ }
++ if (code == 0) {
++ level = 0;
++ } else {
++ if(IS_3IV1){
++ if(code==1)
++ level= 2*get_bits1(&s->gb)-1;
++ else{
++ if(get_bits1(&s->gb))
++ level = get_bits(&s->gb, code-1) + (1<<(code-1));
++ else
++ level = -get_bits(&s->gb, code-1) - (1<<(code-1));
++ }
++ }else{
++ level = get_xbits(&s->gb, code);
++ }
++
++ if (code > 8){
++ if(get_bits1(&s->gb)==0){ /* marker */
++ if(s->error_resilience>=2){
++ av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
++ return -1;
++ }
++ }
++ }
++ }
++
++ return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
++}
++
++/**
++ * decodes first partition.
++ * @return number of MBs decoded or <0 if an error occured
++ */
++static int mpeg4_decode_partition_a(MpegEncContext *s){
+ int mb_num;
+ static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
+
+@@ -3697,116 +3737,371 @@
+ }
+
+ /**
+- * decode partition C of one MB.
++ * decodes a block.
+ * @return <0 if an error occured
+ */
+-static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
++static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
++ int n, int coded, int intra, int rvlc)
+ {
+- int cbp, mb_type;
+- const int xy= s->mb_x + s->mb_y*s->mb_stride;
+-
+- mb_type= s->current_picture.mb_type[xy];
+- cbp = s->cbp_table[xy];
++ int level, i, last, run;
++ int dc_pred_dir;
++ RLTable * rl;
++ RL_VLC_ELEM * rl_vlc;
++ const uint8_t * scan_table;
++ int qmul, qadd;
+
+- if(s->current_picture.qscale_table[xy] != s->qscale){
+- ff_set_qscale(s, s->current_picture.qscale_table[xy] );
+- }
++ //Note intra & rvlc should be optimized away if this is inlined
+
+- if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
+- int i;
+- for(i=0; i<4; i++){
+- s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
+- s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
++ if(intra) {
++ if(s->qscale < s->intra_dc_threshold){
++ /* DC coef */
++ if(s->partitioned_frame){
++ level = s->dc_val[0][ s->block_index[n] ];
++ if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
++ else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
++ dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
++ }else{
++ level = mpeg4_decode_dc(s, n, &dc_pred_dir);
++ if (level < 0)
++ return -1;
+ }
+- s->mb_intra = IS_INTRA(mb_type);
++ block[0] = level;
++ i = 0;
++ }else{
++ i = -1;
++ }
++ if (!coded)
++ goto not_coded;
++
++ if(rvlc){
++ rl = &rvlc_rl_intra;
++ rl_vlc = rvlc_rl_intra.rl_vlc[0];
++ }else{
++ rl = &rl_intra;
++ rl_vlc = rl_intra.rl_vlc[0];
++ }
++ if (s->ac_pred) {
++ if (dc_pred_dir == 0)
++ scan_table = s->intra_v_scantable.permutated; /* left */
++ else
++ scan_table = s->intra_h_scantable.permutated; /* top */
++ } else {
++ scan_table = s->intra_scantable.permutated;
++ }
++ qmul=1;
++ qadd=0;
++ } else {
++ i = -1;
++ if (!coded) {
++ s->block_last_index[n] = i;
++ return 0;
++ }
++ if(rvlc) rl = &rvlc_rl_inter;
++ else rl = &rl_inter;
++
++ scan_table = s->intra_scantable.permutated;
+
+- if (IS_SKIP(mb_type)) {
+- /* skip mb */
+- for(i=0;i<6;i++)
+- s->block_last_index[i] = -1;
+- s->mv_dir = MV_DIR_FORWARD;
+- s->mv_type = MV_TYPE_16X16;
+- if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
+- s->mcsel=1;
+- s->mb_skipped = 0;
++ if(s->mpeg_quant){
++ qmul=1;
++ qadd=0;
++ if(rvlc){
++ rl_vlc = rvlc_rl_inter.rl_vlc[0];
+ }else{
+- s->mcsel=0;
+- s->mb_skipped = 1;
++ rl_vlc = rl_inter.rl_vlc[0];
+ }
+- }else if(s->mb_intra){
+- s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
+- }else if(!s->mb_intra){
+-// s->mcsel= 0; //FIXME do we need to init that
+-
+- s->mv_dir = MV_DIR_FORWARD;
+- if (IS_8X8(mb_type)) {
+- s->mv_type = MV_TYPE_8X8;
+- } else {
+- s->mv_type = MV_TYPE_16X16;
++ }else{
++ qmul = s->qscale << 1;
++ qadd = (s->qscale - 1) | 1;
++ if(rvlc){
++ rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
++ }else{
++ rl_vlc = rl_inter.rl_vlc[s->qscale];
+ }
+ }
+- } else { /* I-Frame */
+- s->mb_intra = 1;
+- s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
+ }
++ {
++ OPEN_READER(re, &s->gb);
++ for(;;) {
++ UPDATE_CACHE(re, &s->gb);
++ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
++ if (level==0) {
++ /* escape */
++ if(rvlc){
++ if(SHOW_UBITS(re, &s->gb, 1)==0){
++ av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
++ return -1;
++ }; SKIP_CACHE(re, &s->gb, 1);
++
++ last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
++ run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
++ SKIP_COUNTER(re, &s->gb, 1+1+6);
++ UPDATE_CACHE(re, &s->gb);
++
++ if(SHOW_UBITS(re, &s->gb, 1)==0){
++ av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
++ return -1;
++ }; SKIP_CACHE(re, &s->gb, 1);
++
++ level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
++
++ if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
++ av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
++ return -1;
++ }; SKIP_CACHE(re, &s->gb, 5);
+
+- if (!IS_SKIP(mb_type)) {
+- int i;
+- s->dsp.clear_blocks(s->block[0]);
+- /* decode each block */
+- for (i = 0; i < 6; i++) {
+- if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
+- av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
+- return -1;
+- }
+- cbp+=cbp;
+- }
+- }
++ level= level * qmul + qadd;
++ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
++ SKIP_COUNTER(re, &s->gb, 1+11+5+1);
+
+- /* per-MB end of slice check */
++ i+= run + 1;
++ if(last) i+=192;
++ }else{
++ int cache;
++ cache= GET_CACHE(re, &s->gb);
+
+- if(--s->mb_num_left <= 0){
+-//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
+- if(mpeg4_is_resync(s))
+- return SLICE_END;
+- else
+- return SLICE_NOEND;
+- }else{
+- if(mpeg4_is_resync(s)){
+- const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
+- if(s->cbp_table[xy+delta])
+- return SLICE_END;
+- }
+- return SLICE_OK;
+- }
+-}
++ if(IS_3IV1)
++ cache ^= 0xC0000000;
+
+-/**
+- * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
+- */
+-static void preview_obmc(MpegEncContext *s){
+- GetBitContext gb= s->gb;
+-
+- int cbpc, i, pred_x, pred_y, mx, my;
+- int16_t *mot_val;
+- const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
+- const int stride= s->b8_stride*2;
+-
+- for(i=0; i<4; i++)
+- s->block_index[i]+= 2;
+- for(i=4; i<6; i++)
+- s->block_index[i]+= 1;
+- s->mb_x++;
+-
+- assert(s->pict_type == P_TYPE);
++ if (cache&0x80000000) {
++ if (cache&0x40000000) {
++ /* third escape */
++ SKIP_CACHE(re, &s->gb, 2);
++ last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
++ run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
++ SKIP_COUNTER(re, &s->gb, 2+1+6);
++ UPDATE_CACHE(re, &s->gb);
+
+- do{
+- if (get_bits1(&s->gb)) {
+- /* skip mb */
+- mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
+- mot_val[0 ]= mot_val[2 ]=
+- mot_val[0+stride]= mot_val[2+stride]= 0;
+- mot_val[1 ]= mot_val[3 ]=
++ if(IS_3IV1){
++ level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
++ }else{
++ if(SHOW_UBITS(re, &s->gb, 1)==0){
++ av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
++ return -1;
++ }; SKIP_CACHE(re, &s->gb, 1);
++
++ level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
++
++ if(SHOW_UBITS(re, &s->gb, 1)==0){
++ av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
++ return -1;
++ }; LAST_SKIP_CACHE(re, &s->gb, 1);
++
++ SKIP_COUNTER(re, &s->gb, 1+12+1);
++ }
++
++#if 0
++ if(s->error_resilience >= FF_ER_COMPLIANT){
++ const int abs_level= ABS(level);
++ if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
++ const int run1= run - rl->max_run[last][abs_level] - 1;
++ if(abs_level <= rl->max_level[last][run]){
++ av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
++ return -1;
++ }
++ if(s->error_resilience > FF_ER_COMPLIANT){
++ if(abs_level <= rl->max_level[last][run]*2){
++ fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
++ return -1;
++ }
++ if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
++ fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
++ return -1;
++ }
++ }
++ }
++ }
++#endif
++ if (level>0) level= level * qmul + qadd;
++ else level= level * qmul - qadd;
++
++ if((unsigned)(level + 2048) > 4095){
++ if(s->error_resilience > FF_ER_COMPLIANT){
++ if(level > 2560 || level<-2560){
++ av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
++ return -1;
++ }
++ }
++ level= level<0 ? -2048 : 2047;
++ }
++
++ i+= run + 1;
++ if(last) i+=192;
++ } else {
++ /* second escape */
++#if MIN_CACHE_BITS < 20
++ LAST_SKIP_BITS(re, &s->gb, 2);
++ UPDATE_CACHE(re, &s->gb);
++#else
++ SKIP_BITS(re, &s->gb, 2);
++#endif
++ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
++ i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
++ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
++ LAST_SKIP_BITS(re, &s->gb, 1);
++ }
++ } else {
++ /* first escape */
++#if MIN_CACHE_BITS < 19
++ LAST_SKIP_BITS(re, &s->gb, 1);
++ UPDATE_CACHE(re, &s->gb);
++#else
++ SKIP_BITS(re, &s->gb, 1);
++#endif
++ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
++ i+= run;
++ level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
++ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
++ LAST_SKIP_BITS(re, &s->gb, 1);
++ }
++ }
++ } else {
++ i+= run;
++ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
++ LAST_SKIP_BITS(re, &s->gb, 1);
++ }
++ if (i > 62){
++ i-= 192;
++ if(i&(~63)){
++ av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
++ return -1;
++ }
++
++ block[scan_table[i]] = level;
++ break;
++ }
++
++ block[scan_table[i]] = level;
++ }
++ CLOSE_READER(re, &s->gb);
++ }
++ not_coded:
++ if (intra) {
++ if(s->qscale >= s->intra_dc_threshold){
++ block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
++
++ if(i == -1) i=0;
++ }
++
++ mpeg4_pred_ac(s, block, n, dc_pred_dir);
++ if (s->ac_pred) {
++ i = 63; /* XXX: not optimal */
++ }
++ }
++ s->block_last_index[n] = i;
++ return 0;
++}
++
++/**
++ * decode partition C of one MB.
++ * @return <0 if an error occured
++ */
++static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
++{
++ int cbp, mb_type;
++ const int xy= s->mb_x + s->mb_y*s->mb_stride;
++
++ mb_type= s->current_picture.mb_type[xy];
++ cbp = s->cbp_table[xy];
++
++ if(s->current_picture.qscale_table[xy] != s->qscale){
++ ff_set_qscale(s, s->current_picture.qscale_table[xy] );
++ }
++
++ if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
++ int i;
++ for(i=0; i<4; i++){
++ s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
++ s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
++ }
++ s->mb_intra = IS_INTRA(mb_type);
++
++ if (IS_SKIP(mb_type)) {
++ /* skip mb */
++ for(i=0;i<6;i++)
++ s->block_last_index[i] = -1;
++ s->mv_dir = MV_DIR_FORWARD;
++ s->mv_type = MV_TYPE_16X16;
++ if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
++ s->mcsel=1;
++ s->mb_skipped = 0;
++ }else{
++ s->mcsel=0;
++ s->mb_skipped = 1;
++ }
++ }else if(s->mb_intra){
++ s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
++ }else if(!s->mb_intra){
++// s->mcsel= 0; //FIXME do we need to init that
++
++ s->mv_dir = MV_DIR_FORWARD;
++ if (IS_8X8(mb_type)) {
++ s->mv_type = MV_TYPE_8X8;
++ } else {
++ s->mv_type = MV_TYPE_16X16;
++ }
++ }
++ } else { /* I-Frame */
++ s->mb_intra = 1;
++ s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
++ }
++
++ if (!IS_SKIP(mb_type)) {
++ int i;
++ s->dsp.clear_blocks(s->block[0]);
++ /* decode each block */
++ for (i = 0; i < 6; i++) {
++ if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
++ av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
++ return -1;
++ }
++ cbp+=cbp;
++ }
++ }
++
++ /* per-MB end of slice check */
++
++ if(--s->mb_num_left <= 0){
++//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
++ if(mpeg4_is_resync(s))
++ return SLICE_END;
++ else
++ return SLICE_NOEND;
++ }else{
++ if(mpeg4_is_resync(s)){
++ const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
++ if(s->cbp_table[xy+delta])
++ return SLICE_END;
++ }
++ return SLICE_OK;
++ }
++}
++
++/**
++ * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
++ */
++static void preview_obmc(MpegEncContext *s){
++ GetBitContext gb= s->gb;
++
++ int cbpc, i, pred_x, pred_y, mx, my;
++ int16_t *mot_val;
++ const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
++ const int stride= s->b8_stride*2;
++
++ for(i=0; i<4; i++)
++ s->block_index[i]+= 2;
++ for(i=4; i<6; i++)
++ s->block_index[i]+= 1;
++ s->mb_x++;
++
++ assert(s->pict_type == P_TYPE);
++
++ do{
++ if (get_bits1(&s->gb)) {
++ /* skip mb */
++ mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
++ mot_val[0 ]= mot_val[2 ]=
++ mot_val[0+stride]= mot_val[2+stride]= 0;
++ mot_val[1 ]= mot_val[3 ]=
+ mot_val[1+stride]= mot_val[3+stride]= 0;
+
+ s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
+@@ -4675,308 +4970,6 @@
+ return 0;
+ }
+
+-/**
+- * decodes the dc value.
+- * @param n block index (0-3 are luma, 4-5 are chroma)
+- * @param dir_ptr the prediction direction will be stored here
+- * @return the quantized dc
+- */
+-static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
+-{
+- int level, code;
+-
+- if (n < 4)
+- code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
+- else
+- code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
+- if (code < 0 || code > 9 /* && s->nbit<9 */){
+- av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
+- return -1;
+- }
+- if (code == 0) {
+- level = 0;
+- } else {
+- if(IS_3IV1){
+- if(code==1)
+- level= 2*get_bits1(&s->gb)-1;
+- else{
+- if(get_bits1(&s->gb))
+- level = get_bits(&s->gb, code-1) + (1<<(code-1));
+- else
+- level = -get_bits(&s->gb, code-1) - (1<<(code-1));
+- }
+- }else{
+- level = get_xbits(&s->gb, code);
+- }
+-
+- if (code > 8){
+- if(get_bits1(&s->gb)==0){ /* marker */
+- if(s->error_resilience>=2){
+- av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
+- return -1;
+- }
+- }
+- }
+- }
+-
+- return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
+-}
+-
+-/**
+- * decodes a block.
+- * @return <0 if an error occured
+- */
+-static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
+- int n, int coded, int intra, int rvlc)
+-{
+- int level, i, last, run;
+- int dc_pred_dir;
+- RLTable * rl;
+- RL_VLC_ELEM * rl_vlc;
+- const uint8_t * scan_table;
+- int qmul, qadd;
+-
+- //Note intra & rvlc should be optimized away if this is inlined
+-
+- if(intra) {
+- if(s->qscale < s->intra_dc_threshold){
+- /* DC coef */
+- if(s->partitioned_frame){
+- level = s->dc_val[0][ s->block_index[n] ];
+- if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
+- else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
+- dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
+- }else{
+- level = mpeg4_decode_dc(s, n, &dc_pred_dir);
+- if (level < 0)
+- return -1;
+- }
+- block[0] = level;
+- i = 0;
+- }else{
+- i = -1;
+- }
+- if (!coded)
+- goto not_coded;
+-
+- if(rvlc){
+- rl = &rvlc_rl_intra;
+- rl_vlc = rvlc_rl_intra.rl_vlc[0];
+- }else{
+- rl = &rl_intra;
+- rl_vlc = rl_intra.rl_vlc[0];
+- }
+- if (s->ac_pred) {
+- if (dc_pred_dir == 0)
+- scan_table = s->intra_v_scantable.permutated; /* left */
+- else
+- scan_table = s->intra_h_scantable.permutated; /* top */
+- } else {
+- scan_table = s->intra_scantable.permutated;
+- }
+- qmul=1;
+- qadd=0;
+- } else {
+- i = -1;
+- if (!coded) {
+- s->block_last_index[n] = i;
+- return 0;
+- }
+- if(rvlc) rl = &rvlc_rl_inter;
+- else rl = &rl_inter;
+-
+- scan_table = s->intra_scantable.permutated;
+-
+- if(s->mpeg_quant){
+- qmul=1;
+- qadd=0;
+- if(rvlc){
+- rl_vlc = rvlc_rl_inter.rl_vlc[0];
+- }else{
+- rl_vlc = rl_inter.rl_vlc[0];
+- }
+- }else{
+- qmul = s->qscale << 1;
+- qadd = (s->qscale - 1) | 1;
+- if(rvlc){
+- rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
+- }else{
+- rl_vlc = rl_inter.rl_vlc[s->qscale];
+- }
+- }
+- }
+- {
+- OPEN_READER(re, &s->gb);
+- for(;;) {
+- UPDATE_CACHE(re, &s->gb);
+- GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
+- if (level==0) {
+- /* escape */
+- if(rvlc){
+- if(SHOW_UBITS(re, &s->gb, 1)==0){
+- av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
+- return -1;
+- }; SKIP_CACHE(re, &s->gb, 1);
+-
+- last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
+- run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
+- SKIP_COUNTER(re, &s->gb, 1+1+6);
+- UPDATE_CACHE(re, &s->gb);
+-
+- if(SHOW_UBITS(re, &s->gb, 1)==0){
+- av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
+- return -1;
+- }; SKIP_CACHE(re, &s->gb, 1);
+-
+- level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
+-
+- if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
+- av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
+- return -1;
+- }; SKIP_CACHE(re, &s->gb, 5);
+-
+- level= level * qmul + qadd;
+- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
+- SKIP_COUNTER(re, &s->gb, 1+11+5+1);
+-
+- i+= run + 1;
+- if(last) i+=192;
+- }else{
+- int cache;
+- cache= GET_CACHE(re, &s->gb);
+-
+- if(IS_3IV1)
+- cache ^= 0xC0000000;
+-
+- if (cache&0x80000000) {
+- if (cache&0x40000000) {
+- /* third escape */
+- SKIP_CACHE(re, &s->gb, 2);
+- last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
+- run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
+- SKIP_COUNTER(re, &s->gb, 2+1+6);
+- UPDATE_CACHE(re, &s->gb);
+-
+- if(IS_3IV1){
+- level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
+- }else{
+- if(SHOW_UBITS(re, &s->gb, 1)==0){
+- av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
+- return -1;
+- }; SKIP_CACHE(re, &s->gb, 1);
+-
+- level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
+-
+- if(SHOW_UBITS(re, &s->gb, 1)==0){
+- av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
+- return -1;
+- }; LAST_SKIP_CACHE(re, &s->gb, 1);
+-
+- SKIP_COUNTER(re, &s->gb, 1+12+1);
+- }
+-
+-#if 0
+- if(s->error_resilience >= FF_ER_COMPLIANT){
+- const int abs_level= ABS(level);
+- if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
+- const int run1= run - rl->max_run[last][abs_level] - 1;
+- if(abs_level <= rl->max_level[last][run]){
+- av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
+- return -1;
+- }
+- if(s->error_resilience > FF_ER_COMPLIANT){
+- if(abs_level <= rl->max_level[last][run]*2){
+- fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
+- return -1;
+- }
+- if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
+- fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
+- return -1;
+- }
+- }
+- }
+- }
+-#endif
+- if (level>0) level= level * qmul + qadd;
+- else level= level * qmul - qadd;
+-
+- if((unsigned)(level + 2048) > 4095){
+- if(s->error_resilience > FF_ER_COMPLIANT){
+- if(level > 2560 || level<-2560){
+- av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
+- return -1;
+- }
+- }
+- level= level<0 ? -2048 : 2047;
+- }
+-
+- i+= run + 1;
+- if(last) i+=192;
+- } else {
+- /* second escape */
+-#if MIN_CACHE_BITS < 20
+- LAST_SKIP_BITS(re, &s->gb, 2);
+- UPDATE_CACHE(re, &s->gb);
+-#else
+- SKIP_BITS(re, &s->gb, 2);
+-#endif
+- GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
+- i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
+- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+- LAST_SKIP_BITS(re, &s->gb, 1);
+- }
+- } else {
+- /* first escape */
+-#if MIN_CACHE_BITS < 19
+- LAST_SKIP_BITS(re, &s->gb, 1);
+- UPDATE_CACHE(re, &s->gb);
+-#else
+- SKIP_BITS(re, &s->gb, 1);
+-#endif
+- GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
+- i+= run;
+- level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
+- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+- LAST_SKIP_BITS(re, &s->gb, 1);
+- }
+- }
+- } else {
+- i+= run;
+- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+- LAST_SKIP_BITS(re, &s->gb, 1);
+- }
+- if (i > 62){
+- i-= 192;
+- if(i&(~63)){
+- av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
+- return -1;
+- }
+-
+- block[scan_table[i]] = level;
+- break;
+- }
+-
+- block[scan_table[i]] = level;
+- }
+- CLOSE_READER(re, &s->gb);
+- }
+- not_coded:
+- if (intra) {
+- if(s->qscale >= s->intra_dc_threshold){
+- block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
+-
+- if(i == -1) i=0;
+- }
+-
+- mpeg4_pred_ac(s, block, n, dc_pred_dir);
+- if (s->ac_pred) {
+- i = 63; /* XXX: not optimal */
+- }
+- }
+- s->block_last_index[n] = i;
+- return 0;
+-}
+-
+ /* most is hardcoded. should extend to handle all h263 streams */
+ int h263_decode_picture_header(MpegEncContext *s)
+ {
@@ -5856,7 +5856,7 @@
s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
@@ -437,3 +4279,18 @@
check_marker(gb, "before vop_coded");
+--- libavcodec/mpegvideo.h 6 May 2005 04:19:20 -0000 1.36
++++ libavcodec/mpegvideo.h 14 May 2005 23:18:23 -0000
+@@ -810,10 +810,10 @@
+ int16_t (*mv_table)[2], int f_code, int type, int truncate);
+ void ff_init_me(MpegEncContext *s);
+ int ff_pre_estimate_p_frame_motion(MpegEncContext * s, int mb_x, int mb_y);
+-inline int ff_epzs_motion_search(MpegEncContext * s, int *mx_ptr, int *my_ptr,
++extern __inline__ int ff_epzs_motion_search(MpegEncContext * s, int *mx_ptr, int *my_ptr,
+ int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2],
+ int ref_mv_scale, int size, int h);
+-int inline ff_get_mb_score(MpegEncContext * s, int mx, int my, int src_index,
++extern __inline__ int ff_get_mb_score(MpegEncContext * s, int mx, int my, int src_index,
+ int ref_index, int size, int h, int add_rate);
+
+ /* mpeg12.c */
diff --git a/src/libffmpeg/libavcodec/h263.c b/src/libffmpeg/libavcodec/h263.c
index 6a8388ee9..b924a6b5a 100644
--- a/src/libffmpeg/libavcodec/h263.c
+++ b/src/libffmpeg/libavcodec/h263.c
@@ -57,18 +57,12 @@
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
int n);
static void h263p_encode_umotion(MpegEncContext * s, int val);
-static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
- int n, int dc, uint8_t *scan_table,
- PutBitContext *dc_pb, PutBitContext *ac_pb);
#endif
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
static int h263p_decode_umotion(MpegEncContext * s, int pred);
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
int n, int coded);
-static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
-static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
- int n, int coded, int intra, int rvlc);
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
uint8_t *scan_table);
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
@@ -77,7 +71,6 @@ static void mpeg4_encode_visual_object_header(MpegEncContext * s);
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
#endif //CONFIG_ENCODERS
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
-static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
#ifdef CONFIG_ENCODERS
static uint8_t uni_DCtab_lum_len[512];
@@ -664,6 +657,85 @@ void ff_h263_update_motion_val(MpegEncContext * s){
}
}
+/**
+ * predicts the dc.
+ * encoding quantized level -> quantized diff
+ * decoding quantized diff -> quantized level
+ * @param n block index (0-3 are luma, 4-5 are chroma)
+ * @param dir_ptr pointer to an integer where the prediction direction will be stored
+ */
+static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
+{
+ int a, b, c, wrap, pred, scale, ret;
+ uint16_t *dc_val;
+
+ /* find prediction */
+ if (n < 4) {
+ scale = s->y_dc_scale;
+ } else {
+ scale = s->c_dc_scale;
+ }
+ if(IS_3IV1)
+ scale= 8;
+
+ wrap= s->block_wrap[n];
+ dc_val = s->dc_val[0] + s->block_index[n];
+
+ /* B C
+ * A X
+ */
+ a = dc_val[ - 1];
+ b = dc_val[ - 1 - wrap];
+ c = dc_val[ - wrap];
+
+ /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
+ if(s->first_slice_line && n!=3){
+ if(n!=2) b=c= 1024;
+ if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
+ }
+ if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
+ if(n==0 || n==4 || n==5)
+ b=1024;
+ }
+
+ if (abs(a - b) < abs(b - c)) {
+ pred = c;
+ *dir_ptr = 1; /* top */
+ } else {
+ pred = a;
+ *dir_ptr = 0; /* left */
+ }
+ /* we assume pred is positive */
+ pred = FASTDIV((pred + (scale >> 1)), scale);
+
+ if(encoding){
+ ret = level - pred;
+ }else{
+ level += pred;
+ ret= level;
+ if(s->error_resilience>=3){
+ if(level<0){
+ av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
+ return -1;
+ }
+ if(level*scale > 2048 + scale){
+ av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
+ return -1;
+ }
+ }
+ }
+ level *=scale;
+ if(level&(~2047)){
+ if(level<0)
+ level=0;
+ else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
+ level=2047;
+ }
+ dc_val[0]= level;
+
+ return ret;
+}
+
#ifdef CONFIG_ENCODERS
static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
@@ -793,6 +865,179 @@ static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
return cbp;
}
+/**
+ * encodes the dc value.
+ * @param n block index (0-3 are luma, 4-5 are chroma)
+ */
+static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
+{
+#if 1
+// if(level<-255 || level>255) printf("dc overflow\n");
+ level+=256;
+ if (n < 4) {
+ /* luminance */
+ put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
+ } else {
+ /* chrominance */
+ put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
+ }
+#else
+ int size, v;
+ /* find number of bits */
+ size = 0;
+ v = abs(level);
+ while (v) {
+ v >>= 1;
+ size++;
+ }
+
+ if (n < 4) {
+ /* luminance */
+ put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
+ } else {
+ /* chrominance */
+ put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
+ }
+
+ /* encode remaining bits */
+ if (size > 0) {
+ if (level < 0)
+ level = (-level) ^ ((1 << size) - 1);
+ put_bits(&s->pb, size, level);
+ if (size > 8)
+ put_bits(&s->pb, 1, 1);
+ }
+#endif
+}
+
+static inline int mpeg4_get_dc_length(int level, int n){
+ if (n < 4) {
+ return uni_DCtab_lum_len[level + 256];
+ } else {
+ return uni_DCtab_chrom_len[level + 256];
+ }
+}
+
+/**
+ * encodes a 8x8 block
+ * @param n block index (0-3 are luma, 4-5 are chroma)
+ */
+static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
+ uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
+{
+ int i, last_non_zero;
+#if 0 //variables for the outcommented version
+ int code, sign, last;
+#endif
+ const RLTable *rl;
+ uint32_t *bits_tab;
+ uint8_t *len_tab;
+ const int last_index = s->block_last_index[n];
+
+ if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
+ /* mpeg4 based DC predictor */
+ mpeg4_encode_dc(dc_pb, intra_dc, n);
+ if(last_index<1) return;
+ i = 1;
+ rl = &rl_intra;
+ bits_tab= uni_mpeg4_intra_rl_bits;
+ len_tab = uni_mpeg4_intra_rl_len;
+ } else {
+ if(last_index<0) return;
+ i = 0;
+ rl = &rl_inter;
+ bits_tab= uni_mpeg4_inter_rl_bits;
+ len_tab = uni_mpeg4_inter_rl_len;
+ }
+
+ /* AC coefs */
+ last_non_zero = i - 1;
+#if 1
+ for (; i < last_index; i++) {
+ int level = block[ scan_table[i] ];
+ if (level) {
+ int run = i - last_non_zero - 1;
+ level+=64;
+ if((level&(~127)) == 0){
+ const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
+ put_bits(ac_pb, len_tab[index], bits_tab[index]);
+ }else{ //ESC3
+ put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
+ }
+ last_non_zero = i;
+ }
+ }
+ /*if(i<=last_index)*/{
+ int level = block[ scan_table[i] ];
+ int run = i - last_non_zero - 1;
+ level+=64;
+ if((level&(~127)) == 0){
+ const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
+ put_bits(ac_pb, len_tab[index], bits_tab[index]);
+ }else{ //ESC3
+ put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
+ }
+ }
+#else
+ for (; i <= last_index; i++) {
+ const int slevel = block[ scan_table[i] ];
+ if (slevel) {
+ int level;
+ int run = i - last_non_zero - 1;
+ last = (i == last_index);
+ sign = 0;
+ level = slevel;
+ if (level < 0) {
+ sign = 1;
+ level = -level;
+ }
+ code = get_rl_index(rl, last, run, level);
+ put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+ if (code == rl->n) {
+ int level1, run1;
+ level1 = level - rl->max_level[last][run];
+ if (level1 < 1)
+ goto esc2;
+ code = get_rl_index(rl, last, run, level1);
+ if (code == rl->n) {
+ esc2:
+ put_bits(ac_pb, 1, 1);
+ if (level > MAX_LEVEL)
+ goto esc3;
+ run1 = run - rl->max_run[last][level] - 1;
+ if (run1 < 0)
+ goto esc3;
+ code = get_rl_index(rl, last, run1, level);
+ if (code == rl->n) {
+ esc3:
+ /* third escape */
+ put_bits(ac_pb, 1, 1);
+ put_bits(ac_pb, 1, last);
+ put_bits(ac_pb, 6, run);
+ put_bits(ac_pb, 1, 1);
+ put_bits(ac_pb, 12, slevel & 0xfff);
+ put_bits(ac_pb, 1, 1);
+ } else {
+ /* second escape */
+ put_bits(ac_pb, 1, 0);
+ put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+ put_bits(ac_pb, 1, sign);
+ }
+ } else {
+ /* first escape */
+ put_bits(ac_pb, 1, 0);
+ put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+ put_bits(ac_pb, 1, sign);
+ }
+ } else {
+ put_bits(ac_pb, 1, sign);
+ }
+ last_non_zero = i;
+ }
+ }
+#endif
+}
+
static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
int i;
@@ -2478,85 +2723,6 @@ void ff_set_qscale(MpegEncContext * s, int qscale)
}
/**
- * predicts the dc.
- * encoding quantized level -> quantized diff
- * decoding quantized diff -> quantized level
- * @param n block index (0-3 are luma, 4-5 are chroma)
- * @param dir_ptr pointer to an integer where the prediction direction will be stored
- */
-static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
-{
- int a, b, c, wrap, pred, scale, ret;
- uint16_t *dc_val;
-
- /* find prediction */
- if (n < 4) {
- scale = s->y_dc_scale;
- } else {
- scale = s->c_dc_scale;
- }
- if(IS_3IV1)
- scale= 8;
-
- wrap= s->block_wrap[n];
- dc_val = s->dc_val[0] + s->block_index[n];
-
- /* B C
- * A X
- */
- a = dc_val[ - 1];
- b = dc_val[ - 1 - wrap];
- c = dc_val[ - wrap];
-
- /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
- if(s->first_slice_line && n!=3){
- if(n!=2) b=c= 1024;
- if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
- }
- if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
- if(n==0 || n==4 || n==5)
- b=1024;
- }
-
- if (abs(a - b) < abs(b - c)) {
- pred = c;
- *dir_ptr = 1; /* top */
- } else {
- pred = a;
- *dir_ptr = 0; /* left */
- }
- /* we assume pred is positive */
- pred = FASTDIV((pred + (scale >> 1)), scale);
-
- if(encoding){
- ret = level - pred;
- }else{
- level += pred;
- ret= level;
- if(s->error_resilience>=3){
- if(level<0){
- av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
- return -1;
- }
- if(level*scale > 2048 + scale){
- av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
- return -1;
- }
- }
- }
- level *=scale;
- if(level&(~2047)){
- if(level<0)
- level=0;
- else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
- level=2047;
- }
- dc_val[0]= level;
-
- return ret;
-}
-
-/**
* predicts the ac.
* @param n block index (0-3 are luma, 4-5 are chroma)
* @param dir the ac prediction direction
@@ -2618,179 +2784,6 @@ void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
#ifdef CONFIG_ENCODERS
-/**
- * encodes the dc value.
- * @param n block index (0-3 are luma, 4-5 are chroma)
- */
-static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
-{
-#if 1
-// if(level<-255 || level>255) printf("dc overflow\n");
- level+=256;
- if (n < 4) {
- /* luminance */
- put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
- } else {
- /* chrominance */
- put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
- }
-#else
- int size, v;
- /* find number of bits */
- size = 0;
- v = abs(level);
- while (v) {
- v >>= 1;
- size++;
- }
-
- if (n < 4) {
- /* luminance */
- put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
- } else {
- /* chrominance */
- put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
- }
-
- /* encode remaining bits */
- if (size > 0) {
- if (level < 0)
- level = (-level) ^ ((1 << size) - 1);
- put_bits(&s->pb, size, level);
- if (size > 8)
- put_bits(&s->pb, 1, 1);
- }
-#endif
-}
-
-static inline int mpeg4_get_dc_length(int level, int n){
- if (n < 4) {
- return uni_DCtab_lum_len[level + 256];
- } else {
- return uni_DCtab_chrom_len[level + 256];
- }
-}
-
-/**
- * encodes a 8x8 block
- * @param n block index (0-3 are luma, 4-5 are chroma)
- */
-static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
- uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
-{
- int i, last_non_zero;
-#if 0 //variables for the outcommented version
- int code, sign, last;
-#endif
- const RLTable *rl;
- uint32_t *bits_tab;
- uint8_t *len_tab;
- const int last_index = s->block_last_index[n];
-
- if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
- /* mpeg4 based DC predictor */
- mpeg4_encode_dc(dc_pb, intra_dc, n);
- if(last_index<1) return;
- i = 1;
- rl = &rl_intra;
- bits_tab= uni_mpeg4_intra_rl_bits;
- len_tab = uni_mpeg4_intra_rl_len;
- } else {
- if(last_index<0) return;
- i = 0;
- rl = &rl_inter;
- bits_tab= uni_mpeg4_inter_rl_bits;
- len_tab = uni_mpeg4_inter_rl_len;
- }
-
- /* AC coefs */
- last_non_zero = i - 1;
-#if 1
- for (; i < last_index; i++) {
- int level = block[ scan_table[i] ];
- if (level) {
- int run = i - last_non_zero - 1;
- level+=64;
- if((level&(~127)) == 0){
- const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
- put_bits(ac_pb, len_tab[index], bits_tab[index]);
- }else{ //ESC3
- put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
- }
- last_non_zero = i;
- }
- }
- /*if(i<=last_index)*/{
- int level = block[ scan_table[i] ];
- int run = i - last_non_zero - 1;
- level+=64;
- if((level&(~127)) == 0){
- const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
- put_bits(ac_pb, len_tab[index], bits_tab[index]);
- }else{ //ESC3
- put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
- }
- }
-#else
- for (; i <= last_index; i++) {
- const int slevel = block[ scan_table[i] ];
- if (slevel) {
- int level;
- int run = i - last_non_zero - 1;
- last = (i == last_index);
- sign = 0;
- level = slevel;
- if (level < 0) {
- sign = 1;
- level = -level;
- }
- code = get_rl_index(rl, last, run, level);
- put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
- if (code == rl->n) {
- int level1, run1;
- level1 = level - rl->max_level[last][run];
- if (level1 < 1)
- goto esc2;
- code = get_rl_index(rl, last, run, level1);
- if (code == rl->n) {
- esc2:
- put_bits(ac_pb, 1, 1);
- if (level > MAX_LEVEL)
- goto esc3;
- run1 = run - rl->max_run[last][level] - 1;
- if (run1 < 0)
- goto esc3;
- code = get_rl_index(rl, last, run1, level);
- if (code == rl->n) {
- esc3:
- /* third escape */
- put_bits(ac_pb, 1, 1);
- put_bits(ac_pb, 1, last);
- put_bits(ac_pb, 6, run);
- put_bits(ac_pb, 1, 1);
- put_bits(ac_pb, 12, slevel & 0xfff);
- put_bits(ac_pb, 1, 1);
- } else {
- /* second escape */
- put_bits(ac_pb, 1, 0);
- put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
- put_bits(ac_pb, 1, sign);
- }
- } else {
- /* first escape */
- put_bits(ac_pb, 1, 0);
- put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
- put_bits(ac_pb, 1, sign);
- }
- } else {
- put_bits(ac_pb, 1, sign);
- }
- last_non_zero = i;
- }
- }
-#endif
-}
-
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
uint8_t *scan_table)
{
@@ -3392,6 +3385,53 @@ static inline int get_amv(MpegEncContext *s, int n){
}
/**
+ * decodes the dc value.
+ * @param n block index (0-3 are luma, 4-5 are chroma)
+ * @param dir_ptr the prediction direction will be stored here
+ * @return the quantized dc
+ */
+static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
+{
+ int level, code;
+
+ if (n < 4)
+ code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
+ else
+ code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
+ if (code < 0 || code > 9 /* && s->nbit<9 */){
+ av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
+ return -1;
+ }
+ if (code == 0) {
+ level = 0;
+ } else {
+ if(IS_3IV1){
+ if(code==1)
+ level= 2*get_bits1(&s->gb)-1;
+ else{
+ if(get_bits1(&s->gb))
+ level = get_bits(&s->gb, code-1) + (1<<(code-1));
+ else
+ level = -get_bits(&s->gb, code-1) - (1<<(code-1));
+ }
+ }else{
+ level = get_xbits(&s->gb, code);
+ }
+
+ if (code > 8){
+ if(get_bits1(&s->gb)==0){ /* marker */
+ if(s->error_resilience>=2){
+ av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
+ return -1;
+ }
+ }
+ }
+ }
+
+ return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
+}
+
+/**
* decodes first partition.
* @return number of MBs decoded or <0 if an error occured
*/
@@ -3697,6 +3737,261 @@ int ff_mpeg4_decode_partitions(MpegEncContext *s)
}
/**
+ * decodes a block.
+ * @return <0 if an error occured
+ */
+static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
+ int n, int coded, int intra, int rvlc)
+{
+ int level, i, last, run;
+ int dc_pred_dir;
+ RLTable * rl;
+ RL_VLC_ELEM * rl_vlc;
+ const uint8_t * scan_table;
+ int qmul, qadd;
+
+ //Note intra & rvlc should be optimized away if this is inlined
+
+ if(intra) {
+ if(s->qscale < s->intra_dc_threshold){
+ /* DC coef */
+ if(s->partitioned_frame){
+ level = s->dc_val[0][ s->block_index[n] ];
+ if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
+ else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
+ dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
+ }else{
+ level = mpeg4_decode_dc(s, n, &dc_pred_dir);
+ if (level < 0)
+ return -1;
+ }
+ block[0] = level;
+ i = 0;
+ }else{
+ i = -1;
+ }
+ if (!coded)
+ goto not_coded;
+
+ if(rvlc){
+ rl = &rvlc_rl_intra;
+ rl_vlc = rvlc_rl_intra.rl_vlc[0];
+ }else{
+ rl = &rl_intra;
+ rl_vlc = rl_intra.rl_vlc[0];
+ }
+ if (s->ac_pred) {
+ if (dc_pred_dir == 0)
+ scan_table = s->intra_v_scantable.permutated; /* left */
+ else
+ scan_table = s->intra_h_scantable.permutated; /* top */
+ } else {
+ scan_table = s->intra_scantable.permutated;
+ }
+ qmul=1;
+ qadd=0;
+ } else {
+ i = -1;
+ if (!coded) {
+ s->block_last_index[n] = i;
+ return 0;
+ }
+ if(rvlc) rl = &rvlc_rl_inter;
+ else rl = &rl_inter;
+
+ scan_table = s->intra_scantable.permutated;
+
+ if(s->mpeg_quant){
+ qmul=1;
+ qadd=0;
+ if(rvlc){
+ rl_vlc = rvlc_rl_inter.rl_vlc[0];
+ }else{
+ rl_vlc = rl_inter.rl_vlc[0];
+ }
+ }else{
+ qmul = s->qscale << 1;
+ qadd = (s->qscale - 1) | 1;
+ if(rvlc){
+ rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
+ }else{
+ rl_vlc = rl_inter.rl_vlc[s->qscale];
+ }
+ }
+ }
+ {
+ OPEN_READER(re, &s->gb);
+ for(;;) {
+ UPDATE_CACHE(re, &s->gb);
+ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
+ if (level==0) {
+ /* escape */
+ if(rvlc){
+ if(SHOW_UBITS(re, &s->gb, 1)==0){
+ av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
+ return -1;
+ }; SKIP_CACHE(re, &s->gb, 1);
+
+ last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
+ run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
+ SKIP_COUNTER(re, &s->gb, 1+1+6);
+ UPDATE_CACHE(re, &s->gb);
+
+ if(SHOW_UBITS(re, &s->gb, 1)==0){
+ av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
+ return -1;
+ }; SKIP_CACHE(re, &s->gb, 1);
+
+ level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
+
+ if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
+ av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
+ return -1;
+ }; SKIP_CACHE(re, &s->gb, 5);
+
+ level= level * qmul + qadd;
+ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
+ SKIP_COUNTER(re, &s->gb, 1+11+5+1);
+
+ i+= run + 1;
+ if(last) i+=192;
+ }else{
+ int cache;
+ cache= GET_CACHE(re, &s->gb);
+
+ if(IS_3IV1)
+ cache ^= 0xC0000000;
+
+ if (cache&0x80000000) {
+ if (cache&0x40000000) {
+ /* third escape */
+ SKIP_CACHE(re, &s->gb, 2);
+ last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
+ run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
+ SKIP_COUNTER(re, &s->gb, 2+1+6);
+ UPDATE_CACHE(re, &s->gb);
+
+ if(IS_3IV1){
+ level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
+ }else{
+ if(SHOW_UBITS(re, &s->gb, 1)==0){
+ av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
+ return -1;
+ }; SKIP_CACHE(re, &s->gb, 1);
+
+ level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
+
+ if(SHOW_UBITS(re, &s->gb, 1)==0){
+ av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
+ return -1;
+ }; LAST_SKIP_CACHE(re, &s->gb, 1);
+
+ SKIP_COUNTER(re, &s->gb, 1+12+1);
+ }
+
+#if 0
+ if(s->error_resilience >= FF_ER_COMPLIANT){
+ const int abs_level= ABS(level);
+ if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
+ const int run1= run - rl->max_run[last][abs_level] - 1;
+ if(abs_level <= rl->max_level[last][run]){
+ av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
+ return -1;
+ }
+ if(s->error_resilience > FF_ER_COMPLIANT){
+ if(abs_level <= rl->max_level[last][run]*2){
+ fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
+ return -1;
+ }
+ if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
+ fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
+ return -1;
+ }
+ }
+ }
+ }
+#endif
+ if (level>0) level= level * qmul + qadd;
+ else level= level * qmul - qadd;
+
+ if((unsigned)(level + 2048) > 4095){
+ if(s->error_resilience > FF_ER_COMPLIANT){
+ if(level > 2560 || level<-2560){
+ av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
+ return -1;
+ }
+ }
+ level= level<0 ? -2048 : 2047;
+ }
+
+ i+= run + 1;
+ if(last) i+=192;
+ } else {
+ /* second escape */
+#if MIN_CACHE_BITS < 20
+ LAST_SKIP_BITS(re, &s->gb, 2);
+ UPDATE_CACHE(re, &s->gb);
+#else
+ SKIP_BITS(re, &s->gb, 2);
+#endif
+ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
+ i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
+ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+ LAST_SKIP_BITS(re, &s->gb, 1);
+ }
+ } else {
+ /* first escape */
+#if MIN_CACHE_BITS < 19
+ LAST_SKIP_BITS(re, &s->gb, 1);
+ UPDATE_CACHE(re, &s->gb);
+#else
+ SKIP_BITS(re, &s->gb, 1);
+#endif
+ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
+ i+= run;
+ level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
+ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+ LAST_SKIP_BITS(re, &s->gb, 1);
+ }
+ }
+ } else {
+ i+= run;
+ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+ LAST_SKIP_BITS(re, &s->gb, 1);
+ }
+ if (i > 62){
+ i-= 192;
+ if(i&(~63)){
+ av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
+ return -1;
+ }
+
+ block[scan_table[i]] = level;
+ break;
+ }
+
+ block[scan_table[i]] = level;
+ }
+ CLOSE_READER(re, &s->gb);
+ }
+ not_coded:
+ if (intra) {
+ if(s->qscale >= s->intra_dc_threshold){
+ block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
+
+ if(i == -1) i=0;
+ }
+
+ mpeg4_pred_ac(s, block, n, dc_pred_dir);
+ if (s->ac_pred) {
+ i = 63; /* XXX: not optimal */
+ }
+ }
+ s->block_last_index[n] = i;
+ return 0;
+}
+
+/**
* decode partition C of one MB.
* @return <0 if an error occured
*/
@@ -4675,308 +4970,6 @@ not_coded:
return 0;
}
-/**
- * decodes the dc value.
- * @param n block index (0-3 are luma, 4-5 are chroma)
- * @param dir_ptr the prediction direction will be stored here
- * @return the quantized dc
- */
-static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
-{
- int level, code;
-
- if (n < 4)
- code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
- else
- code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
- if (code < 0 || code > 9 /* && s->nbit<9 */){
- av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
- return -1;
- }
- if (code == 0) {
- level = 0;
- } else {
- if(IS_3IV1){
- if(code==1)
- level= 2*get_bits1(&s->gb)-1;
- else{
- if(get_bits1(&s->gb))
- level = get_bits(&s->gb, code-1) + (1<<(code-1));
- else
- level = -get_bits(&s->gb, code-1) - (1<<(code-1));
- }
- }else{
- level = get_xbits(&s->gb, code);
- }
-
- if (code > 8){
- if(get_bits1(&s->gb)==0){ /* marker */
- if(s->error_resilience>=2){
- av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
- return -1;
- }
- }
- }
- }
-
- return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
-}
-
-/**
- * decodes a block.
- * @return <0 if an error occured
- */
-static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
- int n, int coded, int intra, int rvlc)
-{
- int level, i, last, run;
- int dc_pred_dir;
- RLTable * rl;
- RL_VLC_ELEM * rl_vlc;
- const uint8_t * scan_table;
- int qmul, qadd;
-
- //Note intra & rvlc should be optimized away if this is inlined
-
- if(intra) {
- if(s->qscale < s->intra_dc_threshold){
- /* DC coef */
- if(s->partitioned_frame){
- level = s->dc_val[0][ s->block_index[n] ];
- if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
- else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
- dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
- }else{
- level = mpeg4_decode_dc(s, n, &dc_pred_dir);
- if (level < 0)
- return -1;
- }
- block[0] = level;
- i = 0;
- }else{
- i = -1;
- }
- if (!coded)
- goto not_coded;
-
- if(rvlc){
- rl = &rvlc_rl_intra;
- rl_vlc = rvlc_rl_intra.rl_vlc[0];
- }else{
- rl = &rl_intra;
- rl_vlc = rl_intra.rl_vlc[0];
- }
- if (s->ac_pred) {
- if (dc_pred_dir == 0)
- scan_table = s->intra_v_scantable.permutated; /* left */
- else
- scan_table = s->intra_h_scantable.permutated; /* top */
- } else {
- scan_table = s->intra_scantable.permutated;
- }
- qmul=1;
- qadd=0;
- } else {
- i = -1;
- if (!coded) {
- s->block_last_index[n] = i;
- return 0;
- }
- if(rvlc) rl = &rvlc_rl_inter;
- else rl = &rl_inter;
-
- scan_table = s->intra_scantable.permutated;
-
- if(s->mpeg_quant){
- qmul=1;
- qadd=0;
- if(rvlc){
- rl_vlc = rvlc_rl_inter.rl_vlc[0];
- }else{
- rl_vlc = rl_inter.rl_vlc[0];
- }
- }else{
- qmul = s->qscale << 1;
- qadd = (s->qscale - 1) | 1;
- if(rvlc){
- rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
- }else{
- rl_vlc = rl_inter.rl_vlc[s->qscale];
- }
- }
- }
- {
- OPEN_READER(re, &s->gb);
- for(;;) {
- UPDATE_CACHE(re, &s->gb);
- GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
- if (level==0) {
- /* escape */
- if(rvlc){
- if(SHOW_UBITS(re, &s->gb, 1)==0){
- av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
- return -1;
- }; SKIP_CACHE(re, &s->gb, 1);
-
- last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
- run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
- SKIP_COUNTER(re, &s->gb, 1+1+6);
- UPDATE_CACHE(re, &s->gb);
-
- if(SHOW_UBITS(re, &s->gb, 1)==0){
- av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
- return -1;
- }; SKIP_CACHE(re, &s->gb, 1);
-
- level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
-
- if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
- av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
- return -1;
- }; SKIP_CACHE(re, &s->gb, 5);
-
- level= level * qmul + qadd;
- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
- SKIP_COUNTER(re, &s->gb, 1+11+5+1);
-
- i+= run + 1;
- if(last) i+=192;
- }else{
- int cache;
- cache= GET_CACHE(re, &s->gb);
-
- if(IS_3IV1)
- cache ^= 0xC0000000;
-
- if (cache&0x80000000) {
- if (cache&0x40000000) {
- /* third escape */
- SKIP_CACHE(re, &s->gb, 2);
- last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
- run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
- SKIP_COUNTER(re, &s->gb, 2+1+6);
- UPDATE_CACHE(re, &s->gb);
-
- if(IS_3IV1){
- level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
- }else{
- if(SHOW_UBITS(re, &s->gb, 1)==0){
- av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
- return -1;
- }; SKIP_CACHE(re, &s->gb, 1);
-
- level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
-
- if(SHOW_UBITS(re, &s->gb, 1)==0){
- av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
- return -1;
- }; LAST_SKIP_CACHE(re, &s->gb, 1);
-
- SKIP_COUNTER(re, &s->gb, 1+12+1);
- }
-
-#if 0
- if(s->error_resilience >= FF_ER_COMPLIANT){
- const int abs_level= ABS(level);
- if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
- const int run1= run - rl->max_run[last][abs_level] - 1;
- if(abs_level <= rl->max_level[last][run]){
- av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
- return -1;
- }
- if(s->error_resilience > FF_ER_COMPLIANT){
- if(abs_level <= rl->max_level[last][run]*2){
- fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
- return -1;
- }
- if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
- fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
- return -1;
- }
- }
- }
- }
-#endif
- if (level>0) level= level * qmul + qadd;
- else level= level * qmul - qadd;
-
- if((unsigned)(level + 2048) > 4095){
- if(s->error_resilience > FF_ER_COMPLIANT){
- if(level > 2560 || level<-2560){
- av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
- return -1;
- }
- }
- level= level<0 ? -2048 : 2047;
- }
-
- i+= run + 1;
- if(last) i+=192;
- } else {
- /* second escape */
-#if MIN_CACHE_BITS < 20
- LAST_SKIP_BITS(re, &s->gb, 2);
- UPDATE_CACHE(re, &s->gb);
-#else
- SKIP_BITS(re, &s->gb, 2);
-#endif
- GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
- i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
- LAST_SKIP_BITS(re, &s->gb, 1);
- }
- } else {
- /* first escape */
-#if MIN_CACHE_BITS < 19
- LAST_SKIP_BITS(re, &s->gb, 1);
- UPDATE_CACHE(re, &s->gb);
-#else
- SKIP_BITS(re, &s->gb, 1);
-#endif
- GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
- i+= run;
- level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
- LAST_SKIP_BITS(re, &s->gb, 1);
- }
- }
- } else {
- i+= run;
- level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
- LAST_SKIP_BITS(re, &s->gb, 1);
- }
- if (i > 62){
- i-= 192;
- if(i&(~63)){
- av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
- return -1;
- }
-
- block[scan_table[i]] = level;
- break;
- }
-
- block[scan_table[i]] = level;
- }
- CLOSE_READER(re, &s->gb);
- }
- not_coded:
- if (intra) {
- if(s->qscale >= s->intra_dc_threshold){
- block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
-
- if(i == -1) i=0;
- }
-
- mpeg4_pred_ac(s, block, n, dc_pred_dir);
- if (s->ac_pred) {
- i = 63; /* XXX: not optimal */
- }
- }
- s->block_last_index[n] = i;
- return 0;
-}
-
/* most is hardcoded. should extend to handle all h263 streams */
int h263_decode_picture_header(MpegEncContext *s)
{
diff --git a/src/libffmpeg/libavcodec/mpeg12.c b/src/libffmpeg/libavcodec/mpeg12.c
index b74412ba8..31bc31ca7 100644
--- a/src/libffmpeg/libavcodec/mpeg12.c
+++ b/src/libffmpeg/libavcodec/mpeg12.c
@@ -65,21 +65,6 @@ static void mpeg1_encode_block(MpegEncContext *s,
int component);
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code); // RAL: f_code parameter added
#endif //CONFIG_ENCODERS
-static inline int mpeg1_decode_block_inter(MpegEncContext *s,
- DCTELEM *block,
- int n);
-static inline int mpeg1_decode_block_intra(MpegEncContext *s,
- DCTELEM *block,
- int n);
-static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n);
-static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
- DCTELEM *block,
- int n);
-static inline int mpeg2_decode_block_intra(MpegEncContext *s,
- DCTELEM *block,
- int n);
-static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, DCTELEM *block, int n);
-static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, DCTELEM *block, int n);
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
static void exchange_uv(MpegEncContext *s);
@@ -1054,436 +1039,6 @@ static inline int get_qscale(MpegEncContext *s)
#define MT_16X8 2
#define MT_DMV 3
-static int mpeg_decode_mb(MpegEncContext *s,
- DCTELEM block[12][64])
-{
- int i, j, k, cbp, val, mb_type, motion_type;
- const int mb_block_count = 4 + (1<< s->chroma_format);
-
- dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
-
- assert(s->mb_skipped==0);
-
- if (s->mb_skip_run-- != 0) {
- if(s->pict_type == I_TYPE){
- av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
- return -1;
- }
-
- /* skip mb */
- s->mb_intra = 0;
- for(i=0;i<12;i++)
- s->block_last_index[i] = -1;
- if(s->picture_structure == PICT_FRAME)
- s->mv_type = MV_TYPE_16X16;
- else
- s->mv_type = MV_TYPE_FIELD;
- if (s->pict_type == P_TYPE) {
- /* if P type, zero motion vector is implied */
- s->mv_dir = MV_DIR_FORWARD;
- s->mv[0][0][0] = s->mv[0][0][1] = 0;
- s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
- s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
- s->field_select[0][0]= s->picture_structure - 1;
- s->mb_skipped = 1;
- s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
- } else {
- int mb_type;
-
- if(s->mb_x)
- mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1];
- else
- mb_type= s->current_picture.mb_type[ s->mb_width + (s->mb_y-1)*s->mb_stride - 1]; // FIXME not sure if this is allowed in mpeg at all,
- if(IS_INTRA(mb_type))
- return -1;
-
- /* if B type, reuse previous vectors and directions */
- s->mv[0][0][0] = s->last_mv[0][0][0];
- s->mv[0][0][1] = s->last_mv[0][0][1];
- s->mv[1][0][0] = s->last_mv[1][0][0];
- s->mv[1][0][1] = s->last_mv[1][0][1];
-
- s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]=
- mb_type | MB_TYPE_SKIP;
-// assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
-
- if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0)
- s->mb_skipped = 1;
- }
-
- return 0;
- }
-
- switch(s->pict_type) {
- default:
- case I_TYPE:
- if (get_bits1(&s->gb) == 0) {
- if (get_bits1(&s->gb) == 0){
- av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
- return -1;
- }
- mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
- } else {
- mb_type = MB_TYPE_INTRA;
- }
- break;
- case P_TYPE:
- mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
- if (mb_type < 0){
- av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
- return -1;
- }
- mb_type = ptype2mb_type[ mb_type ];
- break;
- case B_TYPE:
- mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
- if (mb_type < 0){
- av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
- return -1;
- }
- mb_type = btype2mb_type[ mb_type ];
- break;
- }
- dprintf("mb_type=%x\n", mb_type);
-// motion_type = 0; /* avoid warning */
- if (IS_INTRA(mb_type)) {
- s->dsp.clear_blocks(s->block[0]);
-
- if(!s->chroma_y_shift){
- s->dsp.clear_blocks(s->block[6]);
- }
-
- /* compute dct type */
- if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
- !s->frame_pred_frame_dct) {
- s->interlaced_dct = get_bits1(&s->gb);
- }
-
- if (IS_QUANT(mb_type))
- s->qscale = get_qscale(s);
-
- if (s->concealment_motion_vectors) {
- /* just parse them */
- if (s->picture_structure != PICT_FRAME)
- skip_bits1(&s->gb); /* field select */
-
- s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
- mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
- s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
- mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
-
- skip_bits1(&s->gb); /* marker */
- }else
- memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
- s->mb_intra = 1;
-#ifdef HAVE_XVMC
- //one 1 we memcpy blocks in xvmcvideo
- if(s->avctx->xvmc_acceleration > 1){
- XVMC_pack_pblocks(s,-1);//inter are always full blocks
- if(s->swap_uv){
- exchange_uv(s);
- }
- }
-#endif
-
- if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
- if(s->flags2 & CODEC_FLAG2_FAST){
- for(i=0;i<6;i++) {
- mpeg2_fast_decode_block_intra(s, s->pblocks[i], i);
- }
- }else{
- for(i=0;i<mb_block_count;i++) {
- if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
- return -1;
- }
- }
- } else {
- for(i=0;i<6;i++) {
- if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
- return -1;
- }
- }
- } else {
- if (mb_type & MB_TYPE_ZERO_MV){
- assert(mb_type & MB_TYPE_CBP);
-
- /* compute dct type */
- if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
- !s->frame_pred_frame_dct) {
- s->interlaced_dct = get_bits1(&s->gb);
- }
-
- if (IS_QUANT(mb_type))
- s->qscale = get_qscale(s);
-
- s->mv_dir = MV_DIR_FORWARD;
- if(s->picture_structure == PICT_FRAME)
- s->mv_type = MV_TYPE_16X16;
- else{
- s->mv_type = MV_TYPE_FIELD;
- mb_type |= MB_TYPE_INTERLACED;
- s->field_select[0][0]= s->picture_structure - 1;
- }
- s->last_mv[0][0][0] = 0;
- s->last_mv[0][0][1] = 0;
- s->last_mv[0][1][0] = 0;
- s->last_mv[0][1][1] = 0;
- s->mv[0][0][0] = 0;
- s->mv[0][0][1] = 0;
- }else{
- assert(mb_type & MB_TYPE_L0L1);
-//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
- /* get additionnal motion vector type */
- if (s->frame_pred_frame_dct)
- motion_type = MT_FRAME;
- else{
- motion_type = get_bits(&s->gb, 2);
- }
-
- /* compute dct type */
- if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
- !s->frame_pred_frame_dct && HAS_CBP(mb_type)) {
- s->interlaced_dct = get_bits1(&s->gb);
- }
-
- if (IS_QUANT(mb_type))
- s->qscale = get_qscale(s);
-
- /* motion vectors */
- s->mv_dir = 0;
- for(i=0;i<2;i++) {
- if (USES_LIST(mb_type, i)) {
- s->mv_dir |= (MV_DIR_FORWARD >> i);
- dprintf("motion_type=%d\n", motion_type);
- switch(motion_type) {
- case MT_FRAME: /* or MT_16X8 */
- if (s->picture_structure == PICT_FRAME) {
- /* MT_FRAME */
- mb_type |= MB_TYPE_16x16;
- s->mv_type = MV_TYPE_16X16;
- s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
- mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
- s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
- mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
- /* full_pel: only for mpeg1 */
- if (s->full_pel[i]){
- s->mv[i][0][0] <<= 1;
- s->mv[i][0][1] <<= 1;
- }
- } else {
- /* MT_16X8 */
- mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
- s->mv_type = MV_TYPE_16X8;
- for(j=0;j<2;j++) {
- s->field_select[i][j] = get_bits1(&s->gb);
- for(k=0;k<2;k++) {
- val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
- s->last_mv[i][j][k]);
- s->last_mv[i][j][k] = val;
- s->mv[i][j][k] = val;
- }
- }
- }
- break;
- case MT_FIELD:
- s->mv_type = MV_TYPE_FIELD;
- if (s->picture_structure == PICT_FRAME) {
- mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
- for(j=0;j<2;j++) {
- s->field_select[i][j] = get_bits1(&s->gb);
- val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
- s->last_mv[i][j][0]);
- s->last_mv[i][j][0] = val;
- s->mv[i][j][0] = val;
- dprintf("fmx=%d\n", val);
- val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
- s->last_mv[i][j][1] >> 1);
- s->last_mv[i][j][1] = val << 1;
- s->mv[i][j][1] = val;
- dprintf("fmy=%d\n", val);
- }
- } else {
- mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
- s->field_select[i][0] = get_bits1(&s->gb);
- for(k=0;k<2;k++) {
- val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
- s->last_mv[i][0][k]);
- s->last_mv[i][0][k] = val;
- s->last_mv[i][1][k] = val;
- s->mv[i][0][k] = val;
- }
- }
- break;
- case MT_DMV:
- {
- int dmx, dmy, mx, my, m;
-
- mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
- s->last_mv[i][0][0]);
- s->last_mv[i][0][0] = mx;
- s->last_mv[i][1][0] = mx;
- dmx = get_dmv(s);
- my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
- s->last_mv[i][0][1] >> 1);
- dmy = get_dmv(s);
- s->mv_type = MV_TYPE_DMV;
-
-
- s->last_mv[i][0][1] = my<<1;
- s->last_mv[i][1][1] = my<<1;
-
- s->mv[i][0][0] = mx;
- s->mv[i][0][1] = my;
- s->mv[i][1][0] = mx;//not used
- s->mv[i][1][1] = my;//not used
-
- if (s->picture_structure == PICT_FRAME) {
- mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
-
- //m = 1 + 2 * s->top_field_first;
- m = s->top_field_first ? 1 : 3;
-
- /* top -> top pred */
- s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
- s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
- m = 4 - m;
- s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
- s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
- } else {
- mb_type |= MB_TYPE_16x16;
-
- s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
- s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
- if(s->picture_structure == PICT_TOP_FIELD)
- s->mv[i][2][1]--;
- else
- s->mv[i][2][1]++;
- }
- }
- break;
- default:
- av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
- return -1;
- }
- }
- }
- }
-
- s->mb_intra = 0;
- if (HAS_CBP(mb_type)) {
- s->dsp.clear_blocks(s->block[0]);
-
- if(!s->chroma_y_shift){
- s->dsp.clear_blocks(s->block[6]);
- }
-
- cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
- if (cbp < 0 || ((cbp == 0) && (s->chroma_format < 2)) ){
- av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
- return -1;
- }
- if(mb_block_count > 6){
- cbp<<= mb_block_count-6;
- cbp |= get_bits(&s->gb, mb_block_count-6);
- }
-
-#ifdef HAVE_XVMC
- //on 1 we memcpy blocks in xvmcvideo
- if(s->avctx->xvmc_acceleration > 1){
- XVMC_pack_pblocks(s,cbp);
- if(s->swap_uv){
- exchange_uv(s);
- }
- }
-#endif
-
- if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
- if(s->flags2 & CODEC_FLAG2_FAST){
- for(i=0;i<6;i++) {
- if(cbp & 32) {
- mpeg2_fast_decode_block_non_intra(s, s->pblocks[i], i);
- } else {
- s->block_last_index[i] = -1;
- }
- cbp+=cbp;
- }
- }else{
- cbp<<= 12-mb_block_count;
-
- for(i=0;i<mb_block_count;i++) {
- if ( cbp & (1<<11) ) {
- if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
- return -1;
- } else {
- s->block_last_index[i] = -1;
- }
- cbp+=cbp;
- }
- }
- } else {
- if(s->flags2 & CODEC_FLAG2_FAST){
- for(i=0;i<6;i++) {
- if (cbp & 32) {
- mpeg1_fast_decode_block_inter(s, s->pblocks[i], i);
- } else {
- s->block_last_index[i] = -1;
- }
- cbp+=cbp;
- }
- }else{
- for(i=0;i<6;i++) {
- if (cbp & 32) {
- if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0)
- return -1;
- } else {
- s->block_last_index[i] = -1;
- }
- cbp+=cbp;
- }
- }
- }
- }else{
- for(i=0;i<6;i++)
- s->block_last_index[i] = -1;
- }
- }
-
- s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
-
- return 0;
-}
-
-/* as h263, but only 17 codes */
-static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
-{
- int code, sign, val, l, shift;
-
- code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
- if (code == 0) {
- return pred;
- }
- if (code < 0) {
- return 0xffff;
- }
-
- sign = get_bits1(&s->gb);
- shift = fcode - 1;
- val = code;
- if (shift) {
- val = (val - 1) << shift;
- val |= get_bits(&s->gb, shift);
- val++;
- }
- if (sign)
- val = -val;
- val += pred;
-
- /* modulo decoding */
- l= INT_BIT - 5 - shift;
- val = (val<<l)>>l;
- return val;
-}
-
static inline int decode_dc(GetBitContext *gb, int component)
{
int code, diff;
@@ -2023,6 +1578,436 @@ static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
return 0;
}
+static int mpeg_decode_mb(MpegEncContext *s,
+ DCTELEM block[12][64])
+{
+ int i, j, k, cbp, val, mb_type, motion_type;
+ const int mb_block_count = 4 + (1<< s->chroma_format);
+
+ dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
+
+ assert(s->mb_skipped==0);
+
+ if (s->mb_skip_run-- != 0) {
+ if(s->pict_type == I_TYPE){
+ av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
+ return -1;
+ }
+
+ /* skip mb */
+ s->mb_intra = 0;
+ for(i=0;i<12;i++)
+ s->block_last_index[i] = -1;
+ if(s->picture_structure == PICT_FRAME)
+ s->mv_type = MV_TYPE_16X16;
+ else
+ s->mv_type = MV_TYPE_FIELD;
+ if (s->pict_type == P_TYPE) {
+ /* if P type, zero motion vector is implied */
+ s->mv_dir = MV_DIR_FORWARD;
+ s->mv[0][0][0] = s->mv[0][0][1] = 0;
+ s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
+ s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
+ s->field_select[0][0]= s->picture_structure - 1;
+ s->mb_skipped = 1;
+ s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
+ } else {
+ int mb_type;
+
+ if(s->mb_x)
+ mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1];
+ else
+ mb_type= s->current_picture.mb_type[ s->mb_width + (s->mb_y-1)*s->mb_stride - 1]; // FIXME not sure if this is allowed in mpeg at all,
+ if(IS_INTRA(mb_type))
+ return -1;
+
+ /* if B type, reuse previous vectors and directions */
+ s->mv[0][0][0] = s->last_mv[0][0][0];
+ s->mv[0][0][1] = s->last_mv[0][0][1];
+ s->mv[1][0][0] = s->last_mv[1][0][0];
+ s->mv[1][0][1] = s->last_mv[1][0][1];
+
+ s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]=
+ mb_type | MB_TYPE_SKIP;
+// assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
+
+ if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0)
+ s->mb_skipped = 1;
+ }
+
+ return 0;
+ }
+
+ switch(s->pict_type) {
+ default:
+ case I_TYPE:
+ if (get_bits1(&s->gb) == 0) {
+ if (get_bits1(&s->gb) == 0){
+ av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
+ return -1;
+ }
+ mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
+ } else {
+ mb_type = MB_TYPE_INTRA;
+ }
+ break;
+ case P_TYPE:
+ mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
+ if (mb_type < 0){
+ av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
+ return -1;
+ }
+ mb_type = ptype2mb_type[ mb_type ];
+ break;
+ case B_TYPE:
+ mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
+ if (mb_type < 0){
+ av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
+ return -1;
+ }
+ mb_type = btype2mb_type[ mb_type ];
+ break;
+ }
+ dprintf("mb_type=%x\n", mb_type);
+// motion_type = 0; /* avoid warning */
+ if (IS_INTRA(mb_type)) {
+ s->dsp.clear_blocks(s->block[0]);
+
+ if(!s->chroma_y_shift){
+ s->dsp.clear_blocks(s->block[6]);
+ }
+
+ /* compute dct type */
+ if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
+ !s->frame_pred_frame_dct) {
+ s->interlaced_dct = get_bits1(&s->gb);
+ }
+
+ if (IS_QUANT(mb_type))
+ s->qscale = get_qscale(s);
+
+ if (s->concealment_motion_vectors) {
+ /* just parse them */
+ if (s->picture_structure != PICT_FRAME)
+ skip_bits1(&s->gb); /* field select */
+
+ s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
+ mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
+ s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
+ mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
+
+ skip_bits1(&s->gb); /* marker */
+ }else
+ memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
+ s->mb_intra = 1;
+#ifdef HAVE_XVMC
+ //one 1 we memcpy blocks in xvmcvideo
+ if(s->avctx->xvmc_acceleration > 1){
+ XVMC_pack_pblocks(s,-1);//inter are always full blocks
+ if(s->swap_uv){
+ exchange_uv(s);
+ }
+ }
+#endif
+
+ if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
+ if(s->flags2 & CODEC_FLAG2_FAST){
+ for(i=0;i<6;i++) {
+ mpeg2_fast_decode_block_intra(s, s->pblocks[i], i);
+ }
+ }else{
+ for(i=0;i<mb_block_count;i++) {
+ if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
+ return -1;
+ }
+ }
+ } else {
+ for(i=0;i<6;i++) {
+ if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
+ return -1;
+ }
+ }
+ } else {
+ if (mb_type & MB_TYPE_ZERO_MV){
+ assert(mb_type & MB_TYPE_CBP);
+
+ /* compute dct type */
+ if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
+ !s->frame_pred_frame_dct) {
+ s->interlaced_dct = get_bits1(&s->gb);
+ }
+
+ if (IS_QUANT(mb_type))
+ s->qscale = get_qscale(s);
+
+ s->mv_dir = MV_DIR_FORWARD;
+ if(s->picture_structure == PICT_FRAME)
+ s->mv_type = MV_TYPE_16X16;
+ else{
+ s->mv_type = MV_TYPE_FIELD;
+ mb_type |= MB_TYPE_INTERLACED;
+ s->field_select[0][0]= s->picture_structure - 1;
+ }
+ s->last_mv[0][0][0] = 0;
+ s->last_mv[0][0][1] = 0;
+ s->last_mv[0][1][0] = 0;
+ s->last_mv[0][1][1] = 0;
+ s->mv[0][0][0] = 0;
+ s->mv[0][0][1] = 0;
+ }else{
+ assert(mb_type & MB_TYPE_L0L1);
+//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
+ /* get additionnal motion vector type */
+ if (s->frame_pred_frame_dct)
+ motion_type = MT_FRAME;
+ else{
+ motion_type = get_bits(&s->gb, 2);
+ }
+
+ /* compute dct type */
+ if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
+ !s->frame_pred_frame_dct && HAS_CBP(mb_type)) {
+ s->interlaced_dct = get_bits1(&s->gb);
+ }
+
+ if (IS_QUANT(mb_type))
+ s->qscale = get_qscale(s);
+
+ /* motion vectors */
+ s->mv_dir = 0;
+ for(i=0;i<2;i++) {
+ if (USES_LIST(mb_type, i)) {
+ s->mv_dir |= (MV_DIR_FORWARD >> i);
+ dprintf("motion_type=%d\n", motion_type);
+ switch(motion_type) {
+ case MT_FRAME: /* or MT_16X8 */
+ if (s->picture_structure == PICT_FRAME) {
+ /* MT_FRAME */
+ mb_type |= MB_TYPE_16x16;
+ s->mv_type = MV_TYPE_16X16;
+ s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
+ mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
+ s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
+ mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
+ /* full_pel: only for mpeg1 */
+ if (s->full_pel[i]){
+ s->mv[i][0][0] <<= 1;
+ s->mv[i][0][1] <<= 1;
+ }
+ } else {
+ /* MT_16X8 */
+ mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
+ s->mv_type = MV_TYPE_16X8;
+ for(j=0;j<2;j++) {
+ s->field_select[i][j] = get_bits1(&s->gb);
+ for(k=0;k<2;k++) {
+ val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
+ s->last_mv[i][j][k]);
+ s->last_mv[i][j][k] = val;
+ s->mv[i][j][k] = val;
+ }
+ }
+ }
+ break;
+ case MT_FIELD:
+ s->mv_type = MV_TYPE_FIELD;
+ if (s->picture_structure == PICT_FRAME) {
+ mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
+ for(j=0;j<2;j++) {
+ s->field_select[i][j] = get_bits1(&s->gb);
+ val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
+ s->last_mv[i][j][0]);
+ s->last_mv[i][j][0] = val;
+ s->mv[i][j][0] = val;
+ dprintf("fmx=%d\n", val);
+ val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
+ s->last_mv[i][j][1] >> 1);
+ s->last_mv[i][j][1] = val << 1;
+ s->mv[i][j][1] = val;
+ dprintf("fmy=%d\n", val);
+ }
+ } else {
+ mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
+ s->field_select[i][0] = get_bits1(&s->gb);
+ for(k=0;k<2;k++) {
+ val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
+ s->last_mv[i][0][k]);
+ s->last_mv[i][0][k] = val;
+ s->last_mv[i][1][k] = val;
+ s->mv[i][0][k] = val;
+ }
+ }
+ break;
+ case MT_DMV:
+ {
+ int dmx, dmy, mx, my, m;
+
+ mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
+ s->last_mv[i][0][0]);
+ s->last_mv[i][0][0] = mx;
+ s->last_mv[i][1][0] = mx;
+ dmx = get_dmv(s);
+ my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
+ s->last_mv[i][0][1] >> 1);
+ dmy = get_dmv(s);
+ s->mv_type = MV_TYPE_DMV;
+
+
+ s->last_mv[i][0][1] = my<<1;
+ s->last_mv[i][1][1] = my<<1;
+
+ s->mv[i][0][0] = mx;
+ s->mv[i][0][1] = my;
+ s->mv[i][1][0] = mx;//not used
+ s->mv[i][1][1] = my;//not used
+
+ if (s->picture_structure == PICT_FRAME) {
+ mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
+
+ //m = 1 + 2 * s->top_field_first;
+ m = s->top_field_first ? 1 : 3;
+
+ /* top -> top pred */
+ s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
+ s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
+ m = 4 - m;
+ s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
+ s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
+ } else {
+ mb_type |= MB_TYPE_16x16;
+
+ s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
+ s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
+ if(s->picture_structure == PICT_TOP_FIELD)
+ s->mv[i][2][1]--;
+ else
+ s->mv[i][2][1]++;
+ }
+ }
+ break;
+ default:
+ av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
+ return -1;
+ }
+ }
+ }
+ }
+
+ s->mb_intra = 0;
+ if (HAS_CBP(mb_type)) {
+ s->dsp.clear_blocks(s->block[0]);
+
+ if(!s->chroma_y_shift){
+ s->dsp.clear_blocks(s->block[6]);
+ }
+
+ cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
+ if (cbp < 0 || ((cbp == 0) && (s->chroma_format < 2)) ){
+ av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
+ return -1;
+ }
+ if(mb_block_count > 6){
+ cbp<<= mb_block_count-6;
+ cbp |= get_bits(&s->gb, mb_block_count-6);
+ }
+
+#ifdef HAVE_XVMC
+ //on 1 we memcpy blocks in xvmcvideo
+ if(s->avctx->xvmc_acceleration > 1){
+ XVMC_pack_pblocks(s,cbp);
+ if(s->swap_uv){
+ exchange_uv(s);
+ }
+ }
+#endif
+
+ if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
+ if(s->flags2 & CODEC_FLAG2_FAST){
+ for(i=0;i<6;i++) {
+ if(cbp & 32) {
+ mpeg2_fast_decode_block_non_intra(s, s->pblocks[i], i);
+ } else {
+ s->block_last_index[i] = -1;
+ }
+ cbp+=cbp;
+ }
+ }else{
+ cbp<<= 12-mb_block_count;
+
+ for(i=0;i<mb_block_count;i++) {
+ if ( cbp & (1<<11) ) {
+ if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
+ return -1;
+ } else {
+ s->block_last_index[i] = -1;
+ }
+ cbp+=cbp;
+ }
+ }
+ } else {
+ if(s->flags2 & CODEC_FLAG2_FAST){
+ for(i=0;i<6;i++) {
+ if (cbp & 32) {
+ mpeg1_fast_decode_block_inter(s, s->pblocks[i], i);
+ } else {
+ s->block_last_index[i] = -1;
+ }
+ cbp+=cbp;
+ }
+ }else{
+ for(i=0;i<6;i++) {
+ if (cbp & 32) {
+ if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0)
+ return -1;
+ } else {
+ s->block_last_index[i] = -1;
+ }
+ cbp+=cbp;
+ }
+ }
+ }
+ }else{
+ for(i=0;i<6;i++)
+ s->block_last_index[i] = -1;
+ }
+ }
+
+ s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
+
+ return 0;
+}
+
+/* as h263, but only 17 codes */
+static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
+{
+ int code, sign, val, l, shift;
+
+ code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
+ if (code == 0) {
+ return pred;
+ }
+ if (code < 0) {
+ return 0xffff;
+ }
+
+ sign = get_bits1(&s->gb);
+ shift = fcode - 1;
+ val = code;
+ if (shift) {
+ val = (val - 1) << shift;
+ val |= get_bits(&s->gb, shift);
+ val++;
+ }
+ if (sign)
+ val = -val;
+ val += pred;
+
+ /* modulo decoding */
+ l= INT_BIT - 5 - shift;
+ val = (val<<l)>>l;
+ return val;
+}
+
typedef struct Mpeg1Context {
MpegEncContext mpeg_enc_ctx;
int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
diff --git a/src/libffmpeg/libavcodec/mpegvideo.h b/src/libffmpeg/libavcodec/mpegvideo.h
index df67a469c..f5db85952 100644
--- a/src/libffmpeg/libavcodec/mpegvideo.h
+++ b/src/libffmpeg/libavcodec/mpegvideo.h
@@ -810,10 +810,10 @@ void ff_fix_long_mvs(MpegEncContext * s, uint8_t *field_select_table, int field_
int16_t (*mv_table)[2], int f_code, int type, int truncate);
void ff_init_me(MpegEncContext *s);
int ff_pre_estimate_p_frame_motion(MpegEncContext * s, int mb_x, int mb_y);
-inline int ff_epzs_motion_search(MpegEncContext * s, int *mx_ptr, int *my_ptr,
+extern __inline__ int ff_epzs_motion_search(MpegEncContext * s, int *mx_ptr, int *my_ptr,
int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2],
int ref_mv_scale, int size, int h);
-int inline ff_get_mb_score(MpegEncContext * s, int mx, int my, int src_index,
+extern __inline__ int ff_get_mb_score(MpegEncContext * s, int mx, int my, int src_index,
int ref_index, int size, int h, int add_rate);
/* mpeg12.c */
diff --git a/src/libffmpeg/libavcodec/msmpeg4.c b/src/libffmpeg/libavcodec/msmpeg4.c
index 643ed33c6..3ac3e0df4 100644
--- a/src/libffmpeg/libavcodec/msmpeg4.c
+++ b/src/libffmpeg/libavcodec/msmpeg4.c
@@ -59,9 +59,7 @@
static uint32_t v2_dc_lum_table[512][2];
static uint32_t v2_dc_chroma_table[512][2];
-static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
-static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
- int n, int coded, const uint8_t *scantable);
+static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr);
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
static int msmpeg4_decode_motion(MpegEncContext * s,
int *mx_ptr, int *my_ptr);
@@ -536,6 +534,129 @@ static inline void handle_slices(MpegEncContext *s){
}
}
+/* Encoding of a block. Very similar to MPEG4 except for a different
+ escape coding (same as H263) and more vlc tables.
+ */
+static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
+{
+ int level, run, last, i, j, last_index;
+ int last_non_zero, sign, slevel;
+ int code, run_diff, dc_pred_dir;
+ const RLTable *rl;
+ const uint8_t *scantable;
+
+ if (s->mb_intra) {
+ set_stat(ST_DC);
+ msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
+ i = 1;
+ if (n < 4) {
+ rl = &rl_table[s->rl_table_index];
+ } else {
+ rl = &rl_table[3 + s->rl_chroma_table_index];
+ }
+ run_diff = 0;
+ scantable= s->intra_scantable.permutated;
+ set_stat(ST_INTRA_AC);
+ } else {
+ i = 0;
+ rl = &rl_table[3 + s->rl_table_index];
+ if(s->msmpeg4_version<=2)
+ run_diff = 0;
+ else
+ run_diff = 1;
+ scantable= s->inter_scantable.permutated;
+ set_stat(ST_INTER_AC);
+ }
+
+ /* recalculate block_last_index for M$ wmv1 */
+ if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
+ for(last_index=63; last_index>=0; last_index--){
+ if(block[scantable[last_index]]) break;
+ }
+ s->block_last_index[n]= last_index;
+ }else
+ last_index = s->block_last_index[n];
+ /* AC coefs */
+ last_non_zero = i - 1;
+ for (; i <= last_index; i++) {
+ j = scantable[i];
+ level = block[j];
+ if (level) {
+ run = i - last_non_zero - 1;
+ last = (i == last_index);
+ sign = 0;
+ slevel = level;
+ if (level < 0) {
+ sign = 1;
+ level = -level;
+ }
+
+ if(level<=MAX_LEVEL && run<=MAX_RUN){
+ s->ac_stats[s->mb_intra][n>3][level][run][last]++;
+ }
+#if 0
+else
+ s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
+#endif
+ code = get_rl_index(rl, last, run, level);
+ put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+ if (code == rl->n) {
+ int level1, run1;
+
+ level1 = level - rl->max_level[last][run];
+ if (level1 < 1)
+ goto esc2;
+ code = get_rl_index(rl, last, run, level1);
+ if (code == rl->n) {
+ esc2:
+ put_bits(&s->pb, 1, 0);
+ if (level > MAX_LEVEL)
+ goto esc3;
+ run1 = run - rl->max_run[last][level] - run_diff;
+ if (run1 < 0)
+ goto esc3;
+ code = get_rl_index(rl, last, run1, level);
+ if (code == rl->n) {
+ esc3:
+ /* third escape */
+ put_bits(&s->pb, 1, 0);
+ put_bits(&s->pb, 1, last);
+ if(s->msmpeg4_version>=4){
+ if(s->esc3_level_length==0){
+ s->esc3_level_length=8;
+ s->esc3_run_length= 6;
+ if(s->qscale<8)
+ put_bits(&s->pb, 6, 3);
+ else
+ put_bits(&s->pb, 8, 3);
+ }
+ put_bits(&s->pb, s->esc3_run_length, run);
+ put_bits(&s->pb, 1, sign);
+ put_bits(&s->pb, s->esc3_level_length, level);
+ }else{
+ put_bits(&s->pb, 6, run);
+ put_bits(&s->pb, 8, slevel & 0xff);
+ }
+ } else {
+ /* second escape */
+ put_bits(&s->pb, 1, 1);
+ put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+ put_bits(&s->pb, 1, sign);
+ }
+ } else {
+ /* first escape */
+ put_bits(&s->pb, 1, 1);
+ put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
+ put_bits(&s->pb, 1, sign);
+ }
+ } else {
+ put_bits(&s->pb, 1, sign);
+ }
+ last_non_zero = i;
+ }
+ }
+}
+
void msmpeg4_encode_mb(MpegEncContext * s,
DCTELEM block[6][64],
int motion_x, int motion_y)
@@ -915,129 +1036,6 @@ static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr
}
}
-/* Encoding of a block. Very similar to MPEG4 except for a different
- escape coding (same as H263) and more vlc tables.
- */
-static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
-{
- int level, run, last, i, j, last_index;
- int last_non_zero, sign, slevel;
- int code, run_diff, dc_pred_dir;
- const RLTable *rl;
- const uint8_t *scantable;
-
- if (s->mb_intra) {
- set_stat(ST_DC);
- msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
- i = 1;
- if (n < 4) {
- rl = &rl_table[s->rl_table_index];
- } else {
- rl = &rl_table[3 + s->rl_chroma_table_index];
- }
- run_diff = 0;
- scantable= s->intra_scantable.permutated;
- set_stat(ST_INTRA_AC);
- } else {
- i = 0;
- rl = &rl_table[3 + s->rl_table_index];
- if(s->msmpeg4_version<=2)
- run_diff = 0;
- else
- run_diff = 1;
- scantable= s->inter_scantable.permutated;
- set_stat(ST_INTER_AC);
- }
-
- /* recalculate block_last_index for M$ wmv1 */
- if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
- for(last_index=63; last_index>=0; last_index--){
- if(block[scantable[last_index]]) break;
- }
- s->block_last_index[n]= last_index;
- }else
- last_index = s->block_last_index[n];
- /* AC coefs */
- last_non_zero = i - 1;
- for (; i <= last_index; i++) {
- j = scantable[i];
- level = block[j];
- if (level) {
- run = i - last_non_zero - 1;
- last = (i == last_index);
- sign = 0;
- slevel = level;
- if (level < 0) {
- sign = 1;
- level = -level;
- }
-
- if(level<=MAX_LEVEL && run<=MAX_RUN){
- s->ac_stats[s->mb_intra][n>3][level][run][last]++;
- }
-#if 0
-else
- s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
-#endif
- code = get_rl_index(rl, last, run, level);
- put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
- if (code == rl->n) {
- int level1, run1;
-
- level1 = level - rl->max_level[last][run];
- if (level1 < 1)
- goto esc2;
- code = get_rl_index(rl, last, run, level1);
- if (code == rl->n) {
- esc2:
- put_bits(&s->pb, 1, 0);
- if (level > MAX_LEVEL)
- goto esc3;
- run1 = run - rl->max_run[last][level] - run_diff;
- if (run1 < 0)
- goto esc3;
- code = get_rl_index(rl, last, run1, level);
- if (code == rl->n) {
- esc3:
- /* third escape */
- put_bits(&s->pb, 1, 0);
- put_bits(&s->pb, 1, last);
- if(s->msmpeg4_version>=4){
- if(s->esc3_level_length==0){
- s->esc3_level_length=8;
- s->esc3_run_length= 6;
- if(s->qscale<8)
- put_bits(&s->pb, 6, 3);
- else
- put_bits(&s->pb, 8, 3);
- }
- put_bits(&s->pb, s->esc3_run_length, run);
- put_bits(&s->pb, 1, sign);
- put_bits(&s->pb, s->esc3_level_length, level);
- }else{
- put_bits(&s->pb, 6, run);
- put_bits(&s->pb, 8, slevel & 0xff);
- }
- } else {
- /* second escape */
- put_bits(&s->pb, 1, 1);
- put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
- put_bits(&s->pb, 1, sign);
- }
- } else {
- /* first escape */
- put_bits(&s->pb, 1, 1);
- put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
- put_bits(&s->pb, 1, sign);
- }
- } else {
- put_bits(&s->pb, 1, sign);
- }
- last_non_zero = i;
- }
- }
-}
-
/****************************************/
/* decoding stuff */
@@ -1482,185 +1480,6 @@ static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
return val;
}
-static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
-{
- int cbp, code, i;
-
- if (s->pict_type == P_TYPE) {
- if (s->use_skip_mb_code) {
- if (get_bits1(&s->gb)) {
- /* skip mb */
- s->mb_intra = 0;
- for(i=0;i<6;i++)
- s->block_last_index[i] = -1;
- s->mv_dir = MV_DIR_FORWARD;
- s->mv_type = MV_TYPE_16X16;
- s->mv[0][0][0] = 0;
- s->mv[0][0][1] = 0;
- s->mb_skipped = 1;
- return 0;
- }
- }
-
- if(s->msmpeg4_version==2)
- code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
- else
- code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
- if(code<0 || code>7){
- av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
- return -1;
- }
-
- s->mb_intra = code >>2;
-
- cbp = code & 0x3;
- } else {
- s->mb_intra = 1;
- if(s->msmpeg4_version==2)
- cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
- else
- cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
- if(cbp<0 || cbp>3){
- av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
- return -1;
- }
- }
-
- if (!s->mb_intra) {
- int mx, my, cbpy;
-
- cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
- if(cbpy<0){
- av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
- return -1;
- }
-
- cbp|= cbpy<<2;
- if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
-
- h263_pred_motion(s, 0, 0, &mx, &my);
- mx= msmpeg4v2_decode_motion(s, mx, 1);
- my= msmpeg4v2_decode_motion(s, my, 1);
-
- s->mv_dir = MV_DIR_FORWARD;
- s->mv_type = MV_TYPE_16X16;
- s->mv[0][0][0] = mx;
- s->mv[0][0][1] = my;
- } else {
- if(s->msmpeg4_version==2){
- s->ac_pred = get_bits1(&s->gb);
- cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
- } else{
- s->ac_pred = 0;
- cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
- if(s->pict_type==P_TYPE) cbp^=0x3C;
- }
- }
-
- s->dsp.clear_blocks(s->block[0]);
- for (i = 0; i < 6; i++) {
- if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
- {
- av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
- return -1;
- }
- }
- return 0;
-}
-
-static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
-{
- int cbp, code, i;
- uint8_t *coded_val;
- uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
-
- if (s->pict_type == P_TYPE) {
- set_stat(ST_INTER_MB);
- if (s->use_skip_mb_code) {
- if (get_bits1(&s->gb)) {
- /* skip mb */
- s->mb_intra = 0;
- for(i=0;i<6;i++)
- s->block_last_index[i] = -1;
- s->mv_dir = MV_DIR_FORWARD;
- s->mv_type = MV_TYPE_16X16;
- s->mv[0][0][0] = 0;
- s->mv[0][0][1] = 0;
- s->mb_skipped = 1;
- *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
-
- return 0;
- }
- }
-
- code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
- if (code < 0)
- return -1;
- //s->mb_intra = (code & 0x40) ? 0 : 1;
- s->mb_intra = (~code & 0x40) >> 6;
-
- cbp = code & 0x3f;
- } else {
- set_stat(ST_INTRA_MB);
- s->mb_intra = 1;
- code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
- if (code < 0)
- return -1;
- /* predict coded block pattern */
- cbp = 0;
- for(i=0;i<6;i++) {
- int val = ((code >> (5 - i)) & 1);
- if (i < 4) {
- int pred = coded_block_pred(s, i, &coded_val);
- val = val ^ pred;
- *coded_val = val;
- }
- cbp |= val << (5 - i);
- }
- }
-
- if (!s->mb_intra) {
- int mx, my;
-//printf("P at %d %d\n", s->mb_x, s->mb_y);
- if(s->per_mb_rl_table && cbp){
- s->rl_table_index = decode012(&s->gb);
- s->rl_chroma_table_index = s->rl_table_index;
- }
- set_stat(ST_MV);
- h263_pred_motion(s, 0, 0, &mx, &my);
- if (msmpeg4_decode_motion(s, &mx, &my) < 0)
- return -1;
- s->mv_dir = MV_DIR_FORWARD;
- s->mv_type = MV_TYPE_16X16;
- s->mv[0][0][0] = mx;
- s->mv[0][0][1] = my;
- *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
- } else {
-//printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24));
- set_stat(ST_INTRA_MB);
- s->ac_pred = get_bits1(&s->gb);
- *mb_type_ptr = MB_TYPE_INTRA;
- if(s->inter_intra_pred){
- s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
-// printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
- }
- if(s->per_mb_rl_table && cbp){
- s->rl_table_index = decode012(&s->gb);
- s->rl_chroma_table_index = s->rl_table_index;
- }
- }
-
- s->dsp.clear_blocks(s->block[0]);
- for (i = 0; i < 6; i++) {
- if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
- {
- av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
- return -1;
- }
- }
-
- return 0;
-}
//#define ERROR_DETAILS
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
int n, int coded, const uint8_t *scan_table)
@@ -1912,6 +1731,186 @@ static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
return 0;
}
+static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
+{
+ int cbp, code, i;
+
+ if (s->pict_type == P_TYPE) {
+ if (s->use_skip_mb_code) {
+ if (get_bits1(&s->gb)) {
+ /* skip mb */
+ s->mb_intra = 0;
+ for(i=0;i<6;i++)
+ s->block_last_index[i] = -1;
+ s->mv_dir = MV_DIR_FORWARD;
+ s->mv_type = MV_TYPE_16X16;
+ s->mv[0][0][0] = 0;
+ s->mv[0][0][1] = 0;
+ s->mb_skipped = 1;
+ return 0;
+ }
+ }
+
+ if(s->msmpeg4_version==2)
+ code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
+ else
+ code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
+ if(code<0 || code>7){
+ av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
+ return -1;
+ }
+
+ s->mb_intra = code >>2;
+
+ cbp = code & 0x3;
+ } else {
+ s->mb_intra = 1;
+ if(s->msmpeg4_version==2)
+ cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
+ else
+ cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
+ if(cbp<0 || cbp>3){
+ av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
+ return -1;
+ }
+ }
+
+ if (!s->mb_intra) {
+ int mx, my, cbpy;
+
+ cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
+ if(cbpy<0){
+ av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
+ return -1;
+ }
+
+ cbp|= cbpy<<2;
+ if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
+
+ h263_pred_motion(s, 0, 0, &mx, &my);
+ mx= msmpeg4v2_decode_motion(s, mx, 1);
+ my= msmpeg4v2_decode_motion(s, my, 1);
+
+ s->mv_dir = MV_DIR_FORWARD;
+ s->mv_type = MV_TYPE_16X16;
+ s->mv[0][0][0] = mx;
+ s->mv[0][0][1] = my;
+ } else {
+ if(s->msmpeg4_version==2){
+ s->ac_pred = get_bits1(&s->gb);
+ cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
+ } else{
+ s->ac_pred = 0;
+ cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
+ if(s->pict_type==P_TYPE) cbp^=0x3C;
+ }
+ }
+
+ s->dsp.clear_blocks(s->block[0]);
+ for (i = 0; i < 6; i++) {
+ if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
+ {
+ av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
+{
+ int cbp, code, i;
+ uint8_t *coded_val;
+ uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
+
+ if (s->pict_type == P_TYPE) {
+ set_stat(ST_INTER_MB);
+ if (s->use_skip_mb_code) {
+ if (get_bits1(&s->gb)) {
+ /* skip mb */
+ s->mb_intra = 0;
+ for(i=0;i<6;i++)
+ s->block_last_index[i] = -1;
+ s->mv_dir = MV_DIR_FORWARD;
+ s->mv_type = MV_TYPE_16X16;
+ s->mv[0][0][0] = 0;
+ s->mv[0][0][1] = 0;
+ s->mb_skipped = 1;
+ *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
+
+ return 0;
+ }
+ }
+
+ code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
+ if (code < 0)
+ return -1;
+ //s->mb_intra = (code & 0x40) ? 0 : 1;
+ s->mb_intra = (~code & 0x40) >> 6;
+
+ cbp = code & 0x3f;
+ } else {
+ set_stat(ST_INTRA_MB);
+ s->mb_intra = 1;
+ code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
+ if (code < 0)
+ return -1;
+ /* predict coded block pattern */
+ cbp = 0;
+ for(i=0;i<6;i++) {
+ int val = ((code >> (5 - i)) & 1);
+ if (i < 4) {
+ int pred = coded_block_pred(s, i, &coded_val);
+ val = val ^ pred;
+ *coded_val = val;
+ }
+ cbp |= val << (5 - i);
+ }
+ }
+
+ if (!s->mb_intra) {
+ int mx, my;
+//printf("P at %d %d\n", s->mb_x, s->mb_y);
+ if(s->per_mb_rl_table && cbp){
+ s->rl_table_index = decode012(&s->gb);
+ s->rl_chroma_table_index = s->rl_table_index;
+ }
+ set_stat(ST_MV);
+ h263_pred_motion(s, 0, 0, &mx, &my);
+ if (msmpeg4_decode_motion(s, &mx, &my) < 0)
+ return -1;
+ s->mv_dir = MV_DIR_FORWARD;
+ s->mv_type = MV_TYPE_16X16;
+ s->mv[0][0][0] = mx;
+ s->mv[0][0][1] = my;
+ *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
+ } else {
+//printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24));
+ set_stat(ST_INTRA_MB);
+ s->ac_pred = get_bits1(&s->gb);
+ *mb_type_ptr = MB_TYPE_INTRA;
+ if(s->inter_intra_pred){
+ s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
+// printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
+ }
+ if(s->per_mb_rl_table && cbp){
+ s->rl_table_index = decode012(&s->gb);
+ s->rl_chroma_table_index = s->rl_table_index;
+ }
+ }
+
+ s->dsp.clear_blocks(s->block[0]);
+ for (i = 0; i < 6; i++) {
+ if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
+ {
+ av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
{
int level, pred;
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-22 11:44:43 +0000