h263.c 154 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
 */
25
26
 
//#define DEBUG
Fabrice Bellard's avatar
Fabrice Bellard committed
27
28
29
30
31
32
33
#include "common.h"
#include "dsputil.h"
#include "avcodec.h"
#include "mpegvideo.h"
#include "h263data.h"
#include "mpeg4data.h"

34
35
36
//#undef NDEBUG
//#include <assert.h>

Michael Niedermayer's avatar
Michael Niedermayer committed
37
38
39
//rounded divison & shift
#define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))

40
#if 1
Felix Bünemann's avatar
Felix Bünemann committed
41
#define PRINT_MB_TYPE(a) {}
42
43
44
#else
#define PRINT_MB_TYPE(a) printf(a)
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
45

46
47
48
49
50
51
52
53
54
#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

Fabrice Bellard's avatar
Fabrice Bellard committed
55
56
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
			      int n);
57
static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
58
static void h263p_encode_umotion(MpegEncContext * s, int val);
59
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
60
61
			       int n, int dc, UINT8 *scan_table, 
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
Michael Niedermayer's avatar
Michael Niedermayer committed
62
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
63
static int h263p_decode_umotion(MpegEncContext * s, int pred);
Fabrice Bellard's avatar
Fabrice Bellard committed
64
65
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
                             int n, int coded);
66
67
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
68
                              int n, int coded, int intra);
69
static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
70
71
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
                              int dir);
72
73
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);

74
extern UINT32 inverse[256];
Fabrice Bellard's avatar
Fabrice Bellard committed
75

76
static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
77
static UINT8 fcode_tab[MAX_MV*2+1];
78
static UINT8 umv_fcode_tab[MAX_MV*2+1];
79

80
81
static UINT16 uni_DCtab_lum  [512][2];
static UINT16 uni_DCtab_chrom[512][2];
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
static UINT32 uni_mpeg4_intra_rl_bits[64*64*2*2];
static UINT8  uni_mpeg4_intra_rl_len [64*64*2*2];
static UINT32 uni_mpeg4_inter_rl_bits[64*64*2*2];
static UINT8  uni_mpeg4_inter_rl_len [64*64*2*2];
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)

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

intra
max level: 53/16
max run: 29/41
*/
98

Fabrice Bellard's avatar
Fabrice Bellard committed
99
100
101
102
103
int h263_get_picture_format(int width, int height)
{
    int format;

    if (width == 128 && height == 96)
104
        format = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
105
    else if (width == 176 && height == 144)
106
        format = 2;
Fabrice Bellard's avatar
Fabrice Bellard committed
107
    else if (width == 352 && height == 288)
108
        format = 3;
Fabrice Bellard's avatar
Fabrice Bellard committed
109
    else if (width == 704 && height == 576)
110
        format = 4;
Fabrice Bellard's avatar
Fabrice Bellard committed
111
    else if (width == 1408 && height == 1152)
112
        format = 5;
Fabrice Bellard's avatar
Fabrice Bellard committed
113
114
115
116
117
118
119
    else
        format = 7;
    return format;
}

void h263_encode_picture_header(MpegEncContext * s, int picture_number)
{
120
    int format;
Fabrice Bellard's avatar
Fabrice Bellard committed
121
122

    align_put_bits(&s->pb);
123
124

    /* Update the pointer to last GOB */
125
    s->ptr_lastgob = pbBufPtr(&s->pb);
126
127
128
    s->gob_number = 0;

    put_bits(&s->pb, 22, 0x20); /* PSC */
129
    put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 
Fabrice Bellard's avatar
Fabrice Bellard committed
130
131
132
133
134
135
136
                         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 */
137
138
    
    format = h263_get_picture_format(s->width, s->height);
Fabrice Bellard's avatar
Fabrice Bellard committed
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
    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 */
157
158
159
160
161
        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
162
        put_bits(&s->pb,1,0); /* Custom PCF: off */
163
164
        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
165
166
        put_bits(&s->pb,1,0); /* SAC: off */
        put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
167
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
Fabrice Bellard's avatar
Fabrice Bellard committed
168
169
170
171
172
173
174
175
176
177
178
179
180
        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 */
181
182
183
184
185
        if (s->pict_type == I_TYPE)
            s->no_rounding = 0;
        else
            s->no_rounding ^= 1;
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
Fabrice Bellard's avatar
Fabrice Bellard committed
186
187
188
189
190
191
        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 */
		
192
193
		if (format == 7) {
            /* Custom Picture Format (CPFMT) */
Fabrice Bellard's avatar
Fabrice Bellard committed
194
		
195
	    if (s->aspect_ratio_info)
196
        	put_bits(&s->pb,4,s->aspect_ratio_info);
197
	    else
198
        	put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
199
200
201
            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));
202
203
204
205
206
	    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
	    {
		put_bits(&s->pb, 8, s->aspected_width);
		put_bits(&s->pb, 8, s->aspected_height);
	    }
207
208
        }
        
Fabrice Bellard's avatar
Fabrice Bellard committed
209
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
210
        if (s->umvplus)
Fabrice Bellard's avatar
Fabrice Bellard committed
211
212
213
214
215
            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 */
216
217
218
219
220
221
222
223

    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
224
225
}

226
227
228
229
230
231
232
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
{
    int pdif=0;
    
    /* Check to see if we need to put a new GBSC */
    /* for RTP packetization                    */
    if (s->rtp_mode) {
233
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
234
235
236
        if (pdif >= s->rtp_payload_size) {
            /* Bad luck, packet must be cut before */
            align_put_bits(&s->pb);
237
238
239
            flush_put_bits(&s->pb);
            /* Call the RTP callback to send the last GOB */
            if (s->rtp_callback) {
240
                pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
241
242
                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
            }
243
            s->ptr_lastgob = pbBufPtr(&s->pb);
244
            put_bits(&s->pb, 17, 1); /* GBSC */
245
            s->gob_number = mb_line / s->gob_index;
246
            put_bits(&s->pb, 5, s->gob_number); /* GN */
247
            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
248
            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
249
            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
250
251
252
253
            return pdif;
       } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
           /* Cut the packet before we can't */
           align_put_bits(&s->pb);
254
255
256
           flush_put_bits(&s->pb);
           /* Call the RTP callback to send the last GOB */
           if (s->rtp_callback) {
257
               pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
258
259
               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
           }
260
           s->ptr_lastgob = pbBufPtr(&s->pb);
261
           put_bits(&s->pb, 17, 1); /* GBSC */
262
           s->gob_number = mb_line / s->gob_index;
263
           put_bits(&s->pb, 5, s->gob_number); /* GN */
264
           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
265
           put_bits(&s->pb, 5, s->qscale); /* GQUANT */
266
           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
267
268
269
270
271
           return pdif;
       }
   }
   return 0;
}
272
273
274
275
276
277
278
279
280

static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
{
    int score0=0, score1=0;
    int i, n;

    for(n=0; n<6; n++){
        INT16 *ac_val, *ac_val1;

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

    return score0 > score1 ? 1 : 0;    
}

335
void ff_clean_h263_qscales(MpegEncContext *s){
336
337
338
339
340
341
342
343
344
345
    int i;
    
    for(i=1; i<s->mb_num; i++){
        if(s->qscale_table[i] - s->qscale_table[i-1] >2)
            s->qscale_table[i]= s->qscale_table[i-1]+2;
    }
    for(i=s->mb_num-2; i>=0; i--){
        if(s->qscale_table[i] - s->qscale_table[i+1] >2)
            s->qscale_table[i]= s->qscale_table[i+1]+2;
    }
346
347
348
349
350
351
}

void ff_clean_mpeg4_qscales(MpegEncContext *s){
    int i;
    
    ff_clean_h263_qscales(s);
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
    
    for(i=1; i<s->mb_num; i++){
        if(s->qscale_table[i] != s->qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_INTER4V)){
            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++){
            odd += s->qscale_table[i]&1;
        }
        
        if(2*odd > s->mb_num) odd=1;
        else                  odd=0;
        
        for(i=0; i<s->mb_num; i++){
            if((s->qscale_table[i]&1) != odd)
                s->qscale_table[i]++;
            if(s->qscale_table[i] > 31)
                s->qscale_table[i]= 31;
        }            
    
        for(i=1; i<s->mb_num; i++){
            if(s->qscale_table[i] != s->qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_DIRECT)){
                s->mb_type[i]&= ~MB_TYPE_DIRECT;
                s->mb_type[i]|= MB_TYPE_BIDIR;
            }
        }
    }
}

388
389
390
391
void mpeg4_encode_mb(MpegEncContext * s,
		    DCTELEM block[6][64],
		    int motion_x, int motion_y)
{
392
    int cbpc, cbpy, i, pred_x, pred_y;
393
    int bits;
394
395
396
397
    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;
398
    const int dquant_code[5]= {1,0,9,2,3};
399
    
400
401
402
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
    if (!s->mb_intra) {
        /* compute cbp */
403
        int cbp = 0;
404
        for (i = 0; i < 6; i++) {
405
406
            if (s->block_last_index[i] >= 0)
                cbp |= 1 << (5 - i);
407
        }
408
409
410
411
412
413
414
415
416
417
418

        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;
            }
419
420
421
422
            
            assert(s->dquant>=-2 && s->dquant<=2);
            assert((s->dquant&1)==0);
            assert(mb_type>=0);
423
424

            /* nothing to do if this MB was skiped in the next P Frame */
425
            if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){ //FIXME avoid DCT & ...
426
427
428
429
430
                s->skip_count++;
                s->mv[0][0][0]= 
                s->mv[0][0][1]= 
                s->mv[1][0][0]= 
                s->mv[1][0][1]= 0;
431
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
432
                s->qscale -= s->dquant;
433
434
435
436
437
                return;
            }

            if ((cbp | motion_x | motion_y | mb_type) ==0) {
                /* direct MB with MV={0,0} */
438
439
                assert(s->dquant==0);
                
440
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
441
442
443
444
445

                if(interleaved_stats){
                    s->misc_bits++;
                    s->last_bits++;
                }
446
447
448
449
450
451
452
453
                s->skip_count++;
                return;
            }
            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);
            
454
455
456
457
458
459
460
            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;
461
462
463
464
465
466
467
            
            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
            }
468

469
470
471
472
473
            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
474

475
476
477
478
479
            switch(mb_type)
            {
            case 0: /* direct */
                h263_encode_motion(s, motion_x, 1);
                h263_encode_motion(s, motion_y, 1);                
480
481
                s->b_count++;
                s->f_count++;
482
483
484
485
486
487
488
489
490
491
                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];
492
493
                s->b_count++;
                s->f_count++;
494
495
496
497
498
499
                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;
500
                s->b_count++;
501
502
503
504
505
506
                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;
507
                s->f_count++;
508
                break;
509
510
            default:
                printf("unknown mb type\n");
511
512
                return;
            }
513
514
515
516
517
518

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

520
521
            /* encode each block */
            for (i = 0; i < 6; i++) {
522
523
524
525
526
527
528
                mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, &s->pb);
            }

            if(interleaved_stats){
                bits= get_bit_count(&s->pb);
                s->p_tex_bits+= bits - s->last_bits;
                s->last_bits=bits;
529
530
            }
        }else{ /* s->pict_type==B_TYPE */
531
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
Michael Niedermayer's avatar
Michael Niedermayer committed
532
533
534
535
                /* 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;
536
537
538
539
540
541
542
543
544
545
546
                    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;
                    p_pic= s->new_picture[0] + offset;
                    
Michael Niedermayer's avatar
Michael Niedermayer committed
547
548
                    s->mb_skiped=1;
                    for(i=0; i<s->max_b_frames; i++){
Michael Niedermayer's avatar
Michael Niedermayer committed
549
550
551
552
553
554
555
                        uint8_t *b_pic;
                        int diff;

                        if(s->coded_order[i+1].pict_type!=B_TYPE) break;

                        b_pic= s->coded_order[i+1].picture[0] + offset;
                        diff= pix_abs16x16(p_pic, b_pic, s->linesize);
556
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
Michael Niedermayer's avatar
Michael Niedermayer committed
557
558
559
560
561
562
563
564
565
566
                            s->mb_skiped=0;
                            break;
                        }
                    }
                }else
                    s->mb_skiped=1; 

                if(s->mb_skiped==1){
                    /* skip macroblock */
                    put_bits(&s->pb, 1, 1);
567
568
569
570
571

                    if(interleaved_stats){
                        s->misc_bits++;
                        s->last_bits++;
                    }
Michael Niedermayer's avatar
Michael Niedermayer committed
572
573
574
                    s->skip_count++;
                    return;
                }
575
            }
576

577
578
579
            put_bits(&s->pb, 1, 0);	/* mb coded */
            if(s->mv_type==MV_TYPE_16X16){
                cbpc = cbp & 3;
580
                if(s->dquant) cbpc+= 8;
581
582
583
                put_bits(&s->pb,
                        inter_MCBPC_bits[cbpc],
                        inter_MCBPC_code[cbpc]);
584

585
586
                cbpy = cbp >> 2;
                cbpy ^= 0xf;
587
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
588
589
                if(s->dquant)
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
590
591
592
593
594
595

                if(!s->progressive_sequence){
                    if(cbp)
                        put_bits(pb2, 1, s->interlaced_dct);
                    put_bits(pb2, 1, 0); // no interlaced ME yet
                }
596
                    
597
598
599
600
601
                if(interleaved_stats){
                    bits= get_bit_count(&s->pb);
                    s->misc_bits+= bits - s->last_bits;
                    s->last_bits=bits;
                }
602

603
604
605
606
607
608
609
610
611
612
613
614
                /* 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;
615
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
616

617
618
619
620
621
                if(interleaved_stats){
                    bits= get_bit_count(&s->pb);
                    s->misc_bits+= bits - s->last_bits;
                    s->last_bits=bits;
                }
622
623
624
625
626
627
628
629

                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
630
            }
631
632
633
634
635
636

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

638
639
            /* encode each block */
            for (i = 0; i < 6; i++) {
640
641
642
643
644
645
646
                mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, tex_pb);
            }

            if(interleaved_stats){
                bits= get_bit_count(&s->pb);
                s->p_tex_bits+= bits - s->last_bits;
                s->last_bits=bits;
647
            }
648
            s->f_count++;
649
650
        }
    } else {
651
        int cbp;
652
653
654
655
656
657
658
659
660
        int dc_diff[6];   //dc values with the dc prediction subtracted 
        int dir[6];  //prediction direction
        int zigzag_last_index[6];
        UINT8 *scan_table[6];

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

661
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
            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++){
                UINT8 *st;
                int last_index;

                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
                if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
                else           st = ff_alternate_horizontal_scan; /* top */

                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++)
                scan_table[i]= zigzag_direct;
        }

        /* 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) {
700
            if(s->dquant) cbpc+=4;
701
702
703
704
            put_bits(&s->pb,
                intra_MCBPC_bits[cbpc],
                intra_MCBPC_code[cbpc]);
        } else {
705
            if(s->dquant) cbpc+=8;
706
707
708
709
710
            put_bits(&s->pb, 1, 0);	/* mb coded */
            put_bits(&s->pb,
                inter_MCBPC_bits[cbpc + 4],
                inter_MCBPC_code[cbpc + 4]);
        }
711
        put_bits(pb2, 1, s->ac_pred);
712
        cbpy = cbp >> 2;
713
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
714
715
        if(s->dquant)
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
716

717
718
719
720
        if(!s->progressive_sequence){
            put_bits(dc_pb, 1, s->interlaced_dct);
        }

721
722
723
724
725
        if(interleaved_stats){
            bits= get_bit_count(&s->pb);
            s->misc_bits+= bits - s->last_bits;
            s->last_bits=bits;
        }
726

727
728
        /* encode each block */
        for (i = 0; i < 6; i++) {
729
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
730
731
        }

732
733
734
735
736
        if(interleaved_stats){
            bits= get_bit_count(&s->pb);
            s->i_tex_bits+= bits - s->last_bits;
            s->last_bits=bits;
        }
737
738
        s->i_count++;

739
740
741
742
743
744
        /* 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;    
                INT16 *ac_val;

Michael Niedermayer's avatar
Michael Niedermayer committed
745
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
746
747
748
749
750
751
752
753
754
755
756
757
758
759

                if(dir[i]){
                    for(j=1; j<8; j++) 
                        block[i][block_permute_op(j   )]= ac_val[j+8];
                }else{
                    for(j=1; j<8; j++) 
                        block[i][block_permute_op(j<<3)]= ac_val[j  ];
                }
                s->block_last_index[i]= zigzag_last_index[i];
            }
        }
    }
}

Fabrice Bellard's avatar
Fabrice Bellard committed
760
761
762
763
764
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;
765
766
767
    INT16 pred_dc;
    INT16 rec_intradc[6];
    UINT16 *dc_ptr[6];
768
    const int dquant_code[5]= {1,0,9,2,3};
769
770
           
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
771
    if (!s->mb_intra) {
772
        /* compute cbp */
773
774
775
776
777
        cbp = 0;
        for (i = 0; i < 6; i++) {
            if (s->block_last_index[i] >= 0)
                cbp |= 1 << (5 - i);
        }
778
        if ((cbp | motion_x | motion_y | s->dquant) == 0) {
779
780
781
782
            /* skip macroblock */
            put_bits(&s->pb, 1, 1);
            return;
        }
783
        put_bits(&s->pb, 1, 0);	/* mb coded */
784
        cbpc = cbp & 3;
785
        if(s->dquant) cbpc+= 8;
786
        put_bits(&s->pb,
787
788
		    inter_MCBPC_bits[cbpc],
		    inter_MCBPC_code[cbpc]);
789
790
791
        cbpy = cbp >> 2;
        cbpy ^= 0xf;
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
792
793
        if(s->dquant)
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
794

795
        /* motion vectors: 16x16 mode only now */
796
        h263_pred_motion(s, 0, &pred_x, &pred_y);
797
      
798
799
800
801
802
803
804
805
        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))
806
                /* To prevent Start Code emulation */
807
808
                put_bits(&s->pb,1,1);
        }
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
    } 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) {
                INT16 level = block[i][0];
            
                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
854

855
856
        cbpc = cbp & 3;
        if (s->pict_type == I_TYPE) {
857
            if(s->dquant) cbpc+=4;
858
859
860
861
            put_bits(&s->pb,
                intra_MCBPC_bits[cbpc],
                intra_MCBPC_code[cbpc]);
        } else {
862
            if(s->dquant) cbpc+=8;
863
864
865
866
867
868
869
870
871
872
873
            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]);
874
875
        if(s->dquant)
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
Fabrice Bellard's avatar
Fabrice Bellard committed
876
877
    }

878
879
    for(i=0; i<6; i++) {
        /* encode each block */
880
        h263_encode_block(s, block[i], i);
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
    
        /* Update INTRADC for decoding */
        if (s->h263_aic && s->mb_intra) {
            block[i][0] = rec_intradc[i];
            
        }
    }
}

static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
{
    int x, y, wrap, a, c, pred_dc, scale;
    INT16 *dc_val, *ac_val;

    /* 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
910
    }
911
912
913
914
915
916
917
    /* B C
     * A X 
     */
    a = dc_val[(x - 1) + (y) * wrap];
    c = dc_val[(x) + (y - 1) * wrap];
    
    /* No prediction outside GOB boundary */
918
    if (s->first_slice_line && ((n < 2) || (n > 3)))
919
920
921
922
923
924
925
926
927
928
929
930
931
932
        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
933
934
}

935

936
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
937
{
938
939
    int x, y, wrap, a, c, pred_dc, scale, i;
    INT16 *dc_val, *ac_val, *ac_val1;
940
941
942
943
944
945
946

    /* 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];
947
        ac_val = s->ac_val[0][0];
948
949
950
951
952
953
        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];
954
        ac_val = s->ac_val[n - 4 + 1][0];
955
956
        scale = s->c_dc_scale;
    }
957
958
959
960
    
    ac_val += ((y) * wrap + (x)) * 16;
    ac_val1 = ac_val;
    
961
962
963
964
965
966
    /* B C
     * A X 
     */
    a = dc_val[(x - 1) + (y) * wrap];
    c = dc_val[(x) + (y - 1) * wrap];
    
967
    /* No prediction outside GOB boundary */
968
    if (s->first_slice_line && ((n < 2) || (n > 3)))
969
        c = 1024;
970
    pred_dc = 1024;
971
972
973
    if (s->ac_pred) {
        if (s->h263_aic_dir) {
            /* left prediction */
974
975
976
977
978
979
            if (a != 1024) {
                ac_val -= 16;
                for(i=1;i<8;i++) {
                    block[block_permute_op(i*8)] += ac_val[i];
                }
                pred_dc = a;
980
981
982
            }
        } else {
            /* top prediction */
983
984
985
986
987
988
            if (c != 1024) {
                ac_val -= 16 * wrap;
                for(i=1;i<8;i++) {
                    block[block_permute_op(i)] += ac_val[i + 8];
                }
                pred_dc = c;
989
990
            }
        }
991
992
993
994
995
996
997
998
    } else {
        /* just DC prediction */
        if (a != 1024 && c != 1024)
            pred_dc = (a + c) >> 1;
        else if (a != 1024)
            pred_dc = a;
        else
            pred_dc = c;
999
    }
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
    
    /* we assume pred is positive */
    block[0]=block[0]*scale + pred_dc;
    
    if (block[0] < 0)
        block[0] = 0;
    else if (!(block[0] & 1))
        block[0]++;
    
    /* Update AC/DC tables */
    dc_val[(x) + (y) * wrap] = block[0];
    
1012
1013
1014
1015
1016
1017
1018
1019
    /* left copy */
    for(i=1;i<8;i++)
        ac_val1[i] = block[block_permute_op(i * 8)];
    /* top copy */
    for(i=1;i<8;i++)
        ac_val1[8 + i] = block[block_permute_op(i)];
}

Fabrice Bellard's avatar
Fabrice Bellard committed
1020
1021
1022
INT16 *h263_pred_motion(MpegEncContext * s, int block, 
                        int *px, int *py)
{
Michael Niedermayer's avatar
Michael Niedermayer committed
1023
    int xy, wrap;
Fabrice Bellard's avatar
Fabrice Bellard committed
1024
    INT16 *A, *B, *C, *mot_val;
1025
    static const int off[4]= {2, 1, 1, -1};
Fabrice Bellard's avatar
Fabrice Bellard committed
1026

Michael Niedermayer's avatar
Michael Niedermayer committed
1027
1028
    wrap = s->block_wrap[0];
    xy = s->block_index[block];
Fabrice Bellard's avatar
Fabrice Bellard committed
1029

Zdenek Kabelac's avatar
Zdenek Kabelac committed
1030
    mot_val = s->motion_val[xy];
Fabrice Bellard's avatar
Fabrice Bellard committed
1031

1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
    A = s->motion_val[xy - 1];
    /* special case for first (slice) line */
    if ((s->mb_y == 0 || s->first_slice_line) && block<3) {
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
        if(block==0){ //most common case
            if(s->mb_x  == s->resync_mb_x){ //rare
                *px= *py = 0;
            }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
                C = s->motion_val[xy + off[block] - wrap];
                if(s->mb_x==0){
                    *px = C[0];
                    *py = C[1];
                }else{
                    *px = mid_pred(A[0], 0, C[0]);
                    *py = mid_pred(A[1], 0, C[1]);
                }
            }else{
                *px = A[0];
                *py = A[1];
            }
        }else if(block==1){
            if(s->mb_x + 1 == s->resync_mb_x){ //rare
                C = s->motion_val[xy + off[block] - wrap];
                *px = mid_pred(A[0], 0, C[0]);
                *py = mid_pred(A[1], 0, C[1]);
            }else{
                *px = A[0];
                *py = A[1];
            }
        }else{ /* block==2*/
            B = s->motion_val[xy - wrap];
            C = s->motion_val[xy + off[block] - wrap];
            if(s->mb_x == s->resync_mb_x) //rare
                A[0]=A[1]=0;
    
            *px = mid_pred(A[0], B[0], C[0]);
            *py = mid_pred(A[1], B[1], C[1]);
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1071
    } else {
1072
1073
        B = s->motion_val[xy - wrap];
        C = s->motion_val[xy + off[block] - wrap];
Fabrice Bellard's avatar
Fabrice Bellard committed
1074
1075
1076
1077
1078
1079
        *px = mid_pred(A[0], B[0], C[0]);
        *py = mid_pred(A[1], B[1], C[1]);
    }
    return mot_val;
}

1080
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
Fabrice Bellard's avatar
Fabrice Bellard committed
1081
1082
1083
1084
1085
1086
1087
1088
{
    int range, l, m, bit_size, sign, code, bits;

    if (val == 0) {
        /* zero vector */
        code = 0;
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
    } else {
1089
        bit_size = f_code - 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1090
1091
1092
1093
1094
1095
1096
1097
1098
        range = 1 << bit_size;
        /* modulo encoding */
        l = range * 32;
        m = 2 * l;
        if (val < -l) {
            val += m;
        } else if (val >= l) {
            val -= m;
        }
1099
        assert(val>=-l && val<l);
Fabrice Bellard's avatar
Fabrice Bellard committed
1100
1101
1102
1103
1104
1105
1106

        if (val >= 0) {
            sign = 0;
        } else {
            val = -val;
            sign = 1;
        }
1107
1108
1109
        val--;
        code = (val >> bit_size) + 1;
        bits = val & (range - 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1110
1111
1112
1113
1114
1115
1116
1117

        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
        if (bit_size > 0) {
            put_bits(&s->pb, bit_size, bits);
        }
    }
}

1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
/* Encode MV differences on H.263+ with Unrestricted MV mode */
static void h263p_encode_umotion(MpegEncContext * s, int val)
{
    short sval = 0; 
    short i = 0;
    short n_bits = 0;
    short temp_val;
    int code = 0;
    int tcode;
    
    if ( val == 0)
        put_bits(&s->pb, 1, 1);
    else if (val == 1)
        put_bits(&s->pb, 3, 0);
    else if (val == -1)
        put_bits(&s->pb, 3, 2);
    else {
        
        sval = ((val < 0) ? (short)(-val):(short)val);
        temp_val = sval;
        
        while (temp_val != 0) {
            temp_val = temp_val >> 1;
            n_bits++;
        }
        
        i = n_bits - 1;
        while (i > 0) {
            tcode = (sval & (1 << (i-1))) >> (i-1);
            tcode = (tcode << 1) | 1;
            code = (code << 2) | tcode;
            i--;
        }
        code = ((code << 1) | (val < 0)) << 1;
        put_bits(&s->pb, (2*n_bits)+1, code);
        //printf("\nVal = %d\tCode = %d", sval, code);
    }
}

1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
static void init_mv_penalty_and_fcode(MpegEncContext *s)
{
    int f_code;
    int mv;
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
            int len;

            if(mv==0) len= mvtab[0][1];
            else{
                int val, bit_size, range, code;

                bit_size = s->f_code - 1;
                range = 1 << bit_size;

                val=mv;
                if (val < 0) 
                    val = -val;
                val--;
                code = (val >> bit_size) + 1;
                if(code<33){
                    len= mvtab[code][1] + 1 + bit_size;
                }else{
                    len= mvtab[32][1] + 2 + bit_size;
                }
            }

            mv_penalty[f_code][mv+MAX_MV]= len;
        }
    }

    for(f_code=MAX_FCODE; f_code>0; f_code--){
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
            fcode_tab[mv+MAX_MV]= f_code;
        }
    }
1193
1194
1195
1196

    for(mv=0; mv<MAX_MV*2+1; mv++){
        umv_fcode_tab[mv]= 1;
    }
1197
1198
}

Falk Hüffner's avatar
Falk Hüffner committed
1199
static void init_uni_dc_tab(void)
1200
1201
1202
{
    int level, uni_code, uni_len;

1203
    for(level=-256; level<256; level++){
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
        int size, v, l;
        /* find number of bits */
        size = 0;
        v = abs(level);
        while (v) {
            v >>= 1;
	    size++;
        }

        if (level < 0)
            l= (-level) ^ ((1 << size) - 1);
        else
            l= level;

        /* luminance */
        uni_code= DCtab_lum[size][0];
        uni_len = DCtab_lum[size][1];

        if (size > 0) {
            uni_code<<=size; uni_code|=l;
            uni_len+=size;
            if (size > 8){
                uni_code<<=1; uni_code|=1;
                uni_len++;
            }
        }