/*
* MSMPEG4 backend for ffmpeg encoder and decoder
- * Copyright (c) 2001 Fabrice Bellard.
+ * Copyright (c) 2001 Fabrice Bellard
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
*
- * This library is free software; you can redistribute it and/or
+ * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
*
- * This library is distributed in the hope that it will be useful,
+ * FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
- * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
*/
/**
- * @file msmpeg4.c
+ * @file libavcodec/msmpeg4.c
* MSMPEG4 backend for ffmpeg encoder and decoder.
*/
#include "avcodec.h"
#include "dsputil.h"
#include "mpegvideo.h"
+#include "msmpeg4.h"
/*
* You can also call this codec : MPEG4 with a twist !
#define DC_VLC_BITS 9
#define CBPY_VLC_BITS 6
-#define INTER_INTRA_VLC_BITS 3
#define V1_INTRA_CBPC_VLC_BITS 6
#define V1_INTER_CBPC_VLC_BITS 6
#define V2_INTRA_CBPC_VLC_BITS 3
#define MV_VLC_BITS 9
#define V2_MV_VLC_BITS 9
#define TEX_VLC_BITS 9
-#define MB_NON_INTRA_VLC_BITS 9
-#define MB_INTRA_VLC_BITS 9
#define II_BITRATE 128*1024
#define MBAC_BITRATE 50*1024
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 int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
-static int msmpeg4_decode_motion(MpegEncContext * s,
- int *mx_ptr, int *my_ptr);
static void init_h263_dc_for_msmpeg4(void);
static inline void msmpeg4_memsetw(short *tab, int val, int n);
-#ifdef CONFIG_ENCODERS
+#if CONFIG_ENCODERS
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
#endif //CONFIG_ENCODERS
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
-static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
/* vc1 externs */
-extern uint8_t wmv3_dc_scale_table[32];
+extern const uint8_t wmv3_dc_scale_table[32];
#ifdef DEBUG
int intra_count = 0;
#include "msmpeg4data.h"
-#ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references
+#if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
#endif //CONFIG_ENCODERS
+static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
+
static void common_init(MpegEncContext * s)
{
- static int inited=0;
+ static int initialized=0;
switch(s->msmpeg4_version){
case 1:
case 3:
if(s->workaround_bugs){
s->y_dc_scale_table= old_ff_y_dc_scale_table;
- s->c_dc_scale_table= old_ff_c_dc_scale_table;
+ s->c_dc_scale_table= wmv1_c_dc_scale_table;
} else{
s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
s->y_dc_scale_table= wmv1_y_dc_scale_table;
s->c_dc_scale_table= wmv1_c_dc_scale_table;
break;
-#if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC1_DECODER)
+#if CONFIG_WMV3_DECODER || CONFIG_VC1_DECODER
case 6:
s->y_dc_scale_table= wmv3_dc_scale_table;
s->c_dc_scale_table= wmv3_dc_scale_table;
}
//Note the default tables are set in common_init in mpegvideo.c
- if(!inited){
- inited=1;
+ if(!initialized){
+ initialized=1;
init_h263_dc_for_msmpeg4();
}
}
-#ifdef CONFIG_ENCODERS
+#if CONFIG_ENCODERS
/* build the table which associate a (x,y) motion vector to a vlc */
static void init_mv_table(MVTable *tab)
}
}
-static void code012(PutBitContext *pb, int n)
+void ff_msmpeg4_code012(PutBitContext *pb, int n)
{
if (n == 0) {
put_bits(pb, 1, 0);
init_mv_table(&mv_tables[0]);
init_mv_table(&mv_tables[1]);
for(i=0;i<NB_RL_TABLES;i++)
- init_rl(&rl_table[i], 1);
+ init_rl(&rl_table[i], static_rl_table_store[i]);
for(i=0; i<NB_RL_TABLES; i++){
int level;
int intra_luma_count = s->ac_stats[1][0][level][run][last];
int intra_chroma_count= s->ac_stats[1][1][level][run][last];
- if(s->pict_type==I_TYPE){
+ if(s->pict_type==FF_I_TYPE){
size += intra_luma_count *rl_length[i ][level][run][last];
chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
}else{
// printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
// s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
- if(s->pict_type==P_TYPE) chroma_best= best;
+ if(s->pict_type==FF_P_TYPE) chroma_best= best;
memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
if(s->pict_type != s->last_non_b_pict_type){
s->rl_table_index= 2;
- if(s->pict_type==I_TYPE)
+ if(s->pict_type==FF_I_TYPE)
s->rl_chroma_table_index= 1;
else
s->rl_chroma_table_index= 2;
s->use_skip_mb_code = 1; /* only if P frame */
s->per_mb_rl_table = 0;
if(s->msmpeg4_version==4)
- s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
+ s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==FF_P_TYPE);
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
- if (s->pict_type == I_TYPE) {
+ if (s->pict_type == FF_I_TYPE) {
s->slice_height= s->mb_height/1;
put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
if(s->msmpeg4_version>2){
if(!s->per_mb_rl_table){
- code012(&s->pb, s->rl_chroma_table_index);
- code012(&s->pb, s->rl_table_index);
+ ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
+ ff_msmpeg4_code012(&s->pb, s->rl_table_index);
}
put_bits(&s->pb, 1, s->dc_table_index);
if(s->msmpeg4_version>2){
if(!s->per_mb_rl_table)
- code012(&s->pb, s->rl_table_index);
+ ff_msmpeg4_code012(&s->pb, s->rl_table_index);
put_bits(&s->pb, 1, s->dc_table_index);
#endif //CONFIG_ENCODERS
/* predict coded block */
-static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
+int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
{
int xy, wrap, pred, a, b, c;
return pred;
}
-#ifdef CONFIG_ENCODERS
+#if CONFIG_ENCODERS
-static void msmpeg4_encode_motion(MpegEncContext * s,
+void ff_msmpeg4_encode_motion(MpegEncContext * s,
int mx, int my)
{
int code;
mv->table_mv_bits[code],
mv->table_mv_code[code]);
if (code == mv->n) {
- /* escape : code litterally */
+ /* escape : code literally */
put_bits(&s->pb, 6, mx);
put_bits(&s->pb, 6, my);
}
}
-static inline void handle_slices(MpegEncContext *s){
+void ff_msmpeg4_handle_slices(MpegEncContext *s){
if (s->mb_x == 0) {
if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
if(s->msmpeg4_version < 4){
int pred_x, pred_y;
uint8_t *coded_block;
- handle_slices(s);
+ ff_msmpeg4_handle_slices(s);
if (!s->mb_intra) {
/* compute cbp */
/* motion vector */
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
- msmpeg4_encode_motion(s, motion_x - pred_x,
+ ff_msmpeg4_encode_motion(s, motion_x - pred_x,
motion_y - pred_y);
}
s->mv_bits += get_bits_diff(s);
for (i = 0; i < 6; i++) {
- msmpeg4_encode_block(s, block[i], i);
+ ff_msmpeg4_encode_block(s, block[i], i);
}
s->p_tex_bits += get_bits_diff(s);
} else {
cbp |= val << (5 - i);
if (i < 4) {
/* predict value for close blocks only for luma */
- pred = coded_block_pred(s, i, &coded_block);
+ pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
*coded_block = val;
val = val ^ pred;
}
#endif
if(s->msmpeg4_version<=2){
- if (s->pict_type == I_TYPE) {
+ if (s->pict_type == FF_I_TYPE) {
put_bits(&s->pb,
v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
} else {
cbpy_tab[cbp>>2][1],
cbpy_tab[cbp>>2][0]);
}else{
- if (s->pict_type == I_TYPE) {
+ if (s->pict_type == FF_I_TYPE) {
put_bits(&s->pb,
ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
} else {
s->misc_bits += get_bits_diff(s);
for (i = 0; i < 6; i++) {
- msmpeg4_encode_block(s, block[i], i);
+ ff_msmpeg4_encode_block(s, block[i], i);
}
s->i_tex_bits += get_bits_diff(s);
s->i_count++;
necessitate to modify mpegvideo.c. The problem comes from the
fact they decided to store the quantized DC (which would lead
to problems if Q could vary !) */
-#if (defined(ARCH_X86) || defined(ARCH_X86_64)) && !defined PIC
- asm volatile(
+#if ARCH_X86 && !defined PIC
+ __asm__ volatile(
"movl %3, %%eax \n\t"
"shrl $1, %%eax \n\t"
"addl %%eax, %2 \n\t"
"mull %4 \n\t"
"movl %%edx, %2 \n\t"
: "+b" (a), "+c" (b), "+D" (c)
- : "g" (scale), "S" (inverse[scale])
+ : "g" (scale), "S" (ff_inverse[scale])
: "%eax", "%edx"
);
#else
- /* #elif defined (ARCH_ALPHA) */
+ /* #elif ARCH_ALPHA */
/* Divisions are extremely costly on Alpha; optimize the most
common case. But they are costly everywhere...
*/
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
{
int sign, code;
- int pred;
+ int pred, extquant;
+ int extrabits = 0;
if(s->msmpeg4_version==1){
int32_t *dc_val;
code = level;
if (code > DC_MAX)
code = DC_MAX;
+ else if( s->msmpeg4_version>=6 ) {
+ if( s->qscale == 1 ) {
+ extquant = (level + 3) & 0x3;
+ code = ((level+3)>>2);
+ } else if( s->qscale == 2 ) {
+ extquant = (level + 1) & 0x1;
+ code = ((level+1)>>1);
+ }
+ }
if (s->dc_table_index == 0) {
if (n < 4) {
}
}
+ if(s->msmpeg4_version>=6 && s->qscale<=2)
+ extrabits = 3 - s->qscale;
+
if (code == DC_MAX)
- put_bits(&s->pb, 8, level);
+ put_bits(&s->pb, 8 + extrabits, level);
+ else if(extrabits > 0)//== VC1 && s->qscale<=2
+ put_bits(&s->pb, extrabits, extquant);
if (level != 0) {
put_bits(&s->pb, 1, sign);
/* 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)
+void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
{
int level, run, last, i, j, last_index;
int last_non_zero, sign, slevel;
} else {
rl = &rl_table[3 + s->rl_chroma_table_index];
}
- run_diff = 0;
+ run_diff = s->msmpeg4_version>=4;
scantable= s->intra_scantable.permutated;
} else {
i = 0;
}
/* recalculate block_last_index for M$ wmv1 */
- if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
+ if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
for(last_index=63; last_index>=0; last_index--){
if(block[scantable[last_index]]) break;
}
run1 = run - rl->max_run[last][level] - run_diff;
if (run1 < 0)
goto esc3;
+ code = get_rl_index(rl, last, run1+1, level);
+ if (s->msmpeg4_version == 4 && code == rl->n)
+ goto esc3;
code = get_rl_index(rl, last, run1, level);
if (code == rl->n) {
esc3:
if(s->esc3_level_length==0){
s->esc3_level_length=8;
s->esc3_run_length= 6;
+ //ESCLVLSZ + ESCRUNSZ
if(s->qscale<8)
- put_bits(&s->pb, 6, 3);
+ put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
else
put_bits(&s->pb, 8, 3);
}
put_bits(&s->pb, s->esc3_level_length, level);
}else{
put_bits(&s->pb, 6, run);
- put_bits(&s->pb, 8, slevel & 0xff);
+ put_sbits(&s->pb, 8, slevel);
}
} else {
/* second escape */
/****************************************/
/* decoding stuff */
-static VLC mb_non_intra_vlc[4];
-VLC ff_msmp4_mb_i_vlc;
-VLC ff_msmp4_dc_luma_vlc[2];
-VLC ff_msmp4_dc_chroma_vlc[2];
+VLC ff_mb_non_intra_vlc[4];
static VLC v2_dc_lum_vlc;
static VLC v2_dc_chroma_vlc;
static VLC cbpy_vlc;
static VLC v2_mv_vlc;
static VLC v1_intra_cbpc_vlc;
static VLC v1_inter_cbpc_vlc;
-static VLC inter_intra_vlc;
+VLC ff_inter_intra_vlc;
-/* this table is practically identical to the one from h263 except that its inverted */
+/* This table is practically identical to the one from h263
+ * except that it is inverted. */
static void init_h263_dc_for_msmpeg4(void)
{
int level, uni_code, uni_len;
/* luminance h263 */
uni_code= DCtab_lum[size][0];
uni_len = DCtab_lum[size][1];
- uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
+ uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
if (size > 0) {
uni_code<<=size; uni_code|=l;
/* chrominance h263 */
uni_code= DCtab_chrom[size][0];
uni_len = DCtab_chrom[size][1];
- uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
+ uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
if (size > 0) {
uni_code<<=size; uni_code|=l;
done = 1;
for(i=0;i<NB_RL_TABLES;i++) {
- init_rl(&rl_table[i], 1);
- init_vlc_rl(&rl_table[i], 1);
- }
+ init_rl(&rl_table[i], static_rl_table_store[i]);
+ }
+ INIT_VLC_RL(rl_table[0], 642);
+ INIT_VLC_RL(rl_table[1], 1104);
+ INIT_VLC_RL(rl_table[2], 554);
+ INIT_VLC_RL(rl_table[3], 940);
+ INIT_VLC_RL(rl_table[4], 962);
+ INIT_VLC_RL(rl_table[5], 554);
for(i=0;i<2;i++) {
mv = &mv_tables[i];
init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
&mvtab[0][0], 2, 1, 1);
for(i=0; i<4; i++){
- init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
+ init_vlc(&ff_mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
&wmv2_inter_table[i][0][1], 8, 4,
&wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
}
inter_MCBPC_bits, 1, 1,
inter_MCBPC_code, 1, 1, 1);
- init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
+ init_vlc(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
&table_inter_intra[0][1], 2, 1,
&table_inter_intra[0][0], 2, 1, 1);
}
s->decode_mb= msmpeg4v34_decode_mb;
break;
case 5:
- s->decode_mb= wmv2_decode_mb;
+ if (CONFIG_WMV2_DECODER)
+ s->decode_mb= ff_wmv2_decode_mb;
case 6:
//FIXME + TODO VC1 decode mb
break;
}
- s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
+ s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
return 0;
}
}
s->pict_type = get_bits(&s->gb, 2) + 1;
- if (s->pict_type != I_TYPE &&
- s->pict_type != P_TYPE){
+ if (s->pict_type != FF_I_TYPE &&
+ s->pict_type != FF_P_TYPE){
av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
return -1;
}
#if 0
{
static int had_i=0;
- if(s->pict_type == I_TYPE) had_i=1;
+ if(s->pict_type == FF_I_TYPE) had_i=1;
if(!had_i) return -1;
}
#endif
return -1;
}
- if (s->pict_type == I_TYPE) {
+ if (s->pict_type == FF_I_TYPE) {
code = get_bits(&s->gb, 5);
if(s->msmpeg4_version==1){
if(code==0 || code>s->mb_height){
tab[i] = val;
}
-#ifdef CONFIG_ENCODERS
+#if CONFIG_ENCODERS
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
{
int range, bit_size, sign, code, bits;
}
#endif
-/* this is identical to h263 except that its range is multiplied by 2 */
+/* This is identical to h263 except that its range is multiplied by 2. */
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
{
int code, val, sign, shift;
{
int cbp, code, i;
- if (s->pict_type == P_TYPE) {
+ if (s->pict_type == FF_P_TYPE) {
if (s->use_skip_mb_code) {
if (get_bits1(&s->gb)) {
/* skip mb */
} 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;
+ if(s->pict_type==FF_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)
+ if (ff_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;
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) {
+ if (s->pict_type == FF_P_TYPE) {
if (s->use_skip_mb_code) {
if (get_bits1(&s->gb)) {
/* skip mb */
}
}
- code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
+ code = get_vlc2(&s->gb, ff_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;
for(i=0;i<6;i++) {
int val = ((code >> (5 - i)) & 1);
if (i < 4) {
- int pred = coded_block_pred(s, i, &coded_val);
+ int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
val = val ^ pred;
*coded_val = val;
}
s->rl_chroma_table_index = s->rl_table_index;
}
h263_pred_motion(s, 0, 0, &mx, &my);
- if (msmpeg4_decode_motion(s, &mx, &my) < 0)
+ if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
return -1;
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
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);
+ s->h263_aic_dir= get_vlc2(&s->gb, ff_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->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)
+ if (ff_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 ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
int n, int coded, const uint8_t *scan_table)
{
int level, i, last, run, run_diff;
}
block[0] = level;
- run_diff = 0;
+ run_diff = s->msmpeg4_version >= 4;
i = 0;
if (!coded) {
goto not_coded;
//printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
#if 0 // waste of time / this will detect very few errors
{
- const int abs_level= ABS(level);
+ const int abs_level= FFABS(level);
const int run1= run - rl->max_run[last][abs_level] - run_diff;
if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
if(abs_level <= rl->max_level[last][run]){
i-= 192;
if(i&(~63)){
const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
- if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
+ if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
break;
}else{
return level;
}
-static int msmpeg4_decode_motion(MpegEncContext * s,
+int ff_msmpeg4_decode_motion(MpegEncContext * s,
int *mx_ptr, int *my_ptr)
{
MVTable *mv;
*my_ptr = my;
return 0;
}
-
-/* cleanest way to support it
- * there is too much shared between versions so that we cant have 1 file per version & 1 common
- * as allmost everything would be in the common file
- */
-#include "wmv2.c"