Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 92073d01

History | View | Annotate | Download (130 KB)

1
/*
2
 * H263/MPEG4 backend for ffmpeg encoder and decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * H263+ support.
5
 * Copyright (c) 2001 Juan J. Sierralta P.
6
 *
7
 * This library is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2 of the License, or (at your option) any later version.
11
 *
12
 * This library is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library; if not, write to the Free Software
19
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20
 *
21
 * ac prediction encoding & b-frame support by Michael Niedermayer <michaelni@gmx.at>
22
 */
23
 
24
//#define DEBUG
25
#include "common.h"
26
#include "dsputil.h"
27
#include "avcodec.h"
28
#include "mpegvideo.h"
29
#include "h263data.h"
30
#include "mpeg4data.h"
31

    
32
//rounded divison & shift
33
#define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
34

    
35
#define PRINT_MB_TYPE(a) ;
36
//#define PRINT_MB_TYPE(a) printf(a);
37

    
38
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
39
                              int n);
40
static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
41
static void h263p_encode_umotion(MpegEncContext * s, int val);
42
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
43
                               int n, int dc, UINT8 *scan_table, 
44
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
45
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
46
static int h263p_decode_umotion(MpegEncContext * s, int pred);
47
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
48
                             int n, int coded);
49
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
50
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
51
                              int n, int coded);
52
static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
53
static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
54
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
55
                              int dir);
56
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
57

    
58
extern UINT32 inverse[256];
59

    
60
static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
61
static UINT8 fcode_tab[MAX_MV*2+1];
62
static UINT8 umv_fcode_tab[MAX_MV*2+1];
63

    
64
static UINT16 uni_DCtab_lum  [512][2];
65
static UINT16 uni_DCtab_chrom[512][2];
66

    
67
int h263_get_picture_format(int width, int height)
68
{
69
    int format;
70

    
71
    if (width == 128 && height == 96)
72
        format = 1;
73
    else if (width == 176 && height == 144)
74
        format = 2;
75
    else if (width == 352 && height == 288)
76
        format = 3;
77
    else if (width == 704 && height == 576)
78
        format = 4;
79
    else if (width == 1408 && height == 1152)
80
        format = 5;
81
    else
82
        format = 7;
83
    return format;
84
}
85

    
86
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
87
{
88
    int format;
89

    
90
    align_put_bits(&s->pb);
91

    
92
    /* Update the pointer to last GOB */
93
    s->ptr_lastgob = pbBufPtr(&s->pb);
94
    s->gob_number = 0;
95

    
96
    put_bits(&s->pb, 22, 0x20); /* PSC */
97
    put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 
98
                         s->frame_rate) & 0xff);
99

    
100
    put_bits(&s->pb, 1, 1);        /* marker */
101
    put_bits(&s->pb, 1, 0);        /* h263 id */
102
    put_bits(&s->pb, 1, 0);        /* split screen off */
103
    put_bits(&s->pb, 1, 0);        /* camera  off */
104
    put_bits(&s->pb, 1, 0);        /* freeze picture release off */
105
    
106
    format = h263_get_picture_format(s->width, s->height);
107
    if (!s->h263_plus) {
108
        /* H.263v1 */
109
        put_bits(&s->pb, 3, format);
110
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
111
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
112
        of H.263v1 UMV implies to check the predicted MV after
113
        calculation of the current MB to see if we're on the limits */
114
        put_bits(&s->pb, 1, 0);        /* unrestricted motion vector: off */
115
        put_bits(&s->pb, 1, 0);        /* SAC: off */
116
        put_bits(&s->pb, 1, 0);        /* advanced prediction mode: off */
117
        put_bits(&s->pb, 1, 0);        /* not PB frame */
118
        put_bits(&s->pb, 5, s->qscale);
119
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
120
    } else {
121
        /* H.263v2 */
122
        /* H.263 Plus PTYPE */
123
        put_bits(&s->pb, 3, 7);
124
        put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
125
        if (format == 7)
126
            put_bits(&s->pb,3,6); /* Custom Source Format */
127
        else
128
            put_bits(&s->pb, 3, format);
129
            
130
        put_bits(&s->pb,1,0); /* Custom PCF: off */
131
        s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
132
        put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
133
        put_bits(&s->pb,1,0); /* SAC: off */
134
        put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
135
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
136
        put_bits(&s->pb,1,0); /* Deblocking Filter: off */
137
        put_bits(&s->pb,1,0); /* Slice Structured: off */
138
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
139
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
140
        put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
141
        put_bits(&s->pb,1,0); /* Modified Quantization: off */
142
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
143
        put_bits(&s->pb,3,0); /* Reserved */
144
                
145
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
146
                
147
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
148
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
149
        if (s->pict_type == I_TYPE)
150
            s->no_rounding = 0;
151
        else
152
            s->no_rounding ^= 1;
153
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
154
        put_bits(&s->pb,2,0); /* Reserved */
155
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
156
                
157
        /* This should be here if PLUSPTYPE */
158
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
159
                
160
                if (format == 7) {
161
            /* Custom Picture Format (CPFMT) */
162
                
163
            if (s->aspect_ratio_info)
164
            put_bits(&s->pb,4,s->aspect_ratio_info);
165
            else
166
            put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
167
            put_bits(&s->pb,9,(s->width >> 2) - 1);
168
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
169
            put_bits(&s->pb,9,(s->height >> 2));
170
        }
171
        
172
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
173
        if (s->umvplus)
174
            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
175
        put_bits(&s->pb, 5, s->qscale);
176
    }
177

    
178
    put_bits(&s->pb, 1, 0);        /* no PEI */
179
}
180

    
181
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
182
{
183
    int pdif=0;
184
    
185
    /* Check to see if we need to put a new GBSC */
186
    /* for RTP packetization                    */
187
    if (s->rtp_mode) {
188
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
189
        if (pdif >= s->rtp_payload_size) {
190
            /* Bad luck, packet must be cut before */
191
            align_put_bits(&s->pb);
192
            flush_put_bits(&s->pb);
193
            /* Call the RTP callback to send the last GOB */
194
            if (s->rtp_callback) {
195
                pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
196
                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
197
            }
198
            s->ptr_lastgob = pbBufPtr(&s->pb);
199
            put_bits(&s->pb, 17, 1); /* GBSC */
200
            s->gob_number = mb_line / s->gob_index;
201
            put_bits(&s->pb, 5, s->gob_number); /* GN */
202
            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
203
            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
204
            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
205
            return pdif;
206
       } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
207
           /* Cut the packet before we can't */
208
           align_put_bits(&s->pb);
209
           flush_put_bits(&s->pb);
210
           /* Call the RTP callback to send the last GOB */
211
           if (s->rtp_callback) {
212
               pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
213
               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
214
           }
215
           s->ptr_lastgob = pbBufPtr(&s->pb);
216
           put_bits(&s->pb, 17, 1); /* GBSC */
217
           s->gob_number = mb_line / s->gob_index;
218
           put_bits(&s->pb, 5, s->gob_number); /* GN */
219
           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
220
           put_bits(&s->pb, 5, s->qscale); /* GQUANT */
221
           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
222
           return pdif;
223
       }
224
   }
225
   return 0;
226
}
227

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

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

    
236
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
237
        ac_val1= ac_val;
238
        if(dir[n]){
239
            ac_val-= s->block_wrap[n]*16;
240
            for(i=1; i<8; i++){
241
                const int level= block[n][block_permute_op(i   )];
242
                score0+= ABS(level);
243
                score1+= ABS(level - ac_val[i+8]);
244
                ac_val1[i  ]=    block[n][block_permute_op(i<<3)];
245
                ac_val1[i+8]= level;
246
            }
247
        }else{
248
            ac_val-= 16;
249
            for(i=1; i<8; i++){
250
                const int level= block[n][block_permute_op(i<<3)];
251
                score0+= ABS(level);
252
                score1+= ABS(level - ac_val[i]);
253
                ac_val1[i  ]= level;
254
                ac_val1[i+8]=    block[n][block_permute_op(i   )];
255
            }
256
        }
257
    }
258

    
259
    return score0 > score1 ? 1 : 0;    
260
}
261

    
262
void mpeg4_encode_mb(MpegEncContext * s,
263
                    DCTELEM block[6][64],
264
                    int motion_x, int motion_y)
265
{
266
    int cbpc, cbpy, i, pred_x, pred_y;
267
    int bits;
268
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
269
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
270
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
271
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
272
    
273
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
274
    if (!s->mb_intra) {
275
        /* compute cbp */
276
        int cbp = 0;
277
        for (i = 0; i < 6; i++) {
278
            if (s->block_last_index[i] >= 0)
279
                cbp |= 1 << (5 - i);
280
        }
281

    
282
        if(s->pict_type==B_TYPE){
283
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
284
            int mb_type=  mb_type_table[s->mv_dir];
285
            
286
            if(s->mb_x==0){
287
                s->last_mv[0][0][0]= 
288
                s->last_mv[0][0][1]= 
289
                s->last_mv[1][0][0]= 
290
                s->last_mv[1][0][1]= 0;
291
            }
292

    
293
            /* nothing to do if this MB was skiped in the next P Frame */
294
            if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){
295
                s->skip_count++;
296
                s->mv[0][0][0]= 
297
                s->mv[0][0][1]= 
298
                s->mv[1][0][0]= 
299
                s->mv[1][0][1]= 0;
300
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
301
                return;
302
            }
303

    
304
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
305
                /* direct MB with MV={0,0} */
306
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
307

    
308
                if(interleaved_stats){
309
                    s->misc_bits++;
310
                    s->last_bits++;
311
                }
312
                s->skip_count++;
313
                return;
314
            }
315
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
316
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
317
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
318
            if(cbp) put_bits(&s->pb, 6, cbp);
319
            
320
            if(cbp && mb_type)
321
                put_bits(&s->pb, 1, 0); /* no q-scale change */
322

    
323
            if(interleaved_stats){
324
                bits= get_bit_count(&s->pb);
325
                s->misc_bits+= bits - s->last_bits;
326
                s->last_bits=bits;
327
            }
328

    
329
            switch(mb_type)
330
            {
331
            case 0: /* direct */
332
                h263_encode_motion(s, motion_x, 1);
333
                h263_encode_motion(s, motion_y, 1);                
334
                break;
335
            case 1: /* bidir */
336
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
337
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
338
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
339
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
340
                s->last_mv[0][0][0]= s->mv[0][0][0];
341
                s->last_mv[0][0][1]= s->mv[0][0][1];
342
                s->last_mv[1][0][0]= s->mv[1][0][0];
343
                s->last_mv[1][0][1]= s->mv[1][0][1];
344
                break;
345
            case 2: /* backward */
346
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
347
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
348
                s->last_mv[1][0][0]= motion_x;
349
                s->last_mv[1][0][1]= motion_y;
350
                break;
351
            case 3: /* forward */
352
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
353
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
354
                s->last_mv[0][0][0]= motion_x;
355
                s->last_mv[0][0][1]= motion_y;
356
                break;
357
            default:
358
                printf("unknown mb type\n");
359
                return;
360
            }
361

    
362
            if(interleaved_stats){
363
                bits= get_bit_count(&s->pb);
364
                s->mv_bits+= bits - s->last_bits;
365
                s->last_bits=bits;
366
            }
367

    
368
            /* encode each block */
369
            for (i = 0; i < 6; i++) {
370
                mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, &s->pb);
371
            }
372

    
373
            if(interleaved_stats){
374
                bits= get_bit_count(&s->pb);
375
                s->p_tex_bits+= bits - s->last_bits;
376
                s->last_bits=bits;
377
            }
378
        }else{ /* s->pict_type==B_TYPE */
379
            if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) {
380
                /* check if the B frames can skip it too, as we must skip it if we skip here 
381
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
382
                if(s->max_b_frames>0){
383
                    int i;
384
                    int x,y, offset;
385
                    uint8_t *p_pic;
386

    
387
                    x= s->mb_x*16;
388
                    y= s->mb_y*16;
389
                    if(x+16 > s->width)  x= s->width-16;
390
                    if(y+16 > s->height) y= s->height-16;
391

    
392
                    offset= x + y*s->linesize;
393
                    p_pic= s->new_picture[0] + offset;
394
                    
395
                    s->mb_skiped=1;
396
                    for(i=0; i<s->max_b_frames; i++){
397
                        uint8_t *b_pic;
398
                        int diff;
399

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

    
402
                        b_pic= s->coded_order[i+1].picture[0] + offset;
403
                        diff= pix_abs16x16(p_pic, b_pic, s->linesize);
404
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
405
                            s->mb_skiped=0;
406
                            break;
407
                        }
408
                    }
409
                }else
410
                    s->mb_skiped=1; 
411

    
412
                if(s->mb_skiped==1){
413
                    /* skip macroblock */
414
                    put_bits(&s->pb, 1, 1);
415

    
416
                    if(interleaved_stats){
417
                        s->misc_bits++;
418
                        s->last_bits++;
419
                    }
420
                    s->skip_count++;
421
                    return;
422
                }
423
            }
424

    
425
            put_bits(&s->pb, 1, 0);        /* mb coded */
426
            if(s->mv_type==MV_TYPE_16X16){
427
                cbpc = cbp & 3;
428
                put_bits(&s->pb,
429
                        inter_MCBPC_bits[cbpc],
430
                        inter_MCBPC_code[cbpc]);
431
                cbpy = cbp >> 2;
432
                cbpy ^= 0xf;
433
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
434
                    
435
                if(interleaved_stats){
436
                    bits= get_bit_count(&s->pb);
437
                    s->misc_bits+= bits - s->last_bits;
438
                    s->last_bits=bits;
439
                }
440

    
441
                /* motion vectors: 16x16 mode */
442
                h263_pred_motion(s, 0, &pred_x, &pred_y);
443
            
444
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
445
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
446
            }else{
447
                cbpc = (cbp & 3)+16;
448
                put_bits(&s->pb,
449
                        inter_MCBPC_bits[cbpc],
450
                        inter_MCBPC_code[cbpc]);
451
                cbpy = cbp >> 2;
452
                cbpy ^= 0xf;
453
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
454

    
455
                if(interleaved_stats){
456
                    bits= get_bit_count(&s->pb);
457
                    s->misc_bits+= bits - s->last_bits;
458
                    s->last_bits=bits;
459
                }
460

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

    
465
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
466
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
467
                }
468
            }
469

    
470
            if(interleaved_stats){ 
471
                bits= get_bit_count(&s->pb);
472
                s->mv_bits+= bits - s->last_bits;
473
                s->last_bits=bits;
474
            }
475

    
476
            /* encode each block */
477
            for (i = 0; i < 6; i++) {
478
                mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, tex_pb);
479
            }
480

    
481
            if(interleaved_stats){
482
                bits= get_bit_count(&s->pb);
483
                s->p_tex_bits+= bits - s->last_bits;
484
                s->last_bits=bits;
485
            }
486
            s->p_count++;
487
        }
488
    } else {
489
        int cbp;
490
        int dc_diff[6];   //dc values with the dc prediction subtracted 
491
        int dir[6];  //prediction direction
492
        int zigzag_last_index[6];
493
        UINT8 *scan_table[6];
494

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

    
499
            dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
500
            if (i < 4) {
501
                *dc_ptr = level * s->y_dc_scale;
502
            } else {
503
                *dc_ptr = level * s->c_dc_scale;
504
            }
505
        }
506

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

    
509
        if(s->ac_pred){
510
            for(i=0; i<6; i++){
511
                UINT8 *st;
512
                int last_index;
513

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

    
518
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
519
                    if(block[i][st[last_index]]) break;
520
                zigzag_last_index[i]= s->block_last_index[i];
521
                s->block_last_index[i]= last_index;
522
                scan_table[i]= st;
523
            }
524
        }else{
525
            for(i=0; i<6; i++)
526
                scan_table[i]= zigzag_direct;
527
        }
528

    
529
        /* compute cbp */
530
        cbp = 0;
531
        for (i = 0; i < 6; i++) {
532
            if (s->block_last_index[i] >= 1)
533
                cbp |= 1 << (5 - i);
534
        }
535

    
536
        cbpc = cbp & 3;
537
        if (s->pict_type == I_TYPE) {
538
            put_bits(&s->pb,
539
                intra_MCBPC_bits[cbpc],
540
                intra_MCBPC_code[cbpc]);
541
        } else {
542
            put_bits(&s->pb, 1, 0);        /* mb coded */
543
            put_bits(&s->pb,
544
                inter_MCBPC_bits[cbpc + 4],
545
                inter_MCBPC_code[cbpc + 4]);
546
        }
547
        put_bits(pb2, 1, s->ac_pred);
548
        cbpy = cbp >> 2;
549
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
550

    
551
        if(interleaved_stats){
552
            bits= get_bit_count(&s->pb);
553
            s->misc_bits+= bits - s->last_bits;
554
            s->last_bits=bits;
555
        }
556

    
557
        /* encode each block */
558
        for (i = 0; i < 6; i++) {
559
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
560
        }
561

    
562
        if(interleaved_stats){
563
            bits= get_bit_count(&s->pb);
564
            s->i_tex_bits+= bits - s->last_bits;
565
            s->last_bits=bits;
566
        }
567
        s->i_count++;
568

    
569
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
570
        if(s->ac_pred){
571
            for(i=0; i<6; i++){
572
                int j;    
573
                INT16 *ac_val;
574

    
575
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
576

    
577
                if(dir[i]){
578
                    for(j=1; j<8; j++) 
579
                        block[i][block_permute_op(j   )]= ac_val[j+8];
580
                }else{
581
                    for(j=1; j<8; j++) 
582
                        block[i][block_permute_op(j<<3)]= ac_val[j  ];
583
                }
584
                s->block_last_index[i]= zigzag_last_index[i];
585
            }
586
        }
587
    }
588
}
589

    
590
void h263_encode_mb(MpegEncContext * s,
591
                    DCTELEM block[6][64],
592
                    int motion_x, int motion_y)
593
{
594
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
595
    INT16 pred_dc;
596
    INT16 rec_intradc[6];
597
    UINT16 *dc_ptr[6];
598
           
599
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
600
    if (!s->mb_intra) {
601
        /* compute cbp */
602
        cbp = 0;
603
        for (i = 0; i < 6; i++) {
604
            if (s->block_last_index[i] >= 0)
605
                cbp |= 1 << (5 - i);
606
        }
607
        if ((cbp | motion_x | motion_y) == 0) {
608
            /* skip macroblock */
609
            put_bits(&s->pb, 1, 1);
610
            return;
611
        }
612
        put_bits(&s->pb, 1, 0);        /* mb coded */
613
        cbpc = cbp & 3;
614
        put_bits(&s->pb,
615
                    inter_MCBPC_bits[cbpc],
616
                    inter_MCBPC_code[cbpc]);
617
        cbpy = cbp >> 2;
618
        cbpy ^= 0xf;
619
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
620

    
621
        /* motion vectors: 16x16 mode only now */
622
        h263_pred_motion(s, 0, &pred_x, &pred_y);
623
      
624
        if (!s->umvplus) {  
625
            h263_encode_motion(s, motion_x - pred_x, s->f_code);
626
            h263_encode_motion(s, motion_y - pred_y, s->f_code);
627
        }
628
        else {
629
            h263p_encode_umotion(s, motion_x - pred_x);
630
            h263p_encode_umotion(s, motion_y - pred_y);
631
            if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
632
                /* To prevent Start Code emulation */
633
                put_bits(&s->pb,1,1);
634
        }
635
    } else {
636
        int li = s->h263_aic ? 0 : 1;
637
        
638
        cbp = 0;
639
        for(i=0; i<6; i++) {
640
            /* Predict DC */
641
            if (s->h263_aic && s->mb_intra) {
642
                INT16 level = block[i][0];
643
            
644
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
645
                level -= pred_dc;
646
                /* Quant */
647
                if (level < 0)
648
                    level = (level + (s->qscale >> 1))/(s->y_dc_scale);
649
                else
650
                    level = (level - (s->qscale >> 1))/(s->y_dc_scale);
651
                    
652
                /* AIC can change CBP */
653
                if (level == 0 && s->block_last_index[i] == 0)
654
                    s->block_last_index[i] = -1;
655
                else if (level < -127)
656
                    level = -127;
657
                else if (level > 127)
658
                    level = 127;
659
                
660
                block[i][0] = level;
661
                /* Reconstruction */ 
662
                rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
663
                /* Oddify */
664
                rec_intradc[i] |= 1;
665
                //if ((rec_intradc[i] % 2) == 0)
666
                //    rec_intradc[i]++;
667
                /* Clipping */
668
                if (rec_intradc[i] < 0)
669
                    rec_intradc[i] = 0;
670
                else if (rec_intradc[i] > 2047)
671
                    rec_intradc[i] = 2047;
672
                                
673
                /* Update AC/DC tables */
674
                *dc_ptr[i] = rec_intradc[i];
675
            }
676
            /* compute cbp */
677
            if (s->block_last_index[i] >= li)
678
                cbp |= 1 << (5 - i);
679
        }
680

    
681
        cbpc = cbp & 3;
682
        if (s->pict_type == I_TYPE) {
683
            put_bits(&s->pb,
684
                intra_MCBPC_bits[cbpc],
685
                intra_MCBPC_code[cbpc]);
686
        } else {
687
            put_bits(&s->pb, 1, 0);        /* mb coded */
688
            put_bits(&s->pb,
689
                inter_MCBPC_bits[cbpc + 4],
690
                inter_MCBPC_code[cbpc + 4]);
691
        }
692
        if (s->h263_aic) {
693
            /* XXX: currently, we do not try to use ac prediction */
694
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
695
        }
696
        cbpy = cbp >> 2;
697
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
698
    }
699

    
700
    for(i=0; i<6; i++) {
701
        /* encode each block */
702
        h263_encode_block(s, block[i], i);
703
    
704
        /* Update INTRADC for decoding */
705
        if (s->h263_aic && s->mb_intra) {
706
            block[i][0] = rec_intradc[i];
707
            
708
        }
709
    }
710
}
711

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

    
717
    /* find prediction */
718
    if (n < 4) {
719
        x = 2 * s->mb_x + 1 + (n & 1);
720
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
721
        wrap = s->mb_width * 2 + 2;
722
        dc_val = s->dc_val[0];
723
        ac_val = s->ac_val[0][0];
724
        scale = s->y_dc_scale;
725
    } else {
726
        x = s->mb_x + 1;
727
        y = s->mb_y + 1;
728
        wrap = s->mb_width + 2;
729
        dc_val = s->dc_val[n - 4 + 1];
730
        ac_val = s->ac_val[n - 4 + 1][0];
731
        scale = s->c_dc_scale;
732
    }
733
    /* B C
734
     * A X 
735
     */
736
    a = dc_val[(x - 1) + (y) * wrap];
737
    c = dc_val[(x) + (y - 1) * wrap];
738
    
739
    /* No prediction outside GOB boundary */
740
    if (s->first_slice_line && ((n < 2) || (n > 3)))
741
        c = 1024;
742
    pred_dc = 1024;
743
    /* just DC prediction */
744
    if (a != 1024 && c != 1024)
745
        pred_dc = (a + c) >> 1;
746
    else if (a != 1024)
747
        pred_dc = a;
748
    else
749
        pred_dc = c;
750
    
751
    /* we assume pred is positive */
752
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
753
    *dc_val_ptr = &dc_val[x + y * wrap];
754
    return pred_dc;
755
}
756

    
757

    
758
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
759
{
760
    int x, y, wrap, a, c, pred_dc, scale, i;
761
    INT16 *dc_val, *ac_val, *ac_val1;
762

    
763
    /* find prediction */
764
    if (n < 4) {
765
        x = 2 * s->mb_x + 1 + (n & 1);
766
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
767
        wrap = s->mb_width * 2 + 2;
768
        dc_val = s->dc_val[0];
769
        ac_val = s->ac_val[0][0];
770
        scale = s->y_dc_scale;
771
    } else {
772
        x = s->mb_x + 1;
773
        y = s->mb_y + 1;
774
        wrap = s->mb_width + 2;
775
        dc_val = s->dc_val[n - 4 + 1];
776
        ac_val = s->ac_val[n - 4 + 1][0];
777
        scale = s->c_dc_scale;
778
    }
779
    
780
    ac_val += ((y) * wrap + (x)) * 16;
781
    ac_val1 = ac_val;
782
    
783
    /* B C
784
     * A X 
785
     */
786
    a = dc_val[(x - 1) + (y) * wrap];
787
    c = dc_val[(x) + (y - 1) * wrap];
788
    
789
    /* No prediction outside GOB boundary */
790
    if (s->first_slice_line && ((n < 2) || (n > 3)))
791
        c = 1024;
792
    pred_dc = 1024;
793
    if (s->ac_pred) {
794
        if (s->h263_aic_dir) {
795
            /* left prediction */
796
            if (a != 1024) {
797
                ac_val -= 16;
798
                for(i=1;i<8;i++) {
799
                    block[block_permute_op(i*8)] += ac_val[i];
800
                }
801
                pred_dc = a;
802
            }
803
        } else {
804
            /* top prediction */
805
            if (c != 1024) {
806
                ac_val -= 16 * wrap;
807
                for(i=1;i<8;i++) {
808
                    block[block_permute_op(i)] += ac_val[i + 8];
809
                }
810
                pred_dc = c;
811
            }
812
        }
813
    } else {
814
        /* just DC prediction */
815
        if (a != 1024 && c != 1024)
816
            pred_dc = (a + c) >> 1;
817
        else if (a != 1024)
818
            pred_dc = a;
819
        else
820
            pred_dc = c;
821
    }
822
    
823
    /* we assume pred is positive */
824
    block[0]=block[0]*scale + pred_dc;
825
    
826
    if (block[0] < 0)
827
        block[0] = 0;
828
    else if (!(block[0] & 1))
829
        block[0]++;
830
    
831
    /* Update AC/DC tables */
832
    dc_val[(x) + (y) * wrap] = block[0];
833
    
834
    /* left copy */
835
    for(i=1;i<8;i++)
836
        ac_val1[i] = block[block_permute_op(i * 8)];
837
    /* top copy */
838
    for(i=1;i<8;i++)
839
        ac_val1[8 + i] = block[block_permute_op(i)];
840
}
841

    
842
INT16 *h263_pred_motion(MpegEncContext * s, int block, 
843
                        int *px, int *py)
844
{
845
    int xy, wrap;
846
    INT16 *A, *B, *C, *mot_val;
847
    static const int off[4]= {2, 1, 1, -1};
848

    
849
    wrap = s->block_wrap[0];
850
    xy = s->block_index[block];
851

    
852
    mot_val = s->motion_val[xy];
853

    
854
    A = s->motion_val[xy - 1];
855
    /* special case for first (slice) line */
856
    if ((s->mb_y == 0 || s->first_slice_line) && block<3) {
857
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
858
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
859
        if(block==0){ //most common case
860
            if(s->mb_x  == s->resync_mb_x){ //rare
861
                *px= *py = 0;
862
            }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
863
                C = s->motion_val[xy + off[block] - wrap];
864
                if(s->mb_x==0){
865
                    *px = C[0];
866
                    *py = C[1];
867
                }else{
868
                    *px = mid_pred(A[0], 0, C[0]);
869
                    *py = mid_pred(A[1], 0, C[1]);
870
                }
871
            }else{
872
                *px = A[0];
873
                *py = A[1];
874
            }
875
        }else if(block==1){
876
            if(s->mb_x + 1 == s->resync_mb_x){ //rare
877
                C = s->motion_val[xy + off[block] - wrap];
878
                *px = mid_pred(A[0], 0, C[0]);
879
                *py = mid_pred(A[1], 0, C[1]);
880
            }else{
881
                *px = A[0];
882
                *py = A[1];
883
            }
884
        }else{ /* block==2*/
885
            B = s->motion_val[xy - wrap];
886
            C = s->motion_val[xy + off[block] - wrap];
887
            if(s->mb_x == s->resync_mb_x) //rare
888
                A[0]=A[1]=0;
889
    
890
            *px = mid_pred(A[0], B[0], C[0]);
891
            *py = mid_pred(A[1], B[1], C[1]);
892
        }
893
    } else {
894
        B = s->motion_val[xy - wrap];
895
        C = s->motion_val[xy + off[block] - wrap];
896
        *px = mid_pred(A[0], B[0], C[0]);
897
        *py = mid_pred(A[1], B[1], C[1]);
898
    }
899
    return mot_val;
900
}
901

    
902
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
903
{
904
    int range, l, m, bit_size, sign, code, bits;
905

    
906
    if (val == 0) {
907
        /* zero vector */
908
        code = 0;
909
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
910
    } else {
911
        bit_size = f_code - 1;
912
        range = 1 << bit_size;
913
        /* modulo encoding */
914
        l = range * 32;
915
        m = 2 * l;
916
        if (val < -l) {
917
            val += m;
918
        } else if (val >= l) {
919
            val -= m;
920
        }
921

    
922
        if (val >= 0) {
923
            sign = 0;
924
        } else {
925
            val = -val;
926
            sign = 1;
927
        }
928
        val--;
929
        code = (val >> bit_size) + 1;
930
        bits = val & (range - 1);
931

    
932
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
933
        if (bit_size > 0) {
934
            put_bits(&s->pb, bit_size, bits);
935
        }
936
    }
937
}
938

    
939
/* Encode MV differences on H.263+ with Unrestricted MV mode */
940
static void h263p_encode_umotion(MpegEncContext * s, int val)
941
{
942
    short sval = 0; 
943
    short i = 0;
944
    short n_bits = 0;
945
    short temp_val;
946
    int code = 0;
947
    int tcode;
948
    
949
    if ( val == 0)
950
        put_bits(&s->pb, 1, 1);
951
    else if (val == 1)
952
        put_bits(&s->pb, 3, 0);
953
    else if (val == -1)
954
        put_bits(&s->pb, 3, 2);
955
    else {
956
        
957
        sval = ((val < 0) ? (short)(-val):(short)val);
958
        temp_val = sval;
959
        
960
        while (temp_val != 0) {
961
            temp_val = temp_val >> 1;
962
            n_bits++;
963
        }
964
        
965
        i = n_bits - 1;
966
        while (i > 0) {
967
            tcode = (sval & (1 << (i-1))) >> (i-1);
968
            tcode = (tcode << 1) | 1;
969
            code = (code << 2) | tcode;
970
            i--;
971
        }
972
        code = ((code << 1) | (val < 0)) << 1;
973
        put_bits(&s->pb, (2*n_bits)+1, code);
974
        //printf("\nVal = %d\tCode = %d", sval, code);
975
    }
976
}
977

    
978
static void init_mv_penalty_and_fcode(MpegEncContext *s)
979
{
980
    int f_code;
981
    int mv;
982
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
983
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
984
            int len;
985

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

    
990
                bit_size = s->f_code - 1;
991
                range = 1 << bit_size;
992

    
993
                val=mv;
994
                if (val < 0) 
995
                    val = -val;
996
                val--;
997
                code = (val >> bit_size) + 1;
998
                if(code<33){
999
                    len= mvtab[code][1] + 1 + bit_size;
1000
                }else{
1001
                    len= mvtab[32][1] + 2 + bit_size;
1002
                }
1003
            }
1004

    
1005
            mv_penalty[f_code][mv+MAX_MV]= len;
1006
        }
1007
    }
1008

    
1009
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1010
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1011
            fcode_tab[mv+MAX_MV]= f_code;
1012
        }
1013
    }
1014

    
1015
    for(mv=0; mv<MAX_MV*2+1; mv++){
1016
        umv_fcode_tab[mv]= 1;
1017
    }
1018
}
1019

    
1020
static void init_uni_dc_tab()
1021
{
1022
    int level, uni_code, uni_len;
1023

    
1024
    for(level=-256; level<256; level++){
1025
        int size, v, l;
1026
        /* find number of bits */
1027
        size = 0;
1028
        v = abs(level);
1029
        while (v) {
1030
            v >>= 1;
1031
            size++;
1032
        }
1033

    
1034
        if (level < 0)
1035
            l= (-level) ^ ((1 << size) - 1);
1036
        else
1037
            l= level;
1038

    
1039
        /* luminance */
1040
        uni_code= DCtab_lum[size][0];
1041
        uni_len = DCtab_lum[size][1];
1042

    
1043
        if (size > 0) {
1044
            uni_code<<=size; uni_code|=l;
1045
            uni_len+=size;
1046
            if (size > 8){
1047
                uni_code<<=1; uni_code|=1;
1048
                uni_len++;
1049
            }
1050
        }
1051
        uni_DCtab_lum[level+256][0]= uni_code;
1052
        uni_DCtab_lum[level+256][1]= uni_len;
1053

    
1054
        /* chrominance */
1055
        uni_code= DCtab_chrom[size][0];
1056
        uni_len = DCtab_chrom[size][1];
1057
        
1058
        if (size > 0) {
1059
            uni_code<<=size; uni_code|=l;
1060
            uni_len+=size;
1061
            if (size > 8){
1062
                uni_code<<=1; uni_code|=1;
1063
                uni_len++;
1064
            }
1065
        }
1066
        uni_DCtab_chrom[level+256][0]= uni_code;
1067
        uni_DCtab_chrom[level+256][1]= uni_len;
1068

    
1069
    }
1070
}
1071

    
1072
void h263_encode_init(MpegEncContext *s)
1073
{
1074
    static int done = 0;
1075

    
1076
    if (!done) {
1077
        done = 1;
1078

    
1079
        init_uni_dc_tab();
1080

    
1081
        init_rl(&rl_inter);
1082
        init_rl(&rl_intra);
1083
        init_rl(&rl_intra_aic);
1084

    
1085
        init_mv_penalty_and_fcode(s);
1086
    }
1087
    s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1088
    
1089
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1090
    switch(s->codec_id){
1091
    case CODEC_ID_MPEG4:
1092
        s->fcode_tab= fcode_tab;
1093
        s->min_qcoeff= -2048;
1094
        s->max_qcoeff=  2047;
1095
        break;
1096
    case CODEC_ID_H263P:
1097
        s->fcode_tab= umv_fcode_tab;
1098
        s->min_qcoeff= -128;
1099
        s->max_qcoeff=  127;
1100
        break;
1101
    default: //nothing needed default table allready set in mpegvideo.c
1102
        s->min_qcoeff= -128;
1103
        s->max_qcoeff=  127;
1104
    }
1105

    
1106
    /* h263 type bias */
1107
    //FIXME mpeg4 mpeg quantizer    
1108
    s->intra_quant_bias=0;
1109
    s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1110
}
1111

    
1112
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1113
{
1114
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1115
    RLTable *rl;
1116

    
1117
    rl = &rl_inter;
1118
    if (s->mb_intra && !s->h263_aic) {
1119
        /* DC coef */
1120
            level = block[0];
1121
        /* 255 cannot be represented, so we clamp */
1122
        if (level > 254) {
1123
            level = 254;
1124
            block[0] = 254;
1125
        }
1126
        /* 0 cannot be represented also */
1127
        else if (!level) {
1128
            level = 1;
1129
            block[0] = 1;
1130
        }
1131
            if (level == 128)
1132
                put_bits(&s->pb, 8, 0xff);
1133
            else
1134
                put_bits(&s->pb, 8, level & 0xff);
1135
            i = 1;
1136
    } else {
1137
            i = 0;
1138
            if (s->h263_aic && s->mb_intra)
1139
                rl = &rl_intra_aic;
1140
    }
1141
   
1142
    /* AC coefs */
1143
    last_index = s->block_last_index[n];
1144
    last_non_zero = i - 1;
1145
    for (; i <= last_index; i++) {
1146
        j = zigzag_direct[i];
1147
        level = block[j];
1148
        if (level) {
1149
            run = i - last_non_zero - 1;
1150
            last = (i == last_index);
1151
            sign = 0;
1152
            slevel = level;
1153
            if (level < 0) {
1154
                sign = 1;
1155
                level = -level;
1156
            }
1157
            code = get_rl_index(rl, last, run, level);
1158
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1159
            if (code == rl->n) {
1160
                put_bits(&s->pb, 1, last);
1161
                put_bits(&s->pb, 6, run);
1162
                put_bits(&s->pb, 8, slevel & 0xff);
1163
            } else {
1164
                put_bits(&s->pb, 1, sign);
1165
            }
1166
                last_non_zero = i;
1167
            }
1168
    }
1169
}
1170

    
1171
/***************************************************/
1172

    
1173
void ff_mpeg4_stuffing(PutBitContext * pbc)
1174
{
1175
    int length;
1176
    put_bits(pbc, 1, 0);
1177
    length= (-get_bit_count(pbc))&7;
1178
    if(length) put_bits(pbc, length, (1<<length)-1);
1179
}
1180

    
1181
/* must be called before writing the header */
1182
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1183
    int time_div, time_mod;
1184

    
1185
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1186
        s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1187
        if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1188

    
1189
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1190
    }
1191

    
1192
    s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1193
    time_div= s->time/s->time_increment_resolution;
1194
    time_mod= s->time%s->time_increment_resolution;
1195

    
1196
    if(s->pict_type==B_TYPE){
1197
        s->bp_time= s->last_non_b_time - s->time;
1198
    }else{
1199
        s->last_time_base= s->time_base;
1200
        s->time_base= time_div;
1201
        s->pp_time= s->time - s->last_non_b_time;
1202
        s->last_non_b_time= s->time;
1203
    }
1204
}
1205

    
1206
static void mpeg4_encode_vol_header(MpegEncContext * s)
1207
{
1208
    int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1209
    char buf[255];
1210

    
1211
    s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
1212

    
1213
    put_bits(&s->pb, 16, 0);
1214
    put_bits(&s->pb, 16, 0x100);        /* video obj */
1215
    put_bits(&s->pb, 16, 0);
1216
    put_bits(&s->pb, 16, 0x120);        /* video obj layer */
1217

    
1218
    put_bits(&s->pb, 1, 0);                /* random access vol */
1219
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1220
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1221
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1222
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1223
    if(s->aspect_ratio_info) 
1224
        put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1225
    else
1226
        put_bits(&s->pb, 4, 1);                /* aspect ratio info= sqare pixel */
1227

    
1228
    if(s->low_delay){
1229
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1230
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1231
        put_bits(&s->pb, 1, s->low_delay);
1232
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1233
    }else{
1234
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1235
    }
1236

    
1237
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1238
    put_bits(&s->pb, 1, 1);                /* marker bit */
1239
    
1240
    put_bits(&s->pb, 16, s->time_increment_resolution);
1241
    if (s->time_increment_bits < 1)
1242
        s->time_increment_bits = 1;
1243
    put_bits(&s->pb, 1, 1);                /* marker bit */
1244
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1245
    put_bits(&s->pb, 1, 1);                /* marker bit */
1246
    put_bits(&s->pb, 13, s->width);        /* vol width */
1247
    put_bits(&s->pb, 1, 1);                /* marker bit */
1248
    put_bits(&s->pb, 13, s->height);        /* vol height */
1249
    put_bits(&s->pb, 1, 1);                /* marker bit */
1250
    put_bits(&s->pb, 1, 0);                /* interlace */
1251
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1252
    if (vo_ver_id == 1) {
1253
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1254
    }else{ /* vo_ver_id == 2 */
1255
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1256
    }
1257
    put_bits(&s->pb, 1, 0);                /* not 8 bit */
1258
    put_bits(&s->pb, 1, 0);                /* quant type= h263 style*/
1259
    if (vo_ver_id != 1)
1260
        put_bits(&s->pb, 1, s->quarter_sample=0);
1261
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1262
    s->resync_marker= s->rtp_mode;
1263
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1264
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1265
    if(s->data_partitioning){
1266
        put_bits(&s->pb, 1, 0);                /* no rvlc */
1267
    }
1268

    
1269
    if (vo_ver_id != 1){
1270
        put_bits(&s->pb, 1, 0);                /* newpred */
1271
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1272
    }
1273
    put_bits(&s->pb, 1, 0);                /* scalability */
1274

    
1275
    ff_mpeg4_stuffing(&s->pb);
1276
    put_bits(&s->pb, 16, 0);
1277
    put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1278
    sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1279
    put_string(&s->pb, buf);
1280

    
1281
    ff_mpeg4_stuffing(&s->pb);
1282
}
1283

    
1284
/* write mpeg4 VOP header */
1285
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1286
{
1287
    int time_incr;
1288
    int time_div, time_mod;
1289
    
1290
    if(s->pict_type==I_TYPE){
1291
        s->no_rounding=0;
1292
        if(picture_number==0 || !s->strict_std_compliance)
1293
            mpeg4_encode_vol_header(s);
1294
    }
1295
    
1296
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1297
    
1298
    put_bits(&s->pb, 16, 0);                /* vop header */
1299
    put_bits(&s->pb, 16, 0x1B6);        /* vop header */
1300
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1301

    
1302
    time_div= s->time/s->time_increment_resolution;
1303
    time_mod= s->time%s->time_increment_resolution;
1304
    time_incr= time_div - s->last_time_base;
1305
    while(time_incr--)
1306
        put_bits(&s->pb, 1, 1);
1307
        
1308
    put_bits(&s->pb, 1, 0);
1309

    
1310
    put_bits(&s->pb, 1, 1);        /* marker */
1311
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1312
    put_bits(&s->pb, 1, 1);        /* marker */
1313
    put_bits(&s->pb, 1, 1);        /* vop coded */
1314
    if (    s->pict_type == P_TYPE 
1315
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1316
        s->no_rounding ^= 1;
1317
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1318
    }
1319
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1320
    //FIXME sprite stuff
1321

    
1322
    put_bits(&s->pb, 5, s->qscale);
1323

    
1324
    if (s->pict_type != I_TYPE)
1325
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1326
    if (s->pict_type == B_TYPE)
1327
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1328
    //    printf("****frame %d\n", picture_number);
1329
}
1330

    
1331
void h263_dc_scale(MpegEncContext * s)
1332
{
1333
#if 1
1334
    const static UINT8 y_tab[32]={
1335
    //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
1336
        0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46
1337
    };
1338
    const static UINT8 c_tab[32]={
1339
    //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
1340
        0, 8, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,20,21,22,23,24,25
1341
    };
1342
    s->y_dc_scale = y_tab[s->qscale];
1343
    s->c_dc_scale = c_tab[s->qscale];
1344
#else
1345
    int quant;
1346
    quant = s->qscale;
1347
    /* luminance */
1348
    if (quant < 5)
1349
        s->y_dc_scale = 8;
1350
    else if (quant > 4 && quant < 9)
1351
        s->y_dc_scale = (2 * quant);
1352
    else if (quant > 8 && quant < 25)
1353
        s->y_dc_scale = (quant + 8);
1354
    else
1355
        s->y_dc_scale = (2 * quant - 16);
1356
    /* chrominance */
1357
    if (quant < 5)
1358
        s->c_dc_scale = 8;
1359
    else if (quant > 4 && quant < 25)
1360
        s->c_dc_scale = ((quant + 13) / 2);
1361
    else
1362
        s->c_dc_scale = (quant - 6);
1363
#endif
1364
}
1365

    
1366
static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1367
{
1368
    int a, b, c, wrap, pred, scale;
1369
    UINT16 *dc_val;
1370
    int dummy;
1371

    
1372
    /* find prediction */
1373
    if (n < 4) {
1374
        scale = s->y_dc_scale;
1375
    } else {
1376
        scale = s->c_dc_scale;
1377
    }
1378
    wrap= s->block_wrap[n];
1379
    dc_val = s->dc_val[0] + s->block_index[n];
1380

    
1381
    /* B C
1382
     * A X 
1383
     */
1384
    a = dc_val[ - 1];
1385
    b = dc_val[ - 1 - wrap];
1386
    c = dc_val[ - wrap];
1387

    
1388
    if (abs(a - b) < abs(b - c)) {
1389
        pred = c;
1390
        *dir_ptr = 1; /* top */
1391
    } else {
1392
        pred = a;
1393
        *dir_ptr = 0; /* left */
1394
    }
1395
    /* we assume pred is positive */
1396
#ifdef ARCH_X86
1397
        asm volatile (
1398
                "xorl %%edx, %%edx        \n\t"
1399
                "mul %%ecx                \n\t"
1400
                : "=d" (pred), "=a"(dummy)
1401
                : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1402
        );
1403
#else
1404
    pred = (pred + (scale >> 1)) / scale;
1405
#endif
1406

    
1407
    /* prepare address for prediction update */
1408
    *dc_val_ptr = &dc_val[0];
1409

    
1410
    return pred;
1411
}
1412

    
1413
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1414
                   int dir)
1415
{
1416
    int i;
1417
    INT16 *ac_val, *ac_val1;
1418

    
1419
    /* find prediction */
1420
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1421
    ac_val1 = ac_val;
1422
    if (s->ac_pred) {
1423
        if (dir == 0) {
1424
            /* left prediction */
1425
            ac_val -= 16;
1426
            for(i=1;i<8;i++) {
1427
                block[block_permute_op(i*8)] += ac_val[i];
1428
            }
1429
        } else {
1430
            /* top prediction */
1431
            ac_val -= 16 * s->block_wrap[n];
1432
            for(i=1;i<8;i++) {
1433
                block[block_permute_op(i)] += ac_val[i + 8];
1434
            }
1435
        }
1436
    }
1437
    /* left copy */
1438
    for(i=1;i<8;i++)
1439
        ac_val1[i] = block[block_permute_op(i * 8)];
1440
    /* top copy */
1441
    for(i=1;i<8;i++)
1442
        ac_val1[8 + i] = block[block_permute_op(i)];
1443
}
1444

    
1445
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1446
                              int dir)
1447
{
1448
    int i;
1449
    INT16 *ac_val;
1450

    
1451
    /* find prediction */
1452
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1453
 
1454
    if (dir == 0) {
1455
        /* left prediction */
1456
        ac_val -= 16;
1457
        for(i=1;i<8;i++) {
1458
            block[block_permute_op(i*8)] -= ac_val[i];
1459
        }
1460
    } else {
1461
        /* top prediction */
1462
        ac_val -= 16 * s->block_wrap[n];
1463
        for(i=1;i<8;i++) {
1464
            block[block_permute_op(i)] -= ac_val[i + 8];
1465
        }
1466
    }
1467
}
1468

    
1469
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1470
{
1471
#if 1
1472
//    if(level<-255 || level>255) printf("dc overflow\n");
1473
    level+=256;
1474
    if (n < 4) {
1475
        /* luminance */
1476
        put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1477
    } else {
1478
        /* chrominance */
1479
        put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1480
    }
1481
#else
1482
    int size, v;
1483
    /* find number of bits */
1484
    size = 0;
1485
    v = abs(level);
1486
    while (v) {
1487
        v >>= 1;
1488
        size++;
1489
    }
1490

    
1491
    if (n < 4) {
1492
        /* luminance */
1493
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1494
    } else {
1495
        /* chrominance */
1496
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1497
    }
1498

    
1499
    /* encode remaining bits */
1500
    if (size > 0) {
1501
        if (level < 0)
1502
            level = (-level) ^ ((1 << size) - 1);
1503
        put_bits(&s->pb, size, level);
1504
        if (size > 8)
1505
            put_bits(&s->pb, 1, 1);
1506
    }
1507
#endif
1508
}
1509

    
1510
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
1511
                               UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
1512
{
1513
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1514
    int code;
1515
    const RLTable *rl;
1516

    
1517
    if (s->mb_intra) {
1518
        /* mpeg4 based DC predictor */
1519
        mpeg4_encode_dc(dc_pb, intra_dc, n);
1520
        i = 1;
1521
        rl = &rl_intra;
1522
    } else {
1523
        i = 0;
1524
        rl = &rl_inter;
1525
    }
1526

    
1527
    /* AC coefs */
1528
    last_index = s->block_last_index[n];
1529
    last_non_zero = i - 1;
1530
    for (; i <= last_index; i++) {
1531
        j = scan_table[i];
1532
        level = block[j];
1533
        if (level) {
1534
            run = i - last_non_zero - 1;
1535
            last = (i == last_index);
1536
            sign = 0;
1537
            slevel = level;
1538
            if (level < 0) {
1539
                sign = 1;
1540
                level = -level;
1541
            }
1542
            code = get_rl_index(rl, last, run, level);
1543
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1544
            if (code == rl->n) {
1545
                int level1, run1;
1546
                level1 = level - rl->max_level[last][run];
1547
                if (level1 < 1) 
1548
                    goto esc2;
1549
                code = get_rl_index(rl, last, run, level1);
1550
                if (code == rl->n) {
1551
                esc2:
1552
                    put_bits(ac_pb, 1, 1);
1553
                    if (level > MAX_LEVEL)
1554
                        goto esc3;
1555
                    run1 = run - rl->max_run[last][level] - 1;
1556
                    if (run1 < 0)
1557
                        goto esc3;
1558
                    code = get_rl_index(rl, last, run1, level);
1559
                    if (code == rl->n) {
1560
                    esc3:
1561
                        /* third escape */
1562
                        put_bits(ac_pb, 1, 1);
1563
                        put_bits(ac_pb, 1, last);
1564
                        put_bits(ac_pb, 6, run);
1565
                        put_bits(ac_pb, 1, 1);
1566
                        put_bits(ac_pb, 12, slevel & 0xfff);
1567
                        put_bits(ac_pb, 1, 1);
1568
                    } else {
1569
                        /* second escape */
1570
                        put_bits(ac_pb, 1, 0);
1571
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1572
                        put_bits(ac_pb, 1, sign);
1573
                    }
1574
                } else {
1575
                    /* first escape */
1576
                    put_bits(ac_pb, 1, 0);
1577
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1578
                    put_bits(ac_pb, 1, sign);
1579
                }
1580
            } else {
1581
                put_bits(ac_pb, 1, sign);
1582
            }
1583
            last_non_zero = i;
1584
        }
1585
    }
1586
}
1587

    
1588

    
1589

    
1590
/***********************************************/
1591
/* decoding */
1592

    
1593
static VLC intra_MCBPC_vlc;
1594
static VLC inter_MCBPC_vlc;
1595
static VLC cbpy_vlc;
1596
static VLC mv_vlc;
1597
static VLC dc_lum, dc_chrom;
1598
static VLC sprite_trajectory;
1599
static VLC mb_type_b_vlc;
1600

    
1601
void init_rl(RLTable *rl)
1602
{
1603
    INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1604
    UINT8 index_run[MAX_RUN+1];
1605
    int last, run, level, start, end, i;
1606

    
1607
    /* compute max_level[], max_run[] and index_run[] */
1608
    for(last=0;last<2;last++) {
1609
        if (last == 0) {
1610
            start = 0;
1611
            end = rl->last;
1612
        } else {
1613
            start = rl->last;
1614
            end = rl->n;
1615
        }
1616

    
1617
        memset(max_level, 0, MAX_RUN + 1);
1618
        memset(max_run, 0, MAX_LEVEL + 1);
1619
        memset(index_run, rl->n, MAX_RUN + 1);
1620
        for(i=start;i<end;i++) {
1621
            run = rl->table_run[i];
1622
            level = rl->table_level[i];
1623
            if (index_run[run] == rl->n)
1624
                index_run[run] = i;
1625
            if (level > max_level[run])
1626
                max_level[run] = level;
1627
            if (run > max_run[level])
1628
                max_run[level] = run;
1629
        }
1630
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
1631
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1632
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1633
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1634
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
1635
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1636
    }
1637
}
1638

    
1639
void init_vlc_rl(RLTable *rl)
1640
{
1641
    init_vlc(&rl->vlc, 9, rl->n + 1, 
1642
             &rl->table_vlc[0][1], 4, 2,
1643
             &rl->table_vlc[0][0], 4, 2);
1644
}
1645

    
1646
/* init vlcs */
1647

    
1648
/* XXX: find a better solution to handle static init */
1649
void h263_decode_init_vlc(MpegEncContext *s)
1650
{
1651
    static int done = 0;
1652

    
1653
    if (!done) {
1654
        done = 1;
1655

    
1656
        init_vlc(&intra_MCBPC_vlc, 6, 8, 
1657
                 intra_MCBPC_bits, 1, 1,
1658
                 intra_MCBPC_code, 1, 1);
1659
        init_vlc(&inter_MCBPC_vlc, 9, 25, 
1660
                 inter_MCBPC_bits, 1, 1,
1661
                 inter_MCBPC_code, 1, 1);
1662
        init_vlc(&cbpy_vlc, 6, 16,
1663
                 &cbpy_tab[0][1], 2, 1,
1664
                 &cbpy_tab[0][0], 2, 1);
1665
        init_vlc(&mv_vlc, 9, 33,
1666
                 &mvtab[0][1], 2, 1,
1667
                 &mvtab[0][0], 2, 1);
1668
        init_rl(&rl_inter);
1669
        init_rl(&rl_intra);
1670
        init_rl(&rl_intra_aic);
1671
        init_vlc_rl(&rl_inter);
1672
        init_vlc_rl(&rl_intra);
1673
        init_vlc_rl(&rl_intra_aic);
1674
        init_vlc(&dc_lum, 9, 13,
1675
                 &DCtab_lum[0][1], 2, 1,
1676
                 &DCtab_lum[0][0], 2, 1);
1677
        init_vlc(&dc_chrom, 9, 13,
1678
                 &DCtab_chrom[0][1], 2, 1,
1679
                 &DCtab_chrom[0][0], 2, 1);
1680
        init_vlc(&sprite_trajectory, 9, 15,
1681
                 &sprite_trajectory_tab[0][1], 4, 2,
1682
                 &sprite_trajectory_tab[0][0], 4, 2);
1683
        init_vlc(&mb_type_b_vlc, 4, 4,
1684
                 &mb_type_b_tab[0][1], 2, 1,
1685
                 &mb_type_b_tab[0][0], 2, 1);
1686
    }
1687
}
1688

    
1689
int h263_decode_gob_header(MpegEncContext *s)
1690
{
1691
    unsigned int val, gfid;
1692
    
1693
    /* Check for GOB Start Code */
1694
    val = show_bits(&s->gb, 16);
1695
    if (val == 0) {
1696
        /* We have a GBSC probably with GSTUFF */
1697
        skip_bits(&s->gb, 16); /* Drop the zeros */
1698
        while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1699
#ifdef DEBUG
1700
        fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1701
#endif
1702
        s->gob_number = get_bits(&s->gb, 5); /* GN */
1703
        gfid = get_bits(&s->gb, 2); /* GFID */
1704
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1705
#ifdef DEBUG
1706
        fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1707
#endif
1708
        return 1;
1709
    }
1710
    return 0;
1711
            
1712
}
1713

    
1714
static inline void memsetw(short *tab, int val, int n)
1715
{
1716
    int i;
1717
    for(i=0;i<n;i++)
1718
        tab[i] = val;
1719
}
1720

    
1721
void ff_mpeg4_init_partitions(MpegEncContext *s)
1722
{
1723
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
1724
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
1725
}
1726

    
1727
void ff_mpeg4_merge_partitions(MpegEncContext *s)
1728
{
1729
    const int pb2_len   = get_bit_count(&s->pb2   );
1730
    const int tex_pb_len= get_bit_count(&s->tex_pb);
1731
    const int bits= get_bit_count(&s->pb);
1732

    
1733
    if(s->pict_type==I_TYPE){
1734
        put_bits(&s->pb, 19, DC_MARKER);
1735
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
1736
        s->i_tex_bits+= tex_pb_len;
1737
    }else{
1738
        put_bits(&s->pb, 17, MOTION_MARKER);
1739
        s->misc_bits+=17 + pb2_len;;
1740
        s->mv_bits+= bits - s->last_bits;
1741
        s->p_tex_bits+= tex_pb_len;
1742
    }
1743

    
1744
    flush_put_bits(&s->pb2);
1745
    flush_put_bits(&s->tex_pb);
1746

    
1747
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
1748
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
1749
    s->last_bits= get_bit_count(&s->pb);
1750
}
1751

    
1752
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
1753
{
1754
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1755

    
1756
    ff_mpeg4_stuffing(&s->pb);
1757
    if(s->pict_type==I_TYPE)
1758
        put_bits(&s->pb, 16, 0);
1759
    else if(s->pict_type==B_TYPE)
1760
        put_bits(&s->pb, MAX(MAX(s->f_code, s->b_code)+15, 17), 0);
1761
    else /* S/P_TYPE */
1762
        put_bits(&s->pb, s->f_code+15, 0);
1763
    put_bits(&s->pb, 1, 1);
1764
    
1765
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
1766
    put_bits(&s->pb, 5, s->qscale);
1767
    put_bits(&s->pb, 1, 0); /* no HEC */
1768
}
1769

    
1770
/**
1771
 * decodes the next video packet and sets s->next_qscale 
1772
 * returns mb_num of the next packet or <0 if something went wrong
1773
 */
1774
static int decode_video_packet_header(MpegEncContext *s, GetBitContext *gb)
1775
{
1776
    int bits;
1777
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1778
    int header_extension=0, mb_num;
1779
//printf("%X\n", show_bits(&gb, 24));
1780
//printf("parse_video_packet_header\n");
1781
//    if(show_aligned_bits(gb, 1, 16) != 0) return -1;
1782
    
1783
    /* is there enough space left for a video packet + header */
1784
    if( get_bits_count(gb) > gb->size*8-20) return -1;
1785

    
1786
//printf("resync at %d %d\n", s->mb_x, s->mb_y);
1787
//    skip_bits(gb, 1);
1788
//    align_get_bits(gb);
1789
    if(get_bits(gb, 16)!=0){
1790
        printf("internal error while decoding video packet header\n");
1791
    }
1792

    
1793
//printf("%X\n", show_bits(gb, 24));
1794
    bits=0;
1795
    while(!get_bits1(gb) && bits<30) bits++;
1796
    if((s->pict_type == P_TYPE || s->pict_type == S_TYPE) && bits != s->f_code-1){
1797
        printf("marker does not match f_code (is: %d should be: %d pos: %d end %d x: %d y: %d)\n", 
1798
               bits+1, s->f_code, get_bits_count(gb), gb->size*8, s->mb_x, s->mb_y);
1799
        return -1;
1800
    }else if(s->pict_type == I_TYPE && bits != 0){
1801
        printf("marker too long\n");
1802
        return -1;
1803
    }else if(s->pict_type == B_TYPE && bits != MAX(MAX(s->f_code, s->b_code)-1, 1)){
1804
        printf("marker does not match f/b_code\n");
1805
        return -1;
1806
    }
1807
//printf("%X\n", show_bits(gb, 24));
1808

    
1809
    if(s->shape != RECT_SHAPE){
1810
        header_extension= get_bits1(gb);
1811
        //FIXME more stuff here
1812
    }
1813

    
1814
    mb_num= get_bits(gb, mb_num_bits);
1815
    if(mb_num < s->mb_x + s->mb_y*s->mb_width || mb_num>=s->mb_num){
1816
        fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_x + s->mb_y*s->mb_width);
1817
        return -1;
1818
    }
1819

    
1820
    if(s->shape != BIN_ONLY_SHAPE){
1821
        s->next_resync_qscale= get_bits(gb, 5);
1822
        if(s->next_resync_qscale==0)
1823
            s->next_resync_qscale= s->qscale;
1824
        if(s->next_resync_qscale==0){
1825
            fprintf(stderr, "qscale==0\n");
1826
            return -1;
1827
        }
1828
    }
1829

    
1830
    if(s->shape == RECT_SHAPE){
1831
        header_extension= get_bits1(gb);
1832
    }
1833
    if(header_extension){
1834
        int time_increment;
1835
        int time_incr=0;
1836
        printf("header extension not supported\n");
1837
        return -1;
1838

    
1839
        while (get_bits1(gb) != 0) 
1840
            time_incr++;
1841

    
1842
        check_marker(gb, "before time_increment in video packed header");
1843
        time_increment= get_bits(gb, s->time_increment_bits);
1844
        if(s->pict_type!=B_TYPE){
1845
            s->last_time_base= s->time_base;
1846
            s->time_base+= time_incr;
1847
            s->time= s->time_base*s->time_increment_resolution + time_increment;
1848
            s->pp_time= s->time - s->last_non_b_time;
1849
            s->last_non_b_time= s->time;
1850
        }else{
1851
            s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
1852
            s->bp_time= s->last_non_b_time - s->time;
1853
        }
1854
        check_marker(gb, "before vop_coding_type in video packed header");
1855
        
1856
        skip_bits(gb, 2); /* vop coding type */
1857
        //FIXME not rect stuff here
1858

    
1859
        if(s->shape != BIN_ONLY_SHAPE){
1860
            skip_bits(gb, 3); /* intra dc vlc threshold */
1861

    
1862
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
1863
                mpeg4_decode_sprite_trajectory(s);
1864
            }
1865

    
1866
            //FIXME reduced res stuff here
1867
            
1868
            if (s->pict_type != I_TYPE) {
1869
                s->f_code = get_bits(gb, 3);        /* fcode_for */
1870
                if(s->f_code==0){
1871
                    printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");
1872
                    return -1; // makes no sense to continue, as the MV decoding will break very quickly
1873
                }
1874
            }
1875
            if (s->pict_type == B_TYPE) {
1876
                s->b_code = get_bits(gb, 3);
1877
            }       
1878
        }
1879
    }
1880
    //FIXME new-pred stuff
1881
    
1882
//printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
1883

    
1884
    return mb_num;
1885
}
1886

    
1887
void ff_mpeg4_clean_buffers(MpegEncContext *s)
1888
{
1889
    int c_wrap, c_xy, l_wrap, l_xy;
1890

    
1891
    l_wrap= s->block_wrap[0];
1892
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
1893
    c_wrap= s->block_wrap[4];
1894
    c_xy= s->mb_y*c_wrap + s->mb_x;
1895

    
1896
    /* clean DC */
1897
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
1898
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
1899
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
1900

    
1901
    /* clean AC */
1902
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
1903
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
1904
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
1905

    
1906
    /* clean MV */
1907
    // we cant clear the MVs as they might be needed by a b frame
1908
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
1909
//    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
1910
    s->last_mv[0][0][0]=
1911
    s->last_mv[0][0][1]=
1912
    s->last_mv[1][0][0]=
1913
    s->last_mv[1][0][1]= 0;
1914
}
1915

    
1916
/* searches for the next resync marker clears ac,dc,mc, and sets s->next_resync_gb, s->mb_num_left */
1917
int ff_mpeg4_resync(MpegEncContext *s)
1918
{
1919
    GetBitContext gb;
1920
    
1921
    /* search & parse next resync marker */
1922
    
1923
    gb= s->next_resync_gb;
1924
    align_get_bits(&gb);
1925
//printf("mpeg4_resync %d next:%d \n", get_bits_count(&gb), get_bits_count(&s->next_resync_gb));
1926
    for(;;) {
1927
        int v= show_bits(&gb, 24);
1928
        if( get_bits_count(&gb) >= gb.size*8-24 || v == 1 /* start-code */){
1929
            s->mb_num_left= s->mb_num - s->mb_x - s->mb_y*s->mb_width;
1930
//printf("mpeg4_resync end\n");
1931
            s->gb= s->next_resync_gb; //continue at the next resync marker
1932
            return -1;
1933
        }else if(v>>8 == 0){
1934
            int next;
1935
            s->next_resync_pos= get_bits_count(&gb);
1936
            
1937
            next= decode_video_packet_header(s, &gb);
1938
            if(next >= 0){
1939
                s->mb_num_left= next - s->mb_x - s->mb_y*s->mb_width;
1940
                break;
1941
            }
1942

    
1943
            align_get_bits(&gb);
1944
        }
1945
        skip_bits(&gb, 8);
1946
    }
1947
    s->next_resync_gb=gb;
1948
    
1949
    return 0;
1950
}
1951

    
1952
static inline void init_block_index(MpegEncContext *s)
1953
{
1954
    s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
1955
    s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
1956
    s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
1957
    s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
1958
    s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
1959
    s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
1960
}
1961

    
1962
static inline void update_block_index(MpegEncContext *s)
1963
{
1964
    s->block_index[0]+=2;
1965
    s->block_index[1]+=2;
1966
    s->block_index[2]+=2;
1967
    s->block_index[3]+=2;
1968
    s->block_index[4]++;
1969
    s->block_index[5]++;
1970
}
1971

    
1972
/**
1973
 * decodes the first & second partition
1974
 * returns error type or 0 if no error
1975
 */
1976
int ff_mpeg4_decode_partitions(MpegEncContext *s)
1977
{
1978
    static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
1979
    int mb_num;
1980
    
1981
    /* decode first partition */
1982
    mb_num=0;
1983
    s->first_slice_line=1;
1984
    s->mb_x= s->resync_mb_x;
1985
    for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
1986
        init_block_index(s);
1987
        for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
1988
            const int xy= s->mb_x + s->mb_y*s->mb_width;
1989
            int cbpc;
1990
            int dir=0;
1991
            
1992
            mb_num++;
1993
            update_block_index(s);
1994
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
1995
                s->first_slice_line=0;
1996
            
1997
            if(s->mb_x==0) PRINT_MB_TYPE("\n");
1998

    
1999
            if(s->pict_type==I_TYPE){
2000
                int i;
2001

    
2002
                PRINT_MB_TYPE("I");
2003
                cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
2004
                if (cbpc < 0){
2005
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2006
                    return DECODING_DESYNC;
2007
                }
2008
                s->cbp_table[xy]= cbpc & 3;
2009
                s->mb_type[xy]= MB_TYPE_INTRA;
2010
                s->mb_intra = 1;
2011

    
2012
                if(cbpc & 4) {
2013
                    s->qscale += quant_tab[get_bits(&s->gb, 2)];
2014
                    if (s->qscale < 1)
2015
                        s->qscale = 1;
2016
                    else if (s->qscale > 31)
2017
                        s->qscale = 31;
2018
                    h263_dc_scale(s);
2019
                }
2020
                s->qscale_table[xy]= s->qscale;
2021

    
2022
                s->mbintra_table[xy]= 1;
2023
                for(i=0; i<6; i++){
2024
                    int dc_pred_dir;
2025
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2026
                    if(dc < 0){
2027
                        fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2028
                        return DECODING_DESYNC;
2029
                    }
2030
                    dir<<=1;
2031
                    if(dc_pred_dir) dir|=1;
2032
                }
2033
                s->pred_dir_table[xy]= dir;
2034
            }else{ /* P/S_TYPE */
2035
                int mx, my, pred_x, pred_y;
2036
                INT16 * const mot_val= s->motion_val[s->block_index[0]];
2037
                const int stride= s->block_wrap[0]*2;
2038

    
2039
                if(get_bits1(&s->gb)){
2040
                    /* skip mb */
2041
                    s->mb_type[xy]= MB_TYPE_SKIPED;
2042
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2043
                        const int a= s->sprite_warping_accuracy;
2044
                        PRINT_MB_TYPE("G");
2045
                        if(s->divx_version==500 && s->divx_build==413){
2046
                            mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2047
                            my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2048
                        }else{
2049
                            mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2050
                            my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2051
                            s->mb_type[xy]= MB_TYPE_GMC | MB_TYPE_SKIPED;
2052
                        }
2053
                    }else{
2054
                        PRINT_MB_TYPE("S");
2055
                        mx = 0;
2056
                        my = 0;
2057
                    }
2058
                    mot_val[0       ]= mot_val[2       ]=
2059
                    mot_val[0+stride]= mot_val[2+stride]= mx;
2060
                    mot_val[1       ]= mot_val[3       ]=
2061
                    mot_val[1+stride]= mot_val[3+stride]= my;
2062

    
2063
                    if(s->mbintra_table[xy])
2064
                        ff_clean_intra_table_entries(s);
2065

    
2066
                    continue;
2067
                }
2068
                cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
2069
                if (cbpc < 0){
2070
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2071
                    return DECODING_DESYNC;
2072
                }
2073
                if (cbpc > 20)
2074
                    cbpc+=3;
2075
                else if (cbpc == 20)
2076
                    fprintf(stderr, "Stuffing !");
2077
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2078
    
2079
                s->mb_intra = ((cbpc & 4) != 0);
2080
        
2081
                if(s->mb_intra){
2082
                    PRINT_MB_TYPE("I");
2083
                    s->mbintra_table[xy]= 1;
2084
                    s->mb_type[xy]= MB_TYPE_INTRA;
2085
                    mot_val[0       ]= mot_val[2       ]= 
2086
                    mot_val[0+stride]= mot_val[2+stride]= 0;
2087
                    mot_val[1       ]= mot_val[3       ]=
2088
                    mot_val[1+stride]= mot_val[3+stride]= 0;
2089
                }else{
2090
                    if(s->mbintra_table[xy])
2091
                        ff_clean_intra_table_entries(s);
2092

    
2093
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2094
                        s->mcsel= get_bits1(&s->gb);
2095
                    else s->mcsel= 0;
2096
        
2097
                    if ((cbpc & 16) == 0) {
2098
                        PRINT_MB_TYPE("P");
2099
                        /* 16x16 motion prediction */
2100
                        s->mb_type[xy]= MB_TYPE_INTER;
2101

    
2102
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
2103
                        if(!s->mcsel)
2104
                           mx = h263_decode_motion(s, pred_x, s->f_code);
2105
                        else {
2106
                            const int a= s->sprite_warping_accuracy;
2107
                            if(s->divx_version==500 && s->divx_build==413){
2108
                                mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2109
                            }else{
2110
                                mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2111
                            }
2112
                        }
2113
                        if (mx >= 0xffff)
2114
                            return DECODING_DESYNC;
2115
            
2116
                        if(!s->mcsel)
2117
                           my = h263_decode_motion(s, pred_y, s->f_code);
2118
                        else{
2119
                           const int a= s->sprite_warping_accuracy;
2120
                            if(s->divx_version==500 && s->divx_build==413){
2121
                                my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2122
                            }else{
2123
                                my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2124
                            }
2125
                        }
2126
                        if (my >= 0xffff)
2127
                            return DECODING_DESYNC;
2128
                        mot_val[0       ]= mot_val[2       ] =
2129
                        mot_val[0+stride]= mot_val[2+stride]= mx;
2130
                        mot_val[1       ]= mot_val[3       ]=
2131
                        mot_val[1+stride]= mot_val[3+stride]= my;
2132
                    } else {
2133
                        int i;
2134
                        PRINT_MB_TYPE("4");
2135
                        s->mb_type[xy]= MB_TYPE_INTER4V;
2136
                        for(i=0;i<4;i++) {
2137
                            INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2138
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2139
                            if (mx >= 0xffff)
2140
                                return DECODING_DESYNC;
2141
                
2142
                            my = h263_decode_motion(s, pred_y, s->f_code);
2143
                            if (my >= 0xffff)
2144
                                return DECODING_DESYNC;
2145
                            mot_val[0] = mx;
2146
                            mot_val[1] = my;
2147
                        }
2148
                    }
2149
                }
2150
            }
2151
        }
2152
        s->mb_x= 0;
2153
    }
2154

    
2155
    if     (s->pict_type==I_TYPE && get_bits(&s->gb, 19)!=DC_MARKER    ) s->decoding_error= DECODING_DESYNC;
2156
    else if(s->pict_type!=I_TYPE && get_bits(&s->gb, 17)!=MOTION_MARKER) s->decoding_error= DECODING_DESYNC;
2157
    if(s->decoding_error== DECODING_DESYNC){
2158
        fprintf(stderr, "marker missing after first partition at %d %d\n", s->mb_x, s->mb_y);
2159
        return DECODING_DESYNC;
2160
    }
2161

    
2162
    /* decode second partition */
2163
    mb_num=0;
2164
    s->mb_x= s->resync_mb_x;
2165
    for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
2166
        init_block_index(s);
2167
        for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
2168
            const int xy= s->mb_x + s->mb_y*s->mb_width;
2169

    
2170
            mb_num++;
2171
            update_block_index(s);
2172
            
2173
            if(s->pict_type==I_TYPE){
2174
                int ac_pred= get_bits1(&s->gb);
2175
                int cbpy = get_vlc(&s->gb, &cbpy_vlc);
2176
                if(cbpy<0){
2177
                    fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2178
                    return DECODING_AC_LOST;
2179
                }
2180
                
2181
                s->cbp_table[xy]|= cbpy<<2;
2182
                s->pred_dir_table[xy]|= ac_pred<<7;
2183
            }else{ /* P || S_TYPE */
2184
                if(s->mb_type[xy]&MB_TYPE_INTRA){          
2185
                    int dir=0,i;
2186
                    int ac_pred = get_bits1(&s->gb);
2187
                    int cbpy = get_vlc(&s->gb, &cbpy_vlc);
2188

    
2189
                    if(cbpy<0){
2190
                        fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2191
                        return DECODING_ACDC_LOST;
2192
                    }
2193
                    
2194
                    if(s->cbp_table[xy] & 8) {
2195
                        s->qscale += quant_tab[get_bits(&s->gb, 2)];
2196
                        if (s->qscale < 1)
2197
                            s->qscale = 1;
2198
                        else if (s->qscale > 31)
2199
                            s->qscale = 31;
2200
                        h263_dc_scale(s);
2201
                    }
2202
                    s->qscale_table[xy]= s->qscale;
2203

    
2204
                    for(i=0; i<6; i++){
2205
                        int dc_pred_dir;
2206
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2207
                        if(dc < 0){
2208
                            fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2209
                            return DECODING_ACDC_LOST;
2210
                        }
2211
                        dir<<=1;
2212
                        if(dc_pred_dir) dir|=1;
2213
                    }
2214
                    s->cbp_table[xy]&= 3; //remove dquant
2215
                    s->cbp_table[xy]|= cbpy<<2;
2216
                    s->pred_dir_table[xy]= dir | (ac_pred<<7);
2217
                }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
2218
                    s->qscale_table[xy]= s->qscale;
2219
                    s->cbp_table[xy]= 0;
2220
                }else{
2221
                    int cbpy = get_vlc(&s->gb, &cbpy_vlc);
2222

    
2223
                    if(cbpy<0){
2224
                        fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2225
                        return DECODING_ACDC_LOST;
2226
                    }
2227
                    
2228
                    if(s->cbp_table[xy] & 8) {
2229
//fprintf(stderr, "dquant\n");
2230
                        s->qscale += quant_tab[get_bits(&s->gb, 2)];
2231
                        if (s->qscale < 1)
2232
                            s->qscale = 1;
2233
                        else if (s->qscale > 31)
2234
                            s->qscale = 31;
2235
                        h263_dc_scale(s);
2236
                    }
2237
                    s->qscale_table[xy]= s->qscale;
2238

    
2239
                    s->cbp_table[xy]&= 3; //remove dquant
2240
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
2241
                }
2242
            }
2243
        }
2244
        s->mb_x= 0;
2245
    }
2246
    
2247

    
2248
    return 0;        
2249
}
2250

    
2251
static int mpeg4_decode_partitioned_mb(MpegEncContext *s,
2252
                   DCTELEM block[6][64])
2253
{
2254
    int cbp, mb_type;
2255
    const int xy= s->mb_x + s->mb_y*s->mb_width;
2256

    
2257
    if(s->mb_x==s->resync_mb_x && s->mb_y==s->resync_mb_y){ //Note resync_mb_{x,y}==0 at the start
2258
        int i;
2259
        int block_index_backup[6];
2260
        int qscale= s->qscale;
2261
        
2262
        for(i=0; i<6; i++) block_index_backup[i]= s->block_index[i];
2263
        
2264
        s->decoding_error= ff_mpeg4_decode_partitions(s);
2265
        
2266
        for(i=0; i<6; i++) s->block_index[i]= block_index_backup[i];
2267
        s->first_slice_line=1;
2268
        s->mb_x= s->resync_mb_x;
2269
        s->mb_y= s->resync_mb_y;
2270
        s->qscale= qscale;
2271
        h263_dc_scale(s);
2272

    
2273
        if(s->decoding_error==DECODING_DESYNC) return -1;
2274
    }
2275
    
2276
    mb_type= s->mb_type[xy];
2277
    if(s->decoding_error)
2278
        cbp=0;
2279
    else 
2280
        cbp = s->cbp_table[xy];
2281

    
2282
    if(s->decoding_error!=DECODING_ACDC_LOST && s->qscale_table[xy] != s->qscale){
2283
        s->qscale= s->qscale_table[xy];
2284
        h263_dc_scale(s);
2285
    }
2286

    
2287
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2288
        int i;
2289
        for(i=0; i<4; i++){
2290
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
2291
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
2292
        }
2293
        s->mb_intra = mb_type&MB_TYPE_INTRA;
2294

    
2295
        if (mb_type&MB_TYPE_SKIPED) {
2296
            /* skip mb */
2297
            for(i=0;i<6;i++)
2298
                s->block_last_index[i] = -1;
2299
            s->mv_dir = MV_DIR_FORWARD;
2300
            s->mv_type = MV_TYPE_16X16;
2301
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2302
                s->mcsel=1;
2303
                s->mb_skiped = 0;
2304
            }else{
2305
                s->mcsel=0;
2306
                s->mb_skiped = 1;
2307
            }
2308
            return 0;
2309
        }else if(s->mb_intra && s->decoding_error!=DECODING_ACDC_LOST){
2310
            s->ac_pred = s->pred_dir_table[xy]>>7;
2311

    
2312
            /* decode each block */
2313
            for (i = 0; i < 6; i++) {
2314
                int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
2315
                if(ret==DECODING_AC_LOST){
2316
                    fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2317
                    s->decoding_error=DECODING_AC_LOST;
2318
                    cbp=0;
2319
                }else if(ret==DECODING_ACDC_LOST){
2320
                    fprintf(stderr, "dc corrupted at %d %d (trying to continue with mc only)\n", s->mb_x, s->mb_y);
2321
                    s->decoding_error=DECODING_ACDC_LOST;
2322
                    break;
2323
                }
2324
            }
2325
        }else if(!s->mb_intra){
2326
//            s->mcsel= 0; //FIXME do we need to init that
2327
            
2328
            s->mv_dir = MV_DIR_FORWARD;
2329
            if (mb_type&MB_TYPE_INTER4V) {
2330
                s->mv_type = MV_TYPE_8X8;
2331
            } else {
2332
                s->mv_type = MV_TYPE_16X16;
2333
            }
2334
            if(s->decoding_error==0 && cbp){
2335
                /* decode each block */
2336
                for (i = 0; i < 6; i++) {
2337
                    int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
2338
                    if(ret==DECODING_AC_LOST){
2339
                        fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2340
                        s->decoding_error=DECODING_AC_LOST;
2341
                        break;
2342
                    }
2343
                }
2344
            }
2345
        }
2346
    } else { /* I-Frame */
2347
        int i;
2348
        s->mb_intra = 1;
2349
        s->ac_pred = s->pred_dir_table[xy]>>7;
2350
        
2351
        /* decode each block */
2352
        for (i = 0; i < 6; i++) {
2353
            int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
2354
            if(ret==DECODING_AC_LOST){
2355
                fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
2356
                s->decoding_error=DECODING_AC_LOST;
2357
                cbp=0;
2358
            }else if(ret==DECODING_ACDC_LOST){
2359
                fprintf(stderr, "dc corrupted at %d %d\n", s->mb_x, s->mb_y);
2360
                return -1;
2361
            }
2362
        }
2363
    }
2364

    
2365
    return 0;
2366
}
2367

    
2368

    
2369
int h263_decode_mb(MpegEncContext *s,
2370
                   DCTELEM block[6][64])
2371
{
2372
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
2373
    INT16 *mot_val;
2374
    static INT8 quant_tab[4] = { -1, -2, 1, 2 };
2375

    
2376
    if(s->mb_x==0) PRINT_MB_TYPE("\n")
2377

    
2378
    if(s->resync_marker){
2379
        if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
2380
            s->first_slice_line=0; 
2381
        }
2382
    }
2383

    
2384
    if(s->data_partitioning && s->pict_type!=B_TYPE)
2385
        return mpeg4_decode_partitioned_mb(s, block);
2386

    
2387
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2388
        if (get_bits1(&s->gb)) {
2389
            /* skip mb */
2390
            s->mb_intra = 0;
2391
            for(i=0;i<6;i++)
2392
                s->block_last_index[i] = -1;
2393
            s->mv_dir = MV_DIR_FORWARD;
2394
            s->mv_type = MV_TYPE_16X16;
2395
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2396
                const int a= s->sprite_warping_accuracy;
2397
//                int l = (1 << (s->f_code - 1)) * 32;
2398
                PRINT_MB_TYPE("G");
2399
                s->mcsel=1;
2400
                if(s->divx_version==500 && s->divx_build==413){
2401
                    s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2402
                    s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2403
                }else{
2404
                    s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2405
                    s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2406
                }
2407
/*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
2408
                else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
2409
                if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
2410
                else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
2411

    
2412
                s->mb_skiped = 0;
2413
            }else{
2414
                PRINT_MB_TYPE("S");
2415
                s->mcsel=0;
2416
                s->mv[0][0][0] = 0;
2417
                s->mv[0][0][1] = 0;
2418
                s->mb_skiped = 1;
2419
            }
2420
            return 0;
2421
        }
2422
        cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
2423
        //fprintf(stderr, "\tCBPC: %d", cbpc);
2424
        if (cbpc < 0)
2425
            return -1;
2426
        if (cbpc > 20)
2427
            cbpc+=3;
2428
        else if (cbpc == 20)
2429
            fprintf(stderr, "Stuffing !");
2430
        
2431
        dquant = cbpc & 8;
2432
        s->mb_intra = ((cbpc & 4) != 0);
2433
        if (s->mb_intra) goto intra;
2434
        
2435
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2436
            s->mcsel= get_bits1(&s->gb);
2437
        else s->mcsel= 0;
2438
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
2439
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
2440
        if (dquant) {
2441
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
2442
            if (s->qscale < 1)
2443
                s->qscale = 1;
2444
            else if (s->qscale > 31)
2445
                s->qscale = 31;
2446
            h263_dc_scale(s);
2447
        }
2448
        s->mv_dir = MV_DIR_FORWARD;
2449
        if ((cbpc & 16) == 0) {
2450
            PRINT_MB_TYPE("P");
2451
            /* 16x16 motion prediction */
2452
            s->mv_type = MV_TYPE_16X16;
2453
            h263_pred_motion(s, 0, &pred_x, &pred_y);
2454
            if (s->umvplus_dec)
2455
               mx = h263p_decode_umotion(s, pred_x);
2456
            else if(!s->mcsel)
2457
               mx = h263_decode_motion(s, pred_x, s->f_code);
2458
            else {
2459
               const int a= s->sprite_warping_accuracy;
2460
//        int l = (1 << (s->f_code - 1)) * 32;
2461
                if(s->divx_version==500 && s->divx_build==413){
2462
                    mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2463
                }else{
2464
                    mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2465
                }
2466
//        if (mx < -l) mx= -l, printf("C");
2467
//        else if (mx >= l) mx= l-1, printf("C");
2468
            }
2469
            if (mx >= 0xffff)
2470
                return -1;
2471
            
2472
            if (s->umvplus_dec)
2473
               my = h263p_decode_umotion(s, pred_y);
2474
            else if(!s->mcsel)
2475
               my = h263_decode_motion(s, pred_y, s->f_code);
2476
            else{
2477
               const int a= s->sprite_warping_accuracy;
2478
//       int l = (1 << (s->f_code - 1)) * 32;
2479
                if(s->divx_version==500 && s->divx_build==413){
2480
                    my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2481
                }else{
2482
                    my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2483
                }
2484
//       if (my < -l) my= -l, printf("C");
2485
//       else if (my >= l) my= l-1, printf("C");
2486
            }
2487
            if (my >= 0xffff)
2488
                return -1;
2489
            s->mv[0][0][0] = mx;
2490
            s->mv[0][0][1] = my;
2491
            /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
2492
            fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
2493
            fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
2494
            if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2495
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
2496
                           
2497
        } else {
2498
            PRINT_MB_TYPE("4");
2499
            s->mv_type = MV_TYPE_8X8;
2500
            for(i=0;i<4;i++) {
2501
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
2502
                if (s->umvplus_dec)
2503
                  mx = h263p_decode_umotion(s, pred_x);
2504
                else
2505
                  mx = h263_decode_motion(s, pred_x, s->f_code);
2506
                if (mx >= 0xffff)
2507
                    return -1;
2508
                
2509
                if (s->umvplus_dec)
2510
                  my = h263p_decode_umotion(s, pred_y);
2511
                else    
2512
                  my = h263_decode_motion(s, pred_y, s->f_code);
2513
                if (my >= 0xffff)
2514
                    return -1;
2515
                s->mv[0][i][0] = mx;
2516
                s->mv[0][i][1] = my;
2517
                if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2518
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
2519
                mot_val[0] = mx;
2520
                mot_val[1] = my;
2521
            }
2522
        }
2523
    } else if(s->pict_type==B_TYPE) {
2524
        int modb1; // first bit of modb
2525
        int modb2; // second bit of modb
2526
        int mb_type;
2527
        uint16_t time_pp;
2528
        uint16_t time_pb;
2529
        int xy;
2530

    
2531
        s->mb_intra = 0; //B-frames never contain intra blocks
2532
        s->mcsel=0;      //     ...               true gmc blocks
2533

    
2534
        if(s->mb_x==0){
2535
            s->last_mv[0][0][0]= 
2536
            s->last_mv[0][0][1]= 
2537
            s->last_mv[1][0][0]= 
2538
            s->last_mv[1][0][1]= 0;
2539
        }
2540

    
2541
        /* if we skipped it in the future P Frame than skip it now too */
2542
        s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
2543

    
2544
        if(s->mb_skiped){
2545
                /* skip mb */
2546
            for(i=0;i<6;i++)
2547
                s->block_last_index[i] = -1;
2548

    
2549
            s->mv_dir = MV_DIR_FORWARD;
2550
            s->mv_type = MV_TYPE_16X16;
2551
            s->mv[0][0][0] = 0;
2552
            s->mv[0][0][1] = 0;
2553
            s->mv[1][0][0] = 0;
2554
            s->mv[1][0][1] = 0;
2555
//FIXME is this correct?
2556
/*            s->last_mv[0][0][0]=
2557
            s->last_mv[0][0][1]=0;*/
2558
            PRINT_MB_TYPE("s")
2559
            return 0;
2560
        }
2561

    
2562
        modb1= get_bits1(&s->gb);
2563
        if(modb1==0){
2564
            modb2= get_bits1(&s->gb);
2565
            mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
2566
            if(modb2==0) cbp= get_bits(&s->gb, 6);
2567
            else cbp=0;
2568
            if (mb_type && cbp) {
2569
                if(get_bits1(&s->gb)){
2570
                    s->qscale +=get_bits1(&s->gb)*4 - 2;
2571
                    if (s->qscale < 1)
2572
                        s->qscale = 1;
2573
                    else if (s->qscale > 31)
2574
                        s->qscale = 31;
2575
                    h263_dc_scale(s);
2576
                }
2577
            }
2578
        }else{
2579
            mb_type=4; //like 0 but no vectors coded
2580
            cbp=0;
2581
        }
2582
        s->mv_type = MV_TYPE_16X16; // we'll switch to 8x8 only if the last P frame had 8x8 for this MB and mb_type=0 here
2583
        mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
2584
        switch(mb_type)
2585
        {
2586
        case 0: /* direct */
2587
            mx = h263_decode_motion(s, 0, 1);
2588
            my = h263_decode_motion(s, 0, 1);
2589
        case 4: /* direct with mx=my=0 */
2590
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2591
            xy= s->block_index[0];
2592
            time_pp= s->pp_time;
2593
            time_pb= time_pp - s->bp_time;
2594
//if(time_pp>3000 )printf("%d %d  ", time_pp, time_pb);
2595
            //FIXME 4MV
2596
            //FIXME avoid divides
2597
            s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
2598
            s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
2599
            s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
2600
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
2601
            s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
2602
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
2603
/*            s->mv[0][0][0] = 
2604
            s->mv[0][0][1] = 
2605
            s->mv[1][0][0] = 
2606
            s->mv[1][0][1] = 1000;*/
2607
            PRINT_MB_TYPE("D");
2608
            break;
2609
        case 1: 
2610
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2611
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
2612
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
2613
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
2614
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
2615

    
2616
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
2617
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
2618
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
2619
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
2620
            PRINT_MB_TYPE("i");
2621
            break;
2622
        case 2: 
2623
            s->mv_dir = MV_DIR_BACKWARD;
2624
            mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
2625
            my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
2626
            s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
2627
            s->last_mv[1][0][1]= s->mv[1][0][1] = my;
2628
            PRINT_MB_TYPE("B");
2629
            break;
2630
        case 3:
2631
            s->mv_dir = MV_DIR_FORWARD;
2632
            mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
2633
            my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
2634
            s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
2635
            s->last_mv[0][0][1]= s->mv[0][0][1] = my;
2636
            PRINT_MB_TYPE("F");
2637
            break;
2638
        default: 
2639
            printf("illegal MB_type\n");
2640
            return -1;
2641
        }
2642
    } else { /* I-Frame */
2643
        cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
2644
        if (cbpc < 0)
2645
            return -1;
2646
        dquant = cbpc & 4;
2647
        s->mb_intra = 1;
2648
intra:
2649
        PRINT_MB_TYPE("I");
2650
        s->ac_pred = 0;
2651
        if (s->h263_pred || s->h263_aic) {
2652
            s->ac_pred = get_bits1(&s->gb);
2653
            if (s->ac_pred && s->h263_aic)
2654
                s->h263_aic_dir = get_bits1(&s->gb);
2655
        }
2656
        if (s->h263_aic) {
2657
            s->y_dc_scale = 2 * s->qscale;
2658
            s->c_dc_scale = 2 * s->qscale;
2659
        }
2660
        cbpy = get_vlc(&s->gb, &cbpy_vlc);
2661
        if(cbpy<0) return -1;
2662
        cbp = (cbpc & 3) | (cbpy << 2);
2663
        if (dquant) {
2664
            s->qscale += quant_tab[get_bits(&s->gb, 2)];
2665
            if (s->qscale < 1)
2666
                s->qscale = 1;
2667
            else if (s->qscale > 31)
2668
                s->qscale = 31;
2669
            h263_dc_scale(s);
2670
        }
2671
    }
2672

    
2673
    /* decode each block */
2674
    if (s->h263_pred) {
2675
        for (i = 0; i < 6; i++) {
2676
            if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
2677
                return -1;
2678
        }
2679
    } else {
2680
        for (i = 0; i < 6; i++) {
2681
            if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
2682
                return -1;
2683
        }
2684
    }
2685
    return 0;
2686
}
2687

    
2688
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
2689
{
2690
    int code, val, sign, shift, l, m;
2691

    
2692
    code = get_vlc(&s->gb, &mv_vlc);
2693
    if (code < 0)
2694
        return 0xffff;
2695

    
2696
    if (code == 0)
2697
        return pred;
2698
    sign = get_bits1(&s->gb);
2699
    shift = f_code - 1;
2700
    val = (code - 1) << shift;
2701
    if (shift > 0)
2702
        val |= get_bits(&s->gb, shift);
2703
    val++;
2704
    if (sign)
2705
        val = -val;
2706
    val += pred;
2707
    
2708
    /* modulo decoding */
2709
    if (!s->h263_long_vectors) {
2710
        l = (1 << (f_code - 1)) * 32;
2711
        m = 2 * l;
2712
        if (val < -l) {
2713
            val += m;
2714
        } else if (val >= l) {
2715
            val -= m;
2716
        }
2717
    } else {
2718
        /* horrible h263 long vector mode */
2719
        if (pred < -31 && val < -63)
2720
            val += 64;
2721
        if (pred > 32 && val > 63)
2722
            val -= 64;
2723
        
2724
    }
2725
    return val;
2726
}
2727

    
2728
/* Decodes RVLC of H.263+ UMV */
2729
static int h263p_decode_umotion(MpegEncContext * s, int pred)
2730
{
2731
   int code = 0, sign;
2732
   
2733
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
2734
      return pred;
2735
   
2736
   code = 2 + get_bits1(&s->gb);
2737
   
2738
   while (get_bits1(&s->gb))
2739
   {
2740
      code <<= 1;
2741
      code += get_bits1(&s->gb);
2742
   }
2743
   sign = code & 1;
2744
   code >>= 1;
2745
   
2746
   code = (sign) ? (pred - code) : (pred + code);
2747
#ifdef DEBUG
2748
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
2749
#endif
2750
   return code;   
2751

    
2752
}
2753

    
2754
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
2755
                             int n, int coded)
2756
{
2757
    int code, level, i, j, last, run;
2758
    RLTable *rl = &rl_inter;
2759
    const UINT8 *scan_table;
2760

    
2761
    scan_table = zigzag_direct;
2762
    if (s->h263_aic && s->mb_intra) {
2763
        rl = &rl_intra_aic;
2764
        i = 0;
2765
        if (s->ac_pred) {
2766
            if (s->h263_aic_dir) 
2767
                scan_table = ff_alternate_vertical_scan; /* left */
2768
            else
2769
                scan_table = ff_alternate_horizontal_scan; /* top */
2770
        }
2771
    } else if (s->mb_intra) {
2772
        /* DC coef */
2773
        if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
2774
            int component, diff;
2775
            component = (n <= 3 ? 0 : n - 4 + 1);
2776
            level = s->last_dc[component];
2777
            if (s->rv10_first_dc_coded[component]) {
2778
                diff = rv_decode_dc(s, n);
2779
                if (diff == 0xffff)
2780
                    return -1;
2781
                level += diff;
2782
                level = level & 0xff; /* handle wrap round */
2783
                s->last_dc[component] = level;
2784
            } else {
2785
                s->rv10_first_dc_coded[component] = 1;
2786
            }
2787
        } else {
2788
            level = get_bits(&s->gb, 8);
2789
            if (level == 255)
2790
                level = 128;
2791
        }
2792
        block[0] = level;
2793
        i = 1;
2794
    } else {
2795
        i = 0;
2796
    }
2797
    if (!coded) {
2798
        if (s->mb_intra && s->h263_aic)
2799
            goto not_coded;
2800
        s->block_last_index[n] = i - 1;
2801
        return 0;
2802
    }
2803

    
2804
    for(;;) {
2805
        code = get_vlc(&s->gb, &rl->vlc);
2806
        if (code < 0)
2807
            return -1;
2808
        if (code == rl->n) {
2809
            /* escape */
2810
            last = get_bits1(&s->gb);
2811
            run = get_bits(&s->gb, 6);
2812
            level = (INT8)get_bits(&s->gb, 8);
2813
            if (s->h263_rv10 && level == -128) {
2814
                /* XXX: should patch encoder too */
2815
                level = get_bits(&s->gb, 12);
2816
                level = (level << 20) >> 20;
2817
            }
2818
        } else {
2819
            run = rl->table_run[code];
2820
            level = rl->table_level[code];
2821
            last = code >= rl->last;
2822
            if (get_bits1(&s->gb))
2823
                level = -level;
2824
        }
2825
        i += run;
2826
        if (i >= 64)
2827
            return -1;
2828
        j = scan_table[i];
2829
        block[j] = level;
2830
        if (last)
2831
            break;
2832
        i++;
2833
    }
2834
not_coded:    
2835
    if (s->mb_intra && s->h263_aic) {
2836
        h263_pred_acdc(s, block, n);
2837
        i = 63;
2838
    }
2839
    s->block_last_index[n] = i;
2840
    return 0;
2841
}
2842

    
2843
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
2844
{
2845
    int level, pred, code;
2846
    UINT16 *dc_val;
2847

    
2848
    if (n < 4) 
2849
        code = get_vlc(&s->gb, &dc_lum);
2850
    else 
2851
        code = get_vlc(&s->gb, &dc_chrom);
2852
    if (code < 0 || code > 9 /* && s->nbit<9 */){
2853
        fprintf(stderr, "illegal dc vlc\n");
2854
        return -1;
2855
    }
2856
    if (code == 0) {
2857
        level = 0;
2858
    } else {
2859
        level = get_bits(&s->gb, code);
2860
        if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
2861
            level = - (level ^ ((1 << code) - 1));
2862
        if (code > 8){
2863
            if(get_bits1(&s->gb)==0){ /* marker */
2864
                fprintf(stderr, "dc marker bit missing\n");
2865
                return -1;
2866
            }
2867
        }
2868
    }
2869

    
2870
    pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
2871
    level += pred;
2872
    if (level < 0)
2873
        level = 0;
2874
    if (n < 4) {
2875
        *dc_val = level * s->y_dc_scale;
2876
    } else {
2877
        *dc_val = level * s->c_dc_scale;
2878
    }
2879
    return level;
2880
}
2881

    
2882
/**
2883
 * decode a block
2884
 * returns 0 if everything went ok
2885
 * returns DECODING_AC_LOST   if an error was detected during AC decoding
2886
 * returns DECODING_ACDC_LOST if an error was detected during DC decoding
2887
 */
2888
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
2889
                              int n, int coded)
2890
{
2891
    int code, level, i, j, last, run;
2892
    int dc_pred_dir;
2893
    RLTable *rl;
2894
    const UINT8 *scan_table;
2895

    
2896
    if (s->mb_intra) {
2897
        /* DC coef */
2898
        if(s->data_partitioning && s->pict_type!=B_TYPE){
2899
            level = s->dc_val[0][ s->block_index[n] ];
2900
            if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
2901
            else    level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
2902
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
2903
        }else{
2904
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
2905
            if (level < 0)
2906
                return DECODING_ACDC_LOST;
2907
        }
2908
        block[0] = level;
2909
        i = 1;
2910
        if (!coded) 
2911
            goto not_coded;
2912
        rl = &rl_intra;
2913
        if (s->ac_pred) {
2914
            if (dc_pred_dir == 0) 
2915
                scan_table = ff_alternate_vertical_scan; /* left */
2916
            else
2917
                scan_table = ff_alternate_horizontal_scan; /* top */
2918
        } else {
2919
            scan_table = zigzag_direct;
2920
        }
2921
    } else {
2922
        i = 0;
2923
        if (!coded) {
2924
            s->block_last_index[n] = i - 1;
2925
            return 0;
2926
        }
2927
        rl = &rl_inter;
2928
        scan_table = zigzag_direct;
2929
    }
2930

    
2931
    for(;;) {
2932
        code = get_vlc(&s->gb, &rl->vlc);
2933
        if (code < 0)
2934
            return DECODING_AC_LOST;
2935
        if (code == rl->n) {
2936
            /* escape */
2937
            if (get_bits1(&s->gb) != 0) {
2938
                if (get_bits1(&s->gb) != 0) {
2939
                    /* third escape */
2940
                    last = get_bits1(&s->gb);
2941
                    run = get_bits(&s->gb, 6);
2942
                    if(get_bits1(&s->gb)==0){
2943
                        fprintf(stderr, "1. marker bit missing in 3. esc\n");
2944
                        return DECODING_AC_LOST;
2945
                    }
2946
                    level = get_bits(&s->gb, 12);
2947
                    level = (level << 20) >> 20; /* sign extend */
2948
                    if(get_bits1(&s->gb)==0){
2949
                        fprintf(stderr, "2. marker bit missing in 3. esc\n");
2950
                        return DECODING_AC_LOST;
2951
                    }
2952
                    if(level>512 || level<-512){ //FIXME check that QP=1 is ok with this too
2953
                        fprintf(stderr, "|level| overflow in 3. esc\n");
2954
                        return DECODING_AC_LOST;
2955
                    }
2956
#if 1 
2957
                    {
2958
                        const int abs_level= ABS(level);
2959
                        const int run1= run - rl->max_run[last][abs_level] - 1;
2960
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN && s->error_resilience>=0){
2961
                            if(abs_level <= rl->max_level[last][run]){
2962
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
2963
                                return DECODING_AC_LOST;
2964
                            }
2965
                            if(abs_level <= rl->max_level[last][run]*2){
2966
                                fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
2967
                                return DECODING_AC_LOST;
2968
                            }
2969
                            if(abs_level <= rl->max_level[last][run1]){
2970
                                fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
2971
                                return DECODING_AC_LOST;
2972
                            }
2973
                        }
2974
                    }
2975
#endif
2976
                } else {
2977
                    /* second escape */
2978
                    code = get_vlc(&s->gb, &rl->vlc);
2979
                    if (code < 0 || code >= rl->n)
2980
                        return DECODING_AC_LOST;
2981
                    run = rl->table_run[code];
2982
                    level = rl->table_level[code];
2983
                    last = code >= rl->last;
2984
                    run += rl->max_run[last][level] + 1;
2985
                    if (get_bits1(&s->gb))
2986
                        level = -level;
2987
                }
2988
            } else {
2989
                /* first escape */
2990
                code = get_vlc(&s->gb, &rl->vlc);
2991
                if (code < 0 || code >= rl->n)
2992
                    return DECODING_AC_LOST;
2993
                run = rl->table_run[code];
2994
                level = rl->table_level[code];
2995
                last = code >= rl->last;
2996
                level += rl->max_level[last][run];
2997
                if (get_bits1(&s->gb))
2998
                    level = -level;
2999
            }
3000
        } else {
3001
            run = rl->table_run[code];
3002
            level = rl->table_level[code];
3003
            last = code >= rl->last;
3004
            if (get_bits1(&s->gb))
3005
                level = -level;
3006
        }
3007
        i += run;
3008
        if (i >= 64)
3009
            return DECODING_AC_LOST;
3010
        j = scan_table[i];
3011
        block[j] = level;
3012
        i++;
3013
        if (last)
3014
            break;
3015
    }
3016
 not_coded:
3017
    if (s->mb_intra) {
3018
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
3019
        if (s->ac_pred) {
3020
            i = 64; /* XXX: not optimal */
3021
        }
3022
    }
3023
    s->block_last_index[n] = i - 1;
3024
    return 0;
3025
}
3026

    
3027
/* most is hardcoded. should extend to handle all h263 streams */
3028
int h263_decode_picture_header(MpegEncContext *s)
3029
{
3030
    int format, width, height;
3031

    
3032
    /* picture start code */
3033
    if (get_bits(&s->gb, 22) != 0x20) {
3034
        fprintf(stderr, "Bad picture start code\n");
3035
        return -1;
3036
    }
3037
    /* temporal reference */
3038
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3039

    
3040
    /* PTYPE starts here */    
3041
    if (get_bits1(&s->gb) != 1) {
3042
        /* marker */
3043
        fprintf(stderr, "Bad marker\n");
3044
        return -1;
3045
    }
3046
    if (get_bits1(&s->gb) != 0) {
3047
        fprintf(stderr, "Bad H263 id\n");
3048
        return -1;        /* h263 id */
3049
    }
3050
    skip_bits1(&s->gb);        /* split screen off */
3051
    skip_bits1(&s->gb);        /* camera  off */
3052
    skip_bits1(&s->gb);        /* freeze picture release off */
3053

    
3054
    /* Reset GOB number */
3055
    s->gob_number = 0;
3056
        
3057
    format = get_bits(&s->gb, 3);
3058
    /*
3059
        0    forbidden
3060
        1    sub-QCIF
3061
        10   QCIF
3062
        7        extended PTYPE (PLUSPTYPE)
3063
    */
3064

    
3065
    if (format != 7 && format != 6) {
3066
        s->h263_plus = 0;
3067
        /* H.263v1 */
3068
        width = h263_format[format][0];
3069
        height = h263_format[format][1];
3070
        if (!width)
3071
            return -1;
3072
        
3073
        s->width = width;
3074
        s->height = height;
3075
        s->pict_type = I_TYPE + get_bits1(&s->gb);
3076

    
3077
        s->unrestricted_mv = get_bits1(&s->gb); 
3078
        s->h263_long_vectors = s->unrestricted_mv;
3079

    
3080
        if (get_bits1(&s->gb) != 0) {
3081
            fprintf(stderr, "H263 SAC not supported\n");
3082
            return -1;        /* SAC: off */
3083
        }
3084
        if (get_bits1(&s->gb) != 0) {
3085
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3086
        }   
3087
        
3088
        if (get_bits1(&s->gb) != 0) {
3089
            fprintf(stderr, "H263 PB frame not supported\n");
3090
            return -1;        /* not PB frame */
3091
        }
3092
        s->qscale = get_bits(&s->gb, 5);
3093
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
3094
    } else {
3095
        int ufep;
3096
        
3097
        /* H.263v2 */
3098
        s->h263_plus = 1;
3099
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3100

    
3101
        /* ufep other than 0 and 1 are reserved */        
3102
        if (ufep == 1) {
3103
            /* OPPTYPE */       
3104
            format = get_bits(&s->gb, 3);
3105
            dprintf("ufep=1, format: %d\n", format);
3106
            skip_bits(&s->gb,1); /* Custom PCF */
3107
            s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3108
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3109
            if (get_bits1(&s->gb) != 0) {
3110
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3111
            }
3112
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3113
                s->h263_aic = 1;
3114
            }
3115
            
3116
            skip_bits(&s->gb, 7);
3117
            /* these are the 7 bits: (in order of appearence  */
3118
            /* Deblocking Filter */
3119
            /* Slice Structured */
3120
            /* Reference Picture Selection */
3121
            /* Independent Segment Decoding */
3122
            /* Alternative Inter VLC */
3123
            /* Modified Quantization */
3124
            /* Prevent start code emulation */
3125

    
3126
            skip_bits(&s->gb, 3); /* Reserved */
3127
        } else if (ufep != 0) {
3128
            fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3129
            return -1;
3130
        }
3131
            
3132
        /* MPPTYPE */
3133
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3134
        dprintf("pict_type: %d\n", s->pict_type);
3135
        if (s->pict_type != I_TYPE &&
3136
            s->pict_type != P_TYPE)
3137
            return -1;
3138
        skip_bits(&s->gb, 2);
3139
        s->no_rounding = get_bits1(&s->gb);
3140
        dprintf("RTYPE: %d\n", s->no_rounding);
3141
        skip_bits(&s->gb, 4);
3142
        
3143
        /* Get the picture dimensions */
3144
        if (ufep) {
3145
            if (format == 6) {
3146
                /* Custom Picture Format (CPFMT) */
3147
                s->aspect_ratio_info = get_bits(&s->gb, 4);
3148
                dprintf("aspect: %d\n", s->aspect_ratio_info);
3149
                /* aspect ratios:
3150
                0 - forbidden
3151
                1 - 1:1
3152
                2 - 12:11 (CIF 4:3)
3153
                3 - 10:11 (525-type 4:3)
3154
                4 - 16:11 (CIF 16:9)
3155
                5 - 40:33 (525-type 16:9)
3156
                6-14 - reserved
3157
                */
3158
                width = (get_bits(&s->gb, 9) + 1) * 4;
3159
                skip_bits1(&s->gb);
3160
                height = get_bits(&s->gb, 9) * 4;
3161
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
3162
                if (s->aspect_ratio_info == EXTENDED_PAR) {
3163
                    /* aspected dimensions */
3164
                    skip_bits(&s->gb, 8); /* width */
3165
                    skip_bits(&s->gb, 8); /* height */
3166
                }
3167
            } else {
3168
                width = h263_format[format][0];
3169
                height = h263_format[format][1];
3170
            }
3171
            if ((width == 0) || (height == 0))
3172
                return -1;
3173
            s->width = width;
3174
            s->height = height;
3175
            if (s->umvplus_dec) {
3176
                skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
3177
            }
3178
        }
3179
            
3180
        s->qscale = get_bits(&s->gb, 5);
3181
    }
3182
    /* PEI */
3183
    while (get_bits1(&s->gb) != 0) {
3184
        skip_bits(&s->gb, 8);
3185
    }
3186
    s->f_code = 1;
3187
    return 0;
3188
}
3189

    
3190
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
3191
{
3192
    int i;
3193
    int a= 2<<s->sprite_warping_accuracy;
3194
    int rho= 3-s->sprite_warping_accuracy;
3195
    int r=16/a;
3196
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
3197
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
3198
    int sprite_ref[4][2];
3199
    int virtual_ref[2][2];
3200
    int w2, h2;
3201
    int alpha=0, beta=0;
3202
    int w= s->width;
3203
    int h= s->height;
3204
//printf("SP %d\n", s->sprite_warping_accuracy);
3205
    for(i=0; i<s->num_sprite_warping_points; i++){
3206
        int length;
3207
        int x=0, y=0;
3208

    
3209
        length= get_vlc(&s->gb, &sprite_trajectory);
3210
        if(length){
3211
            x= get_bits(&s->gb, length);
3212
//printf("lx %d %d\n", length, x);
3213
            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
3214
                x = - (x ^ ((1 << length) - 1));
3215
        }
3216
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
3217
        
3218
        length= get_vlc(&s->gb, &sprite_trajectory);
3219
        if(length){
3220
            y=get_bits(&s->gb, length);
3221
//printf("ly %d %d\n", length, y);
3222
            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
3223
                y = - (y ^ ((1 << length) - 1));
3224
        }
3225
        skip_bits1(&s->gb); /* marker bit */
3226
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
3227
//if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
3228
//x=y=0;
3229
        d[i][0]= x;
3230
        d[i][1]= y;
3231
    }
3232

    
3233
    while((1<<alpha)<w) alpha++;
3234
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
3235
    w2= 1<<alpha;
3236
    h2= 1<<beta;
3237

    
3238
// Note, the 4th point isnt used for GMC
3239
    if(s->divx_version==500 && s->divx_build==413){
3240
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
3241
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
3242
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
3243
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
3244
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
3245
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
3246
    } else {
3247
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
3248
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
3249
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
3250
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
3251
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
3252
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
3253
    }
3254
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
3255
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
3256
    
3257
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
3258
// perhaps it should be reordered to be more readable ...
3259
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
3260
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
3261
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
3262
        + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
3263
    virtual_ref[0][1]= 16*vop_ref[0][1] 
3264
        + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
3265
    virtual_ref[1][0]= 16*vop_ref[0][0] 
3266
        + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
3267
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
3268
        + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
3269

    
3270
    switch(s->num_sprite_warping_points)
3271
    {
3272
        case 0:
3273
            s->sprite_offset[0][0]= 0;
3274
            s->sprite_offset[0][1]= 0;
3275
            s->sprite_offset[1][0]= 0;
3276
            s->sprite_offset[1][1]= 0;
3277
            s->sprite_delta[0][0][0]= a;
3278
            s->sprite_delta[0][0][1]= 0;
3279
            s->sprite_delta[0][1][0]= 0;
3280
            s->sprite_delta[0][1][1]= a;
3281
            s->sprite_delta[1][0][0]= a;
3282
            s->sprite_delta[1][0][1]= 0;
3283
            s->sprite_delta[1][1][0]= 0;
3284
            s->sprite_delta[1][1][1]= a;
3285
            s->sprite_shift[0][0]= 0;
3286
            s->sprite_shift[0][1]= 0;
3287
            s->sprite_shift[1][0]= 0;
3288
            s->sprite_shift[1][1]= 0;
3289
            break;
3290
        case 1: //GMC only
3291
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
3292
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
3293
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
3294
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
3295
            s->sprite_delta[0][0][0]= a;
3296
            s->sprite_delta[0][0][1]= 0;
3297
            s->sprite_delta[0][1][0]= 0;
3298
            s->sprite_delta[0][1][1]= a;
3299
            s->sprite_delta[1][0][0]= a;
3300
            s->sprite_delta[1][0][1]= 0;
3301
            s->sprite_delta[1][1][0]= 0;
3302
            s->sprite_delta[1][1][1]= a;
3303
            s->sprite_shift[0][0]= 0;
3304
            s->sprite_shift[0][1]= 0;
3305
            s->sprite_shift[1][0]= 0;
3306
            s->sprite_shift[1][1]= 0;
3307
            break;
3308
        case 2:
3309
        case 3: //FIXME
3310
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
3311
                                                  + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
3312
                                                    +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
3313
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
3314
                                                  + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
3315
                                                    +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
3316
            s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
3317
                                 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
3318
                                 +2*w2*r*sprite_ref[0][0] - 16*w2);
3319
            s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
3320
                                 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
3321
                                 +2*w2*r*sprite_ref[0][1] - 16*w2);
3322
            s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3323
            s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
3324
            s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
3325
            s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3326
            s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
3327
            s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
3328
            s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
3329
            s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
3330
            s->sprite_shift[0][0]= alpha+rho;
3331
            s->sprite_shift[0][1]= alpha+rho;
3332
            s->sprite_shift[1][0]= alpha+rho+2;
3333
            s->sprite_shift[1][1]= alpha+rho+2;
3334
            break;
3335
//        case 3:
3336
            break;
3337
    }
3338
/*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
3339
printf("%d %d\n", s->sprite_delta[0][0][1], 0);
3340
printf("%d %d\n", s->sprite_delta[0][1][0], 0);
3341
printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
3342
printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
3343
printf("%d %d\n", s->sprite_delta[1][0][1], 0);
3344
printf("%d %d\n", s->sprite_delta[1][1][0], 0);
3345
printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
3346
    /* try to simplify the situation */ 
3347
    if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
3348
       && s->sprite_delta[0][0][1] == 0
3349
       && s->sprite_delta[0][1][0] == 0
3350
       && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
3351
       && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
3352
       && s->sprite_delta[1][0][1] == 0
3353
       && s->sprite_delta[1][1][0] == 0
3354
       && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
3355
    {
3356
        s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
3357
        s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
3358
        s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
3359
        s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
3360
        s->sprite_delta[0][0][0]= a;
3361
        s->sprite_delta[0][0][1]= 0;
3362
        s->sprite_delta[0][1][0]= 0;
3363
        s->sprite_delta[0][1][1]= a;
3364
        s->sprite_delta[1][0][0]= a;
3365
        s->sprite_delta[1][0][1]= 0;
3366
        s->sprite_delta[1][1][0]= 0;
3367
        s->sprite_delta[1][1][1]= a;
3368
        s->sprite_shift[0][0]= 0;
3369
        s->sprite_shift[0][1]= 0;
3370
        s->sprite_shift[1][0]= 0;
3371
        s->sprite_shift[1][1]= 0;
3372
        s->real_sprite_warping_points=1;
3373
    }
3374
    else
3375
        s->real_sprite_warping_points= s->num_sprite_warping_points;
3376

    
3377
//printf("%d %d %d %d\n", d[0][0], d[0][1], s->sprite_offset[0][0], s->sprite_offset[0][1]);
3378
}
3379

    
3380
/* decode mpeg4 VOP header */
3381
int mpeg4_decode_picture_header(MpegEncContext * s)
3382
{
3383
    int time_incr, startcode, state, v;
3384
    int time_increment;
3385

    
3386
 redo:
3387
    /* search next start code */
3388
    align_get_bits(&s->gb);
3389
    state = 0xff;
3390
    for(;;) {
3391
        v = get_bits(&s->gb, 8);
3392
        if (state == 0x000001) {
3393
            state = ((state << 8) | v) & 0xffffff;
3394
            startcode = state;
3395
            break;
3396
        }
3397
        state = ((state << 8) | v) & 0xffffff;
3398
        if( get_bits_count(&s->gb) > s->gb.size*8-32){
3399
            if(s->gb.size>50){
3400
                printf("no VOP startcode found, frame size was=%d\n", s->gb.size);
3401
                return -1;
3402
            }else{
3403
                printf("frame skip\n");
3404
                return FRAME_SKIPED;
3405
            }
3406
        }
3407
    }
3408
//printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
3409
    if (startcode == 0x120) { // Video Object Layer
3410
        int width, height, vo_ver_id;
3411

    
3412
        /* vol header */
3413
        skip_bits(&s->gb, 1); /* random access */
3414
        s->vo_type= get_bits(&s->gb, 8);
3415
        if (get_bits1(&s->gb) != 0) { /* is_ol_id */
3416
            vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
3417
            skip_bits(&s->gb, 3); /* vo_priority */
3418
        } else {
3419
            vo_ver_id = 1;
3420
        }
3421
//printf("vo type:%d\n",s->vo_type);
3422
        s->aspect_ratio_info= get_bits(&s->gb, 4);
3423
        if(s->aspect_ratio_info == EXTENDED_PAR){
3424
            skip_bits(&s->gb, 8); //par_width
3425
            skip_bits(&s->gb, 8); // par_height
3426
        }
3427

    
3428
        if ((s->vol_control_parameters=get_bits1(&s->gb))) { /* vol control parameter */
3429
            int chroma_format= get_bits(&s->gb, 2);
3430
            if(chroma_format!=1){
3431
                printf("illegal chroma format\n");
3432
            }
3433
            s->low_delay= get_bits1(&s->gb);
3434
            if(get_bits1(&s->gb)){ /* vbv parameters */
3435
                printf("vbv parameters not supported\n");
3436
                return -1;
3437
            }
3438
        }else{
3439
            s->low_delay=0;
3440
        }
3441

    
3442
        s->shape = get_bits(&s->gb, 2); /* vol shape */
3443
        if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
3444
        if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
3445
            printf("Gray shape not supported\n");
3446
            skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
3447
        }
3448

    
3449
        skip_bits1(&s->gb);   /* marker */
3450
        
3451
        s->time_increment_resolution = get_bits(&s->gb, 16);
3452
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
3453
        if (s->time_increment_bits < 1)
3454
            s->time_increment_bits = 1;
3455
        skip_bits1(&s->gb);   /* marker */
3456

    
3457
        if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
3458
            skip_bits(&s->gb, s->time_increment_bits);
3459
        }
3460

    
3461
        if (s->shape != BIN_ONLY_SHAPE) {
3462
            if (s->shape == RECT_SHAPE) {
3463
                skip_bits1(&s->gb);   /* marker */
3464
                width = get_bits(&s->gb, 13);
3465
                skip_bits1(&s->gb);   /* marker */
3466
                height = get_bits(&s->gb, 13);
3467
                skip_bits1(&s->gb);   /* marker */
3468
                if(width && height){ /* they should be non zero but who knows ... */
3469
                    s->width = width;
3470
                    s->height = height;
3471
//                    printf("width/height: %d %d\n", width, height);
3472
                }
3473
            }
3474
            
3475
            if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */
3476
            if(!get_bits1(&s->gb)) printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
3477
            if (vo_ver_id == 1) {
3478
                s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
3479
            } else {
3480
                s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
3481
            }
3482
            if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
3483
            if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
3484
                if(s->vol_sprite_usage==STATIC_SPRITE){
3485
                    s->sprite_width = get_bits(&s->gb, 13);
3486
                    skip_bits1(&s->gb); /* marker */
3487
                    s->sprite_height= get_bits(&s->gb, 13);
3488
                    skip_bits1(&s->gb); /* marker */
3489
                    s->sprite_left  = get_bits(&s->gb, 13);
3490
                    skip_bits1(&s->gb); /* marker */
3491
                    s->sprite_top   = get_bits(&s->gb, 13);
3492
                    skip_bits1(&s->gb); /* marker */
3493
                }
3494
                s->num_sprite_warping_points= get_bits(&s->gb, 6);
3495
                s->sprite_warping_accuracy = get_bits(&s->gb, 2);
3496
                s->sprite_brightness_change= get_bits1(&s->gb);
3497
                if(s->vol_sprite_usage==STATIC_SPRITE)
3498
                    s->low_latency_sprite= get_bits1(&s->gb);            
3499
            }
3500
            // FIXME sadct disable bit if verid!=1 && shape not rect
3501
            
3502
            if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
3503
                s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
3504
                if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
3505
                if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
3506
            } else {
3507
                s->quant_precision = 5;
3508
            }
3509
            
3510
            // FIXME a bunch of grayscale shape things
3511

    
3512
            if(get_bits1(&s->gb)){ /* vol_quant_type */
3513
                int i, j, v;
3514
                /* load default matrixes */
3515
                for(i=0; i<64; i++){
3516
                    v= ff_mpeg4_default_intra_matrix[i];
3517
                    s->intra_matrix[i]= v;
3518
                    s->chroma_intra_matrix[i]= v;
3519
                    
3520
                    v= ff_mpeg4_default_non_intra_matrix[i];
3521
                    s->inter_matrix[i]= v;
3522
                    s->chroma_inter_matrix[i]= v;
3523
                }
3524

    
3525
                /* load custom intra matrix */
3526
                if(get_bits1(&s->gb)){
3527
                    for(i=0; i<64; i++){
3528
                        v= get_bits(&s->gb, 8);
3529
                        if(v==0) break;
3530

    
3531
                        j= zigzag_direct[i];
3532
                        s->intra_matrix[j]= v;
3533
                        s->chroma_intra_matrix[j]= v;
3534
                    }
3535
                }
3536

    
3537
                /* load custom non intra matrix */
3538
                if(get_bits1(&s->gb)){
3539
                    for(i=0; i<64; i++){
3540
                        v= get_bits(&s->gb, 8);
3541
                        if(v==0) break;
3542

    
3543
                        j= zigzag_direct[i];
3544
                        s->inter_matrix[j]= v;
3545
                        s->chroma_inter_matrix[j]= v;
3546
                    }
3547

    
3548
                    /* replicate last value */
3549
                    for(; i<64; i++){
3550
                        j= zigzag_direct[i];
3551
                        s->inter_matrix[j]= v;
3552
                        s->chroma_inter_matrix[j]= v;
3553
                    }
3554
                }
3555

    
3556
                s->dct_unquantize= s->dct_unquantize_mpeg2;
3557

    
3558
                // FIXME a bunch of grayscale shape things
3559
            }else
3560
                s->dct_unquantize= s->dct_unquantize_h263;
3561

    
3562
            if(vo_ver_id != 1)
3563
                 s->quarter_sample= get_bits1(&s->gb);
3564
            else s->quarter_sample=0;
3565

    
3566
            if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
3567

    
3568
            s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */
3569

    
3570
            s->data_partitioning= get_bits1(&s->gb);
3571
            if(s->data_partitioning){
3572
                s->rvlc= get_bits1(&s->gb);
3573
                if(s->rvlc){
3574
                    printf("reversible vlc not supported\n");
3575
                }
3576
            }
3577
            
3578
            if(vo_ver_id != 1) {
3579
                s->new_pred= get_bits1(&s->gb);
3580
                if(s->new_pred){
3581
                    printf("new pred not supported\n");
3582
                    skip_bits(&s->gb, 2); /* requested upstream message type */
3583
                    skip_bits1(&s->gb); /* newpred segment type */
3584
                }
3585
                s->reduced_res_vop= get_bits1(&s->gb);
3586
                if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
3587
            }
3588
            else{
3589
                s->new_pred=0;
3590
                s->reduced_res_vop= 0;
3591
            }
3592

    
3593
            s->scalability= get_bits1(&s->gb);
3594
            if (s->scalability) {
3595
                printf("scalability not supported\n");
3596
            }
3597
        }
3598
//printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
3599
        goto redo;
3600
    } else if (startcode == 0x1b2) { //userdata
3601
        char buf[256];
3602
        int i;
3603
        int e;
3604
        int ver, build;
3605

    
3606
//printf("user Data %X\n", show_bits(&s->gb, 32));
3607
        buf[0]= show_bits(&s->gb, 8);
3608
        for(i=1; i<256; i++){
3609
            buf[i]= show_bits(&s->gb, 16)&0xFF;
3610
            if(buf[i]==0) break;
3611
            skip_bits(&s->gb, 8);
3612
        }
3613
        buf[255]=0;
3614
        e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
3615
        if(e!=2)
3616
            e=sscanf(buf, "DivX%db%d", &ver, &build);
3617
        if(e==2){
3618
            s->divx_version= ver;
3619
            s->divx_build= build;
3620
            if(s->picture_number==0){
3621
                printf("This file was encoded with DivX%d Build%d\n", ver, build);
3622
                if(ver==500 && build==413){
3623
                    printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
3624
#if 0
3625
                }else{
3626
                    printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
3627
                           "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
3628
#endif 
3629
                }
3630
            }
3631
        }
3632
//printf("User Data: %s\n", buf);
3633
        goto redo;
3634
    } else if (startcode != 0x1b6) { //VOP
3635
        goto redo;
3636
    }
3637

    
3638
    s->pict_type = get_bits(&s->gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
3639
//if(s->pict_type!=I_TYPE) return FRAME_SKIPED;
3640
    if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
3641
        printf("low_delay flag set, but shouldnt, clearing it\n");
3642
        s->low_delay=0;
3643
    }
3644
// printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample); 
3645
//printf("%d", s->pict_type);
3646
    time_incr=0;
3647
    while (get_bits1(&s->gb) != 0) 
3648
        time_incr++;
3649

    
3650
    check_marker(&s->gb, "before time_increment");
3651
    time_increment= get_bits(&s->gb, s->time_increment_bits);
3652
//printf(" type:%d incr:%d increment:%d\n", s->pict_type, time_incr, time_increment);
3653
    if(s->pict_type!=B_TYPE){
3654
        s->last_time_base= s->time_base;
3655
        s->time_base+= time_incr;
3656
        s->time= s->time_base*s->time_increment_resolution + time_increment;
3657
        s->pp_time= s->time - s->last_non_b_time;
3658
        s->last_non_b_time= s->time;
3659
    }else{
3660
        s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
3661
        s->bp_time= s->last_non_b_time - s->time;
3662
        if(s->pp_time <=s->bp_time){
3663
//            printf("messed up order, seeking?, skiping current b frame\n");
3664
            return FRAME_SKIPED;
3665
        }
3666
    }
3667

    
3668
    if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
3669
        printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
3670
        for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
3671
            if(get_bits1(&s->gb)) break;
3672
        }
3673
        printf("my guess is %d bits ;)\n",s->time_increment_bits);
3674
    }
3675
    /* vop coded */
3676
    if (get_bits1(&s->gb) != 1)
3677
        goto redo;
3678
//printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
3679
//s->time, s->last_non_b_time[0], s->last_non_b_time[1]);  
3680
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
3681
                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
3682
        /* rounding type for motion estimation */
3683
        s->no_rounding = get_bits1(&s->gb);
3684
    } else {
3685
        s->no_rounding = 0;
3686
    }
3687
//FIXME reduced res stuff
3688

    
3689
     if (s->shape != RECT_SHAPE) {
3690
         if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
3691
             int width, height, hor_spat_ref, ver_spat_ref;
3692
 
3693
             width = get_bits(&s->gb, 13);
3694
             skip_bits1(&s->gb);   /* marker */
3695
             height = get_bits(&s->gb, 13);
3696
             skip_bits1(&s->gb);   /* marker */
3697
             hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
3698
             skip_bits1(&s->gb);   /* marker */
3699
             ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
3700
         }
3701
         skip_bits1(&s->gb); /* change_CR_disable */
3702
 
3703
         if (get_bits1(&s->gb) != 0) {
3704
             skip_bits(&s->gb, 8); /* constant_alpha_value */
3705
         }
3706
     }
3707
//FIXME complexity estimation stuff
3708
     
3709
     if (s->shape != BIN_ONLY_SHAPE) {
3710
         int t;
3711
         t=get_bits(&s->gb, 3); /* intra dc VLC threshold */
3712
//printf("threshold %d\n", t);
3713
         //FIXME interlaced specific bits
3714
     }
3715

    
3716
     if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
3717
         if(s->num_sprite_warping_points){
3718
             mpeg4_decode_sprite_trajectory(s);
3719
         }
3720
         if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
3721
         if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
3722
     }
3723

    
3724
     if (s->shape != BIN_ONLY_SHAPE) {
3725
         /* note: we do not use quant_precision to avoid problem if no
3726
            MPEG4 vol header as it is found on some old opendivx
3727
            movies */
3728
         s->qscale = get_bits(&s->gb, 5);
3729
         if(s->qscale==0){
3730
             printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
3731
             return -1; // makes no sense to continue, as there is nothing left from the image then
3732
         }
3733
  
3734
         if (s->pict_type != I_TYPE) {
3735
             s->f_code = get_bits(&s->gb, 3);        /* fcode_for */
3736
             if(s->f_code==0){
3737
                 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
3738
                 return -1; // makes no sense to continue, as the MV decoding will break very quickly
3739
             }
3740
         }
3741
         if (s->pict_type == B_TYPE) {
3742
             s->b_code = get_bits(&s->gb, 3);
3743
//printf("b-code %d\n", s->b_code);
3744
         }
3745
//printf("quant:%d fcode:%d bcode:%d type:%d\n", s->qscale, s->f_code, s->b_code, s->pict_type);
3746
         if(!s->scalability){
3747
             if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
3748
                 skip_bits1(&s->gb); // vop shape coding type
3749
             }
3750
         }
3751
     }
3752
     /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
3753
     // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
3754
     if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
3755
         printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
3756
         s->low_delay=1;
3757
     }
3758

    
3759
     s->picture_number++; // better than pic number==0 allways ;)
3760
//printf("done\n");
3761

    
3762
     return 0;
3763
}
3764

    
3765
/* don't understand why they choose a different header ! */
3766
int intel_h263_decode_picture_header(MpegEncContext *s)
3767
{
3768
    int format;
3769

    
3770
    /* picture header */
3771
    if (get_bits(&s->gb, 22) != 0x20) {
3772
        fprintf(stderr, "Bad picture start code\n");
3773
        return -1;
3774
    }
3775
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3776

    
3777
    if (get_bits1(&s->gb) != 1) {
3778
        fprintf(stderr, "Bad marker\n");
3779
        return -1;        /* marker */
3780
    }
3781
    if (get_bits1(&s->gb) != 0) {
3782
        fprintf(stderr, "Bad H263 id\n");
3783
        return -1;        /* h263 id */
3784
    }
3785
    skip_bits1(&s->gb);        /* split screen off */
3786
    skip_bits1(&s->gb);        /* camera  off */
3787
    skip_bits1(&s->gb);        /* freeze picture release off */
3788

    
3789
    format = get_bits(&s->gb, 3);
3790
    if (format != 7) {
3791
        fprintf(stderr, "Intel H263 free format not supported\n");
3792
        return -1;
3793
    }
3794
    s->h263_plus = 0;
3795

    
3796
    s->pict_type = I_TYPE + get_bits1(&s->gb);
3797
    
3798
    s->unrestricted_mv = get_bits1(&s->gb); 
3799
    s->h263_long_vectors = s->unrestricted_mv;
3800

    
3801
    if (get_bits1(&s->gb) != 0) {
3802
        fprintf(stderr, "SAC not supported\n");
3803
        return -1;        /* SAC: off */
3804
    }
3805
    if (get_bits1(&s->gb) != 0) {
3806
        fprintf(stderr, "Advanced Prediction Mode not supported\n");
3807
        return -1;        /* advanced prediction mode: off */
3808
    }
3809
    if (get_bits1(&s->gb) != 0) {
3810
        fprintf(stderr, "PB frame mode no supported\n");
3811
        return -1;        /* PB frame mode */
3812
    }
3813

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

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

    
3820
    /* PEI */
3821
    while (get_bits1(&s->gb) != 0) {
3822
        skip_bits(&s->gb, 8);
3823
    }
3824
    s->f_code = 1;
3825
    return 0;
3826
}
3827