h263.c 162 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1 2
/*
 * H263/MPEG4 backend for ffmpeg encoder and decoder
Fabrice Bellard's avatar
Fabrice Bellard committed
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * H263+ support.
Fabrice Bellard's avatar
Fabrice Bellard committed
5 6
 * Copyright (c) 2001 Juan J. Sierralta P.
 *
Fabrice Bellard's avatar
Fabrice Bellard committed
7 8 9 10
 * This library 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.
Fabrice Bellard's avatar
Fabrice Bellard committed
11
 *
Fabrice Bellard's avatar
Fabrice Bellard committed
12
 * This library is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Fabrice Bellard's avatar
Fabrice Bellard committed
14 15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
16
 *
Fabrice Bellard's avatar
Fabrice Bellard committed
17 18 19
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20
 *
21 22 23
 * ac prediction encoding, b-frame support, error resilience, optimizations,
 * qpel decoding, gmc decoding, interlaced decoding, 
 * by Michael Niedermayer <michaelni@gmx.at>
Fabrice Bellard's avatar
Fabrice Bellard committed
24
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
25 26 27 28 29 30

/**
 * @file h263.c
 * @brief h263/mpeg4 codec
 *
 */
31 32
 
//#define DEBUG
Fabrice Bellard's avatar
Fabrice Bellard committed
33 34 35 36 37 38 39
#include "common.h"
#include "dsputil.h"
#include "avcodec.h"
#include "mpegvideo.h"
#include "h263data.h"
#include "mpeg4data.h"

40 41 42 43
//#undef NDEBUG
//#include <assert.h>

#if 1
Felix Bünemann's avatar
Felix Bünemann committed
44
#define PRINT_MB_TYPE(a) {}
45 46 47
#else
#define PRINT_MB_TYPE(a) printf(a)
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
48

49 50 51 52 53 54 55 56 57
#define INTRA_MCBPC_VLC_BITS 6
#define INTER_MCBPC_VLC_BITS 6
#define CBPY_VLC_BITS 6
#define MV_VLC_BITS 9
#define DC_VLC_BITS 9
#define SPRITE_TRAJ_VLC_BITS 6
#define MB_TYPE_B_VLC_BITS 4
#define TEX_VLC_BITS 9

58
#ifdef CONFIG_ENCODERS
Fabrice Bellard's avatar
Fabrice Bellard committed
59 60
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
			      int n);
61
static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
62
static void h263p_encode_umotion(MpegEncContext * s, int val);
63
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
64
			       int n, int dc, uint8_t *scan_table, 
65
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
66 67
#endif

Michael Niedermayer's avatar
Michael Niedermayer committed
68
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
69
static int h263p_decode_umotion(MpegEncContext * s, int pred);
Fabrice Bellard's avatar
Fabrice Bellard committed
70 71
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
                             int n, int coded);
72 73
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
Michael Niedermayer's avatar
Michael Niedermayer committed
74
                              int n, int coded, int intra);
75
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
Michael Niedermayer's avatar
Michael Niedermayer committed
76
static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
77
                              int dir);
78
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
79
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
80

81
extern uint32_t inverse[256];
Fabrice Bellard's avatar
Fabrice Bellard committed
82

83 84 85 86
static uint8_t uni_DCtab_lum_len[512];
static uint8_t uni_DCtab_chrom_len[512];
static uint16_t uni_DCtab_lum_bits[512];
static uint16_t uni_DCtab_chrom_bits[512];
87 88

#ifdef CONFIG_ENCODERS
89 90 91
static uint16_t (*mv_penalty)[MAX_MV*2+1]= NULL;
static uint8_t fcode_tab[MAX_MV*2+1];
static uint8_t umv_fcode_tab[MAX_MV*2+1];
92

Michael Niedermayer's avatar
Michael Niedermayer committed
93 94 95 96 97
static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
98
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
Michael Niedermayer's avatar
Michael Niedermayer committed
99
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
100 101 102 103 104 105 106 107 108 109

/* mpeg4
inter
max level: 24/6
max run: 53/63

intra
max level: 53/16
max run: 29/41
*/
110 111
#endif

112

Fabrice Bellard's avatar
Fabrice Bellard committed
113 114 115 116 117
int h263_get_picture_format(int width, int height)
{
    int format;

    if (width == 128 && height == 96)
118
        format = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
119
    else if (width == 176 && height == 144)
120
        format = 2;
Fabrice Bellard's avatar
Fabrice Bellard committed
121
    else if (width == 352 && height == 288)
122
        format = 3;
Fabrice Bellard's avatar
Fabrice Bellard committed
123
    else if (width == 704 && height == 576)
124
        format = 4;
Fabrice Bellard's avatar
Fabrice Bellard committed
125
    else if (width == 1408 && height == 1152)
126
        format = 5;
Fabrice Bellard's avatar
Fabrice Bellard committed
127 128 129 130 131
    else
        format = 7;
    return format;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
132 133 134 135 136
static void float_aspect_to_info(MpegEncContext * s, float aspect){
    int i;

    aspect*= s->height/(double)s->width;
//printf("%f\n", aspect);
Michael Niedermayer's avatar
Michael Niedermayer committed
137
    
Michael Niedermayer's avatar
Michael Niedermayer committed
138 139
    if(aspect==0) aspect= 1.0;

Michael Niedermayer's avatar
Michael Niedermayer committed
140
    ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
Michael Niedermayer's avatar
Michael Niedermayer committed
141 142 143 144 145 146 147 148

//printf("%d %d\n", s->aspected_width, s->aspected_height);
    for(i=1; i<6; i++){
        if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
            s->aspect_ratio_info=i;
            return;
        }
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
149
    
Michael Niedermayer's avatar
Michael Niedermayer committed
150
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
Michael Niedermayer's avatar
Michael Niedermayer committed
151 152
}

Fabrice Bellard's avatar
Fabrice Bellard committed
153 154
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
{
155
    int format;
Fabrice Bellard's avatar
Fabrice Bellard committed
156 157

    align_put_bits(&s->pb);
158 159

    /* Update the pointer to last GOB */
160
    s->ptr_lastgob = pbBufPtr(&s->pb);
161 162 163
    s->gob_number = 0;

    put_bits(&s->pb, 22, 0x20); /* PSC */
164
    put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * FRAME_RATE_BASE) / 
Fabrice Bellard's avatar
Fabrice Bellard committed
165 166 167 168 169 170 171
                         s->frame_rate) & 0xff);

    put_bits(&s->pb, 1, 1);	/* marker */
    put_bits(&s->pb, 1, 0);	/* h263 id */
    put_bits(&s->pb, 1, 0);	/* split screen off */
    put_bits(&s->pb, 1, 0);	/* camera  off */
    put_bits(&s->pb, 1, 0);	/* freeze picture release off */
172 173
    
    format = h263_get_picture_format(s->width, s->height);
Fabrice Bellard's avatar
Fabrice Bellard committed
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
    if (!s->h263_plus) {
        /* H.263v1 */
        put_bits(&s->pb, 3, format);
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
        of H.263v1 UMV implies to check the predicted MV after
        calculation of the current MB to see if we're on the limits */
        put_bits(&s->pb, 1, 0);	/* unrestricted motion vector: off */
        put_bits(&s->pb, 1, 0);	/* SAC: off */
        put_bits(&s->pb, 1, 0);	/* advanced prediction mode: off */
        put_bits(&s->pb, 1, 0);	/* not PB frame */
        put_bits(&s->pb, 5, s->qscale);
        put_bits(&s->pb, 1, 0);	/* Continuous Presence Multipoint mode: off */
    } else {
        /* H.263v2 */
        /* H.263 Plus PTYPE */
        put_bits(&s->pb, 3, 7);
        put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
192 193 194 195 196
        if (format == 7)
            put_bits(&s->pb,3,6); /* Custom Source Format */
        else
            put_bits(&s->pb, 3, format);
            
Fabrice Bellard's avatar
Fabrice Bellard committed
197
        put_bits(&s->pb,1,0); /* Custom PCF: off */
198 199
        s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
        put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
Fabrice Bellard's avatar
Fabrice Bellard committed
200 201
        put_bits(&s->pb,1,0); /* SAC: off */
        put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
202
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
Fabrice Bellard's avatar
Fabrice Bellard committed
203 204 205 206 207 208 209 210 211 212 213 214 215
        put_bits(&s->pb,1,0); /* Deblocking Filter: off */
        put_bits(&s->pb,1,0); /* Slice Structured: off */
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
        put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
        put_bits(&s->pb,1,0); /* Modified Quantization: off */
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
        put_bits(&s->pb,3,0); /* Reserved */
		
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
		
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
216
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
Fabrice Bellard's avatar
Fabrice Bellard committed
217 218 219 220 221 222
        put_bits(&s->pb,2,0); /* Reserved */
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
		
        /* This should be here if PLUSPTYPE */
        put_bits(&s->pb, 1, 0);	/* Continuous Presence Multipoint mode: off */
		
223 224
		if (format == 7) {
            /* Custom Picture Format (CPFMT) */
Michael Niedermayer's avatar
Michael Niedermayer committed
225
            float_aspect_to_info(s, s->avctx->aspect_ratio);
Michael Niedermayer's avatar
Michael Niedermayer committed
226 227

            put_bits(&s->pb,4,s->aspect_ratio_info);
228 229 230
            put_bits(&s->pb,9,(s->width >> 2) - 1);
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
            put_bits(&s->pb,9,(s->height >> 2));
231 232 233 234 235
	    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
	    {
		put_bits(&s->pb, 8, s->aspected_width);
		put_bits(&s->pb, 8, s->aspected_height);
	    }
236 237
        }
        
Fabrice Bellard's avatar
Fabrice Bellard committed
238
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
239
        if (s->umvplus)
Fabrice Bellard's avatar
Fabrice Bellard committed
240 241 242 243 244
            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
        put_bits(&s->pb, 5, s->qscale);
    }

    put_bits(&s->pb, 1, 0);	/* no PEI */
245 246 247 248 249 250 251 252

    if(s->h263_aic){
         s->y_dc_scale_table= 
         s->c_dc_scale_table= h263_aic_dc_scale_table;
    }else{
        s->y_dc_scale_table=
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
253 254
}

Michael Niedermayer's avatar
Michael Niedermayer committed
255 256 257
/**
 * Encodes a group of blocks header.
 */
258 259 260
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
{
           align_put_bits(&s->pb);
261 262 263
           flush_put_bits(&s->pb);
           /* Call the RTP callback to send the last GOB */
           if (s->rtp_callback) {
Michael Niedermayer's avatar
Michael Niedermayer committed
264
               int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
265 266
               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
           }
267
           put_bits(&s->pb, 17, 1); /* GBSC */
268
           s->gob_number = mb_line / s->gob_index;
269
           put_bits(&s->pb, 5, s->gob_number); /* GN */
270
           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
271
           put_bits(&s->pb, 5, s->qscale); /* GQUANT */
272
           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
Michael Niedermayer's avatar
Michael Niedermayer committed
273
    return 0;
274
}
275 276 277 278 279

static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
{
    int score0=0, score1=0;
    int i, n;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
280
    int8_t * const qscale_table= s->current_picture.qscale_table;
281 282

    for(n=0; n<6; n++){
283
        int16_t *ac_val, *ac_val1;
284

Michael Niedermayer's avatar
Michael Niedermayer committed
285
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
286 287
        ac_val1= ac_val;
        if(dir[n]){
288 289
            const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
            /* top prediction */
Michael Niedermayer's avatar
Michael Niedermayer committed
290
            ac_val-= s->block_wrap[n]*16;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
291
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
292 293
                /* same qscale */
                for(i=1; i<8; i++){
294
                    const int level= block[n][s->idct_permutation[i   ]];
295 296
                    score0+= ABS(level);
                    score1+= ABS(level - ac_val[i+8]);
297
                    ac_val1[i  ]=    block[n][s->idct_permutation[i<<3]];
298 299 300 301 302
                    ac_val1[i+8]= level;
                }
            }else{
                /* different qscale, we must rescale */
                for(i=1; i<8; i++){
303
                    const int level= block[n][s->idct_permutation[i   ]];
304
                    score0+= ABS(level);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
305
                    score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale));
306
                    ac_val1[i  ]=    block[n][s->idct_permutation[i<<3]];
307 308
                    ac_val1[i+8]= level;
                }
309 310
            }
        }else{
311 312
            const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
            /* left prediction */
313
            ac_val-= 16;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
314
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
315 316
                /* same qscale */
                for(i=1; i<8; i++){
317
                    const int level= block[n][s->idct_permutation[i<<3]];
318 319 320
                    score0+= ABS(level);
                    score1+= ABS(level - ac_val[i]);
                    ac_val1[i  ]= level;
321
                    ac_val1[i+8]=    block[n][s->idct_permutation[i   ]];
322 323 324 325
                }
            }else{
                /* different qscale, we must rescale */
                for(i=1; i<8; i++){
326
                    const int level= block[n][s->idct_permutation[i<<3]];
327
                    score0+= ABS(level);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
328
                    score1+= ABS(level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale));
329
                    ac_val1[i  ]= level;
330
                    ac_val1[i+8]=    block[n][s->idct_permutation[i   ]];
331
                }
332 333 334 335 336 337 338
            }
        }
    }

    return score0 > score1 ? 1 : 0;    
}

339 340 341
/**
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
 */
342
void ff_clean_h263_qscales(MpegEncContext *s){
343
    int i;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
344
    int8_t * const qscale_table= s->current_picture.qscale_table;
345 346
    
    for(i=1; i<s->mb_num; i++){
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
347 348
        if(qscale_table[i] - qscale_table[i-1] >2)
            qscale_table[i]= qscale_table[i-1]+2;
349 350
    }
    for(i=s->mb_num-2; i>=0; i--){
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
351 352
        if(qscale_table[i] - qscale_table[i+1] >2)
            qscale_table[i]= qscale_table[i+1]+2;
353
    }
354 355
}

356 357 358
/**
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
 */
359 360
void ff_clean_mpeg4_qscales(MpegEncContext *s){
    int i;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
361 362
    int8_t * const qscale_table= s->current_picture.qscale_table;

363
    ff_clean_h263_qscales(s);
364 365
    
    for(i=1; i<s->mb_num; i++){
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
366
        if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_INTER4V)){
367 368 369 370 371 372 373 374 375 376 377
            s->mb_type[i]&= ~MB_TYPE_INTER4V;
            s->mb_type[i]|= MB_TYPE_INTER;
        }
    }

    if(s->pict_type== B_TYPE){
        int odd=0;
        /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
           for the actual adaptive quantization */
        
        for(i=0; i<s->mb_num; i++){
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
378
            odd += qscale_table[i]&1;
379 380 381 382 383 384
        }
        
        if(2*odd > s->mb_num) odd=1;
        else                  odd=0;
        
        for(i=0; i<s->mb_num; i++){
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
385 386 387 388
            if((qscale_table[i]&1) != odd)
                qscale_table[i]++;
            if(qscale_table[i] > 31)
                qscale_table[i]= 31;
389 390 391
        }            
    
        for(i=1; i<s->mb_num; i++){
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
392
            if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_DIRECT)){
393 394 395 396 397 398 399
                s->mb_type[i]&= ~MB_TYPE_DIRECT;
                s->mb_type[i]|= MB_TYPE_BIDIR;
            }
        }
    }
}

Michael Niedermayer's avatar
Michael Niedermayer committed
400 401 402 403 404 405
void ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
    const int mb_index= s->mb_x + s->mb_y*s->mb_width;
    int xy= s->block_index[0];
    uint16_t time_pp= s->pp_time;
    uint16_t time_pb= s->pb_time;
    int i;
406
    
Michael Niedermayer's avatar
Michael Niedermayer committed
407 408 409
    //FIXME avoid divides
    switch(s->co_located_type_table[mb_index]){
    case 0:
410 411 412
        s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
        s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
        s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
Michael Niedermayer's avatar
Michael Niedermayer committed
413
                            : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
414
        s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
Michael Niedermayer's avatar
Michael Niedermayer committed
415
                            : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
416 417 418 419
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
            s->mv_type= MV_TYPE_16X16;
        else
            s->mv_type= MV_TYPE_8X8;
Michael Niedermayer's avatar
Michael Niedermayer committed
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
        break;
    case CO_LOCATED_TYPE_4MV:
        s->mv_type = MV_TYPE_8X8;
        for(i=0; i<4; i++){
            xy= s->block_index[i];
            s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
            s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1] 
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
        }
        break;
    case CO_LOCATED_TYPE_FIELDMV:
        s->mv_type = MV_TYPE_FIELD;
        for(i=0; i<2; i++){
            if(s->top_field_first){
                time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
                time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
            }else{
                time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
                time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
            }
            s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
            s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
                                : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] 
                                : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
        }
        break;
    }
}

454
#ifdef CONFIG_ENCODERS
455 456 457 458
void mpeg4_encode_mb(MpegEncContext * s,
		    DCTELEM block[6][64],
		    int motion_x, int motion_y)
{
459
    int cbpc, cbpy, pred_x, pred_y;
460
    int bits;
461 462 463 464
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
465
    const int dquant_code[5]= {1,0,9,2,3};
466
    
467 468 469
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
    if (!s->mb_intra) {
        /* compute cbp */
470
        int i, cbp = 0;
471
        for (i = 0; i < 6; i++) {
472 473
            if (s->block_last_index[i] >= 0)
                cbp |= 1 << (5 - i);
474
        }
475 476 477 478 479 480 481 482 483 484 485

        if(s->pict_type==B_TYPE){
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
            int mb_type=  mb_type_table[s->mv_dir];
            
            if(s->mb_x==0){
                s->last_mv[0][0][0]= 
                s->last_mv[0][0][1]= 
                s->last_mv[1][0][0]= 
                s->last_mv[1][0][1]= 0;
            }
486 487 488 489
            
            assert(s->dquant>=-2 && s->dquant<=2);
            assert((s->dquant&1)==0);
            assert(mb_type>=0);
490 491

            /* nothing to do if this MB was skiped in the next P Frame */
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
492
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x]){ //FIXME avoid DCT & ...
493 494 495 496 497
                s->skip_count++;
                s->mv[0][0][0]= 
                s->mv[0][0][1]= 
                s->mv[1][0][0]= 
                s->mv[1][0][1]= 0;
498
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
499
                s->qscale -= s->dquant;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
500 501
//                s->mb_skiped=1;

502 503
                return;
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
504
            
505 506
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
                /* direct MB with MV={0,0} */
507 508
                assert(s->dquant==0);
                
509
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
510 511 512 513 514

                if(interleaved_stats){
                    s->misc_bits++;
                    s->last_bits++;
                }
515 516 517
                s->skip_count++;
                return;
            }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
518
            
519 520 521 522 523
            put_bits(&s->pb, 1, 0);	/* mb coded modb1=0 */
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
            if(cbp) put_bits(&s->pb, 6, cbp);
            
524 525 526 527 528 529 530
            if(cbp && mb_type){
                if(s->dquant)
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
                else
                    put_bits(&s->pb, 1, 0);
            }else
                s->qscale -= s->dquant;
531 532 533 534 535 536 537
            
            if(!s->progressive_sequence){
                if(cbp)
                    put_bits(&s->pb, 1, s->interlaced_dct);
                if(mb_type) // not diect mode
                    put_bits(&s->pb, 1, 0); // no interlaced ME yet
            }
538

539 540 541 542 543
            if(interleaved_stats){
                bits= get_bit_count(&s->pb);
                s->misc_bits+= bits - s->last_bits;
                s->last_bits=bits;
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
544

545 546 547 548 549
            switch(mb_type)
            {
            case 0: /* direct */
                h263_encode_motion(s, motion_x, 1);
                h263_encode_motion(s, motion_y, 1);                
550 551
                s->b_count++;
                s->f_count++;
552 553 554 555 556 557 558 559 560 561
                break;
            case 1: /* bidir */
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
                s->last_mv[0][0][0]= s->mv[0][0][0];
                s->last_mv[0][0][1]= s->mv[0][0][1];
                s->last_mv[1][0][0]= s->mv[1][0][0];
                s->last_mv[1][0][1]= s->mv[1][0][1];
562 563
                s->b_count++;
                s->f_count++;
564 565 566 567 568 569
                break;
            case 2: /* backward */
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
                s->last_mv[1][0][0]= motion_x;
                s->last_mv[1][0][1]= motion_y;
570
                s->b_count++;
571 572 573 574 575 576
                break;
            case 3: /* forward */
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
                s->last_mv[0][0][0]= motion_x;
                s->last_mv[0][0][1]= motion_y;
577
                s->f_count++;
578
                break;
579 580
            default:
                printf("unknown mb type\n");
581 582
                return;
            }
583 584 585 586 587 588

            if(interleaved_stats){
                bits= get_bit_count(&s->pb);
                s->mv_bits+= bits - s->last_bits;
                s->last_bits=bits;
            }
589

590 591
            /* encode each block */
            for (i = 0; i < 6; i++) {
592
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
593 594 595 596 597 598
            }

            if(interleaved_stats){
                bits= get_bit_count(&s->pb);
                s->p_tex_bits+= bits - s->last_bits;
                s->last_bits=bits;
599 600
            }
        }else{ /* s->pict_type==B_TYPE */
601
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
Michael Niedermayer's avatar
Michael Niedermayer committed
602 603 604 605
                /* check if the B frames can skip it too, as we must skip it if we skip here 
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
                if(s->max_b_frames>0){
                    int i;
606 607 608 609 610 611 612 613 614
                    int x,y, offset;
                    uint8_t *p_pic;

                    x= s->mb_x*16;
                    y= s->mb_y*16;
                    if(x+16 > s->width)  x= s->width-16;
                    if(y+16 > s->height) y= s->height-16;

                    offset= x + y*s->linesize;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
615
                    p_pic= s->new_picture.data[0] + offset;
616
                    
Michael Niedermayer's avatar
Michael Niedermayer committed
617 618
                    s->mb_skiped=1;
                    for(i=0; i<s->max_b_frames; i++){
Michael Niedermayer's avatar
Michael Niedermayer committed
619 620
                        uint8_t *b_pic;
                        int diff;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
621
                        Picture *pic= s->reordered_input_picture[i+1];
Michael Niedermayer's avatar
Michael Niedermayer committed
622

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
623
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
Michael Niedermayer's avatar
Michael Niedermayer committed
624

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
625
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
626
			diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
627
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
Michael Niedermayer's avatar
Michael Niedermayer committed
628 629 630 631 632 633 634 635 636 637
                            s->mb_skiped=0;
                            break;
                        }
                    }
                }else
                    s->mb_skiped=1; 

                if(s->mb_skiped==1){
                    /* skip macroblock */
                    put_bits(&s->pb, 1, 1);
638 639 640 641 642

                    if(interleaved_stats){
                        s->misc_bits++;
                        s->last_bits++;
                    }
Michael Niedermayer's avatar
Michael Niedermayer committed
643 644 645
                    s->skip_count++;
                    return;
                }
646
            }
647

648 649 650
            put_bits(&s->pb, 1, 0);	/* mb coded */
            if(s->mv_type==MV_TYPE_16X16){
                cbpc = cbp & 3;
651
                if(s->dquant) cbpc+= 8;
652 653 654
                put_bits(&s->pb,
                        inter_MCBPC_bits[cbpc],
                        inter_MCBPC_code[cbpc]);
655

656 657
                cbpy = cbp >> 2;
                cbpy ^= 0xf;
658
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
659 660
                if(s->dquant)
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
661 662 663 664 665 666

                if(!s->progressive_sequence){
                    if(cbp)
                        put_bits(pb2, 1, s->interlaced_dct);
                    put_bits(pb2, 1, 0); // no interlaced ME yet
                }
667
                    
668 669 670 671 672
                if(interleaved_stats){
                    bits= get_bit_count(&s->pb);
                    s->misc_bits+= bits - s->last_bits;
                    s->last_bits=bits;
                }
673

674 675 676 677 678 679 680 681 682 683 684 685
                /* motion vectors: 16x16 mode */
                h263_pred_motion(s, 0, &pred_x, &pred_y);
            
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
            }else{
                cbpc = (cbp & 3)+16;
                put_bits(&s->pb,
                        inter_MCBPC_bits[cbpc],
                        inter_MCBPC_code[cbpc]);
                cbpy = cbp >> 2;
                cbpy ^= 0xf;
686
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
687

688 689 690 691 692
                if(!s->progressive_sequence){
                    if(cbp)
                        put_bits(pb2, 1, s->interlaced_dct);
                }
    
693 694 695 696 697
                if(interleaved_stats){
                    bits= get_bit_count(&s->pb);
                    s->misc_bits+= bits - s->last_bits;
                    s->last_bits=bits;
                }
698 699 700 701 702 703 704 705

                for(i=0; i<4; i++){
                    /* motion vectors: 8x8 mode*/
                    h263_pred_motion(s, i, &pred_x, &pred_y);

                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
                }
Michael Niedermayer's avatar
Michael Niedermayer committed
706
            }
707 708 709 710 711 712

            if(interleaved_stats){ 
                bits= get_bit_count(&s->pb);
                s->mv_bits+= bits - s->last_bits;
                s->last_bits=bits;
            }
713

714 715
            /* encode each block */
            for (i = 0; i < 6; i++) {
716
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
717 718 719 720 721 722
            }

            if(interleaved_stats){
                bits= get_bit_count(&s->pb);
                s->p_tex_bits+= bits - s->last_bits;
                s->last_bits=bits;
723
            }
724
            s->f_count++;
725 726
        }
    } else {
727
        int cbp;
728 729 730
        int dc_diff[6];   //dc values with the dc prediction subtracted 
        int dir[6];  //prediction direction
        int zigzag_last_index[6];
731
	uint8_t *scan_table[6];
732
        int i;
733 734 735

        for(i=0; i<6; i++){
            const int level= block[i][0];
736
            uint16_t *dc_ptr;
737

738
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
739 740 741 742 743 744 745 746 747 748 749
            if (i < 4) {
                *dc_ptr = level * s->y_dc_scale;
            } else {
                *dc_ptr = level * s->c_dc_scale;
            }
        }

        s->ac_pred= decide_ac_pred(s, block, dir);

        if(s->ac_pred){
            for(i=0; i<6; i++){
750
                uint8_t *st;
751 752 753
                int last_index;

                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
754 755
                if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
                else           st = s->intra_h_scantable.permutated; /* top */
756 757 758 759 760 761 762 763 764

                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
                    if(block[i][st[last_index]]) break;
                zigzag_last_index[i]= s->block_last_index[i];
                s->block_last_index[i]= last_index;
                scan_table[i]= st;
            }
        }else{
            for(i=0; i<6; i++)
765
                scan_table[i]= s->intra_scantable.permutated;
766 767 768 769 770 771 772 773 774 775 776
        }

        /* compute cbp */
        cbp = 0;
        for (i = 0; i < 6; i++) {
            if (s->block_last_index[i] >= 1)
                cbp |= 1 << (5 - i);
        }

        cbpc = cbp & 3;
        if (s->pict_type == I_TYPE) {
777
            if(s->dquant) cbpc+=4;
778 779 780 781
            put_bits(&s->pb,
                intra_MCBPC_bits[cbpc],
                intra_MCBPC_code[cbpc]);
        } else {
782
            if(s->dquant) cbpc+=8;
783 784 785 786 787
            put_bits(&s->pb, 1, 0);	/* mb coded */
            put_bits(&s->pb,
                inter_MCBPC_bits[cbpc + 4],
                inter_MCBPC_code[cbpc + 4]);
        }
788
        put_bits(pb2, 1, s->ac_pred);
789
        cbpy = cbp >> 2;
790
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
791 792
        if(s->dquant)
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
793

794 795 796 797
        if(!s->progressive_sequence){
            put_bits(dc_pb, 1, s->interlaced_dct);
        }

798 799 800 801 802
        if(interleaved_stats){
            bits= get_bit_count(&s->pb);
            s->misc_bits+= bits - s->last_bits;
            s->last_bits=bits;
        }
803

804 805
        /* encode each block */
        for (i = 0; i < 6; i++) {
806
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
807 808
        }

809 810 811 812 813
        if(interleaved_stats){
            bits= get_bit_count(&s->pb);
            s->i_tex_bits+= bits - s->last_bits;
            s->last_bits=bits;
        }
814 815
        s->i_count++;

816 817 818 819
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
        if(s->ac_pred){
            for(i=0; i<6; i++){
                int j;    
820
                int16_t *ac_val;
821

Michael Niedermayer's avatar
Michael Niedermayer committed
822
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
823 824 825

                if(dir[i]){
                    for(j=1; j<8; j++) 
826
                        block[i][s->idct_permutation[j   ]]= ac_val[j+8];
827 828
                }else{
                    for(j=1; j<8; j++) 
829
                        block[i][s->idct_permutation[j<<3]]= ac_val[j  ];
830 831 832 833 834 835 836
                }
                s->block_last_index[i]= zigzag_last_index[i];
            }
        }
    }
}

Fabrice Bellard's avatar
Fabrice Bellard committed
837 838 839 840 841
void h263_encode_mb(MpegEncContext * s,
		    DCTELEM block[6][64],
		    int motion_x, int motion_y)
{
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
842 843 844
    int16_t pred_dc;
    int16_t rec_intradc[6];
    uint16_t *dc_ptr[6];
845
    const int dquant_code[5]= {1,0,9,2,3};
846 847
           
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
848
    if (!s->mb_intra) {
849
        /* compute cbp */
850 851 852 853 854
        cbp = 0;
        for (i = 0; i < 6; i++) {
            if (s->block_last_index[i] >= 0)
                cbp |= 1 << (5 - i);
        }
855
        if ((cbp | motion_x | motion_y | s->dquant) == 0) {
856 857 858 859
            /* skip macroblock */
            put_bits(&s->pb, 1, 1);
            return;
        }
860
        put_bits(&s->pb, 1, 0);	/* mb coded */
861
        cbpc = cbp & 3;
862
        if(s->dquant) cbpc+= 8;
863
        put_bits(&s->pb,
864 865
		    inter_MCBPC_bits[cbpc],
		    inter_MCBPC_code[cbpc]);
866 867 868
        cbpy = cbp >> 2;
        cbpy ^= 0xf;
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
869 870
        if(s->dquant)
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
871

872
        /* motion vectors: 16x16 mode only now */
873
        h263_pred_motion(s, 0, &pred_x, &pred_y);
874
      
875 876 877 878 879 880 881 882
        if (!s->umvplus) {  
            h263_encode_motion(s, motion_x - pred_x, s->f_code);
            h263_encode_motion(s, motion_y - pred_y, s->f_code);
        }
        else {
            h263p_encode_umotion(s, motion_x - pred_x);
            h263p_encode_umotion(s, motion_y - pred_y);
            if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
883
                /* To prevent Start Code emulation */
884 885
                put_bits(&s->pb,1,1);
        }
886 887 888 889 890 891 892
    } else {
        int li = s->h263_aic ? 0 : 1;
        
        cbp = 0;
        for(i=0; i<6; i++) {
            /* Predict DC */
            if (s->h263_aic && s->mb_intra) {
893
                int16_t level = block[i][0];
894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
            
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
                level -= pred_dc;
                /* Quant */
                if (level < 0)
                    level = (level + (s->qscale >> 1))/(s->y_dc_scale);
                else
                    level = (level - (s->qscale >> 1))/(s->y_dc_scale);
                    
                /* AIC can change CBP */
                if (level == 0 && s->block_last_index[i] == 0)
                    s->block_last_index[i] = -1;
                else if (level < -127)
                    level = -127;
                else if (level > 127)
                    level = 127;
                
                block[i][0] = level;
                /* Reconstruction */ 
                rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
                /* Oddify */
                rec_intradc[i] |= 1;
                //if ((rec_intradc[i] % 2) == 0)
                //    rec_intradc[i]++;
                /* Clipping */
                if (rec_intradc[i] < 0)
                    rec_intradc[i] = 0;
                else if (rec_intradc[i] > 2047)
                    rec_intradc[i] = 2047;
                                
                /* Update AC/DC tables */
                *dc_ptr[i] = rec_intradc[i];
            }
            /* compute cbp */
            if (s->block_last_index[i] >= li)
                cbp |= 1 << (5 - i);
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
931

932 933
        cbpc = cbp & 3;
        if (s->pict_type == I_TYPE) {
934
            if(s->dquant) cbpc+=4;
935 936 937 938
            put_bits(&s->pb,
                intra_MCBPC_bits[cbpc],
                intra_MCBPC_code[cbpc]);
        } else {
939
            if(s->dquant) cbpc+=8;
940 941 942 943 944 945 946 947 948 949 950
            put_bits(&s->pb, 1, 0);	/* mb coded */
            put_bits(&s->pb,
                inter_MCBPC_bits[cbpc + 4],
                inter_MCBPC_code[cbpc + 4]);
        }
        if (s->h263_aic) {
            /* XXX: currently, we do not try to use ac prediction */
            put_bits(&s->pb, 1, 0);	/* no AC prediction */
        }
        cbpy = cbp >> 2;
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
951 952
        if(s->dquant)
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
Fabrice Bellard's avatar
Fabrice Bellard committed
953 954
    }

955 956
    for(i=0; i<6; i++) {
        /* encode each block */
957
        h263_encode_block(s, block[i], i);
958 959 960 961 962 963 964 965
    
        /* Update INTRADC for decoding */
        if (s->h263_aic && s->mb_intra) {
            block[i][0] = rec_intradc[i];
            
        }
    }
}
966
#endif
967

968
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
969 970
{
    int x, y, wrap, a, c, pred_dc, scale;
971
    int16_t *dc_val, *ac_val;
972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987

    /* find prediction */
    if (n < 4) {
        x = 2 * s->mb_x + 1 + (n & 1);
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
        wrap = s->mb_width * 2 + 2;
        dc_val = s->dc_val[0];
        ac_val = s->ac_val[0][0];
        scale = s->y_dc_scale;
    } else {
        x = s->mb_x + 1;
        y = s->mb_y + 1;
        wrap = s->mb_width + 2;
        dc_val = s->dc_val[n - 4 + 1];
        ac_val = s->ac_val[n - 4 + 1][0];
        scale = s->c_dc_scale;
Fabrice Bellard's avatar
Fabrice Bellard committed
988
    }
989 990 991 992 993 994 995
    /* B C
     * A X 
     */
    a = dc_val[(x - 1) + (y) * wrap];
    c = dc_val[(x) + (y - 1) * wrap];
    
    /* No prediction outside GOB boundary */
996
    if (s->first_slice_line && ((n < 2) || (n > 3)))
997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
        c = 1024;
    pred_dc = 1024;
    /* just DC prediction */
    if (a != 1024 && c != 1024)
        pred_dc = (a + c) >> 1;
    else if (a != 1024)
        pred_dc = a;
    else
        pred_dc = c;
    
    /* we assume pred is positive */
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
    *dc_val_ptr = &dc_val[x + y * wrap];
    return pred_dc;
Fabrice Bellard's avatar
Fabrice Bellard committed
1011 1012
}

1013

1014
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1015
{
1016
    int x, y, wrap, a, c, pred_dc, scale, i;
1017
    int16_t *dc_val, *ac_val, *ac_val1;
1018 1019 1020 1021 1022 1023 1024

    /* find prediction */
    if (n < 4) {
        x = 2 * s->mb_x + 1 + (n & 1);
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
        wrap = s->mb_width * 2 + 2;
        dc_val = s->dc_val[0];
1025
        ac_val = s->ac_val[0][0];
1026 1027 1028 1029 1030 1031
        scale = s->y_dc_scale;
    } else {
        x = s->mb_x + 1;
        y = s->mb_y + 1;
        wrap = s->mb_width + 2;
        dc_val = s->dc_val[n - 4 + 1];
1032
        ac_val = s->ac_val[n - 4 + 1][0];
1033 1034
        scale = s->c_dc_scale;
    }
1035 1036 1037 1038
    
    ac_val += ((y) * wrap + (x)) * 16;
    ac_val1 = ac_val;
    
1039 1040 1041 1042 1043 1044
    /* B C
     * A X 
     */
    a = dc_val[(x - 1) + (y) * wrap];
    c = dc_val[(x) + (y - 1) * wrap];
    
1045
    /* No prediction outside GOB boundary */
1046
    if (s->first_slice_line && ((n < 2) || (n > 3)))