Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 59c673d5

History | View | Annotate | Download (174 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, error resilience, optimizations,
22
 * qpel decoding, gmc decoding, interlaced decoding, 
23
 * by Michael Niedermayer <michaelni@gmx.at>
24
 */
25

    
26
/**
27
 * @file h263.c
28
 * h263/mpeg4 codec.
29
 */
30
 
31
//#define DEBUG
32
#include "common.h"
33
#include "dsputil.h"
34
#include "avcodec.h"
35
#include "mpegvideo.h"
36
#include "h263data.h"
37
#include "mpeg4data.h"
38

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

    
42
#define INTRA_MCBPC_VLC_BITS 6
43
#define INTER_MCBPC_VLC_BITS 6
44
#define CBPY_VLC_BITS 6
45
#define MV_VLC_BITS 9
46
#define DC_VLC_BITS 9
47
#define SPRITE_TRAJ_VLC_BITS 6
48
#define MB_TYPE_B_VLC_BITS 4
49
#define TEX_VLC_BITS 9
50

    
51
#ifdef CONFIG_ENCODERS
52
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
53
                              int n);
54
static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
55
static void h263p_encode_umotion(MpegEncContext * s, int val);
56
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
57
                               int n, int dc, uint8_t *scan_table, 
58
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
59
#endif
60

    
61
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
62
static int h263p_decode_umotion(MpegEncContext * s, int pred);
63
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
64
                             int n, int coded);
65
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
66
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
67
                              int n, int coded, int intra, int rvlc);
68
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
69
#ifdef CONFIG_ENCODERS
70
static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
71
                              int dir);
72
#endif //CONFIG_ENCODERS
73
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
74
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
75

    
76
#ifdef CONFIG_ENCODERS
77
static uint8_t uni_DCtab_lum_len[512];
78
static uint8_t uni_DCtab_chrom_len[512];
79
static uint16_t uni_DCtab_lum_bits[512];
80
static uint16_t uni_DCtab_chrom_bits[512];
81

    
82
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
83
static uint8_t fcode_tab[MAX_MV*2+1];
84
static uint8_t umv_fcode_tab[MAX_MV*2+1];
85

    
86
static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
87
static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
88
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
89
static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
90
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
91
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
92
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
93

    
94
/* mpeg4
95
inter
96
max level: 24/6
97
max run: 53/63
98

99
intra
100
max level: 53/16
101
max run: 29/41
102
*/
103
#endif
104

    
105
#if 0 //3IV1 is quite rare and tis slows things down a tiny bit
106
#define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
107
#else 
108
#define IS_3IV1 0
109
#endif
110

    
111
int h263_get_picture_format(int width, int height)
112
{
113
    int format;
114

    
115
    if (width == 128 && height == 96)
116
        format = 1;
117
    else if (width == 176 && height == 144)
118
        format = 2;
119
    else if (width == 352 && height == 288)
120
        format = 3;
121
    else if (width == 704 && height == 576)
122
        format = 4;
123
    else if (width == 1408 && height == 1152)
124
        format = 5;
125
    else
126
        format = 7;
127
    return format;
128
}
129

    
130
#ifdef CONFIG_ENCODERS
131

    
132
static void float_aspect_to_info(MpegEncContext * s, float aspect){
133
    int i;
134

    
135
    aspect*= s->height/(double)s->width;
136
//printf("%f\n", aspect);
137
    
138
    if(aspect==0) aspect= 1.0;
139

    
140
    ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
141

    
142
//printf("%d %d\n", s->aspected_width, s->aspected_height);
143
    for(i=1; i<6; i++){
144
        if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
145
            s->aspect_ratio_info=i;
146
            return;
147
        }
148
    }
149
    
150
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
151
}
152

    
153
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
154
{
155
      int format;
156

    
157
      align_put_bits(&s->pb);
158

    
159
      put_bits(&s->pb, 17, 1);
160
      put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
161
      put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / 
162
                           s->avctx->frame_rate) & 0xff); /* TemporalReference */
163
      if (s->width == 352 && s->height == 288)
164
        format = 2;
165
      else if (s->width == 176 && s->height == 144)
166
        format = 3;
167
      else if (s->width == 128 && s->height == 96)
168
        format = 4;
169
      else if (s->width == 320 && s->height == 240)
170
        format = 5;
171
      else if (s->width == 160 && s->height == 120)
172
        format = 6;
173
      else if (s->width <= 255 && s->height <= 255)
174
        format = 0; /* use 1 byte width & height */
175
      else
176
        format = 1; /* use 2 bytes width & height */
177
      put_bits(&s->pb, 3, format); /* PictureSize */
178
      if (format == 0) {
179
        put_bits(&s->pb, 8, s->width);
180
        put_bits(&s->pb, 8, s->height);
181
      } else if (format == 1) {
182
        put_bits(&s->pb, 16, s->width);
183
        put_bits(&s->pb, 16, s->height);
184
      }
185
      put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
186
      put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
187
      put_bits(&s->pb, 5, s->qscale); /* Quantizer */
188
      put_bits(&s->pb, 1, 0); /* ExtraInformation */
189

    
190
      if(s->h263_aic){
191
        s->y_dc_scale_table= 
192
          s->c_dc_scale_table= h263_aic_dc_scale_table;
193
      }else{
194
        s->y_dc_scale_table=
195
          s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
196
      }
197
}
198

    
199
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
200
{
201
    int format;
202

    
203
    align_put_bits(&s->pb);
204

    
205
    /* Update the pointer to last GOB */
206
    s->ptr_lastgob = pbBufPtr(&s->pb);
207
    s->gob_number = 0;
208

    
209
    put_bits(&s->pb, 22, 0x20); /* PSC */
210
    put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / 
211
                         s->avctx->frame_rate) & 0xff);
212

    
213
    put_bits(&s->pb, 1, 1);        /* marker */
214
    put_bits(&s->pb, 1, 0);        /* h263 id */
215
    put_bits(&s->pb, 1, 0);        /* split screen off */
216
    put_bits(&s->pb, 1, 0);        /* camera  off */
217
    put_bits(&s->pb, 1, 0);        /* freeze picture release off */
218
    
219
    format = h263_get_picture_format(s->width, s->height);
220
    if (!s->h263_plus) {
221
        /* H.263v1 */
222
        put_bits(&s->pb, 3, format);
223
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
224
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
225
        of H.263v1 UMV implies to check the predicted MV after
226
        calculation of the current MB to see if we're on the limits */
227
        put_bits(&s->pb, 1, 0);        /* unrestricted motion vector: off */
228
        put_bits(&s->pb, 1, 0);        /* SAC: off */
229
        put_bits(&s->pb, 1, 0);        /* advanced prediction mode: off */
230
        put_bits(&s->pb, 1, 0);        /* not PB frame */
231
        put_bits(&s->pb, 5, s->qscale);
232
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
233
    } else {
234
        /* H.263v2 */
235
        /* H.263 Plus PTYPE */
236
        put_bits(&s->pb, 3, 7);
237
        put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
238
        if (format == 7)
239
            put_bits(&s->pb,3,6); /* Custom Source Format */
240
        else
241
            put_bits(&s->pb, 3, format);
242
            
243
        put_bits(&s->pb,1,0); /* Custom PCF: off */
244
        s->umvplus = s->unrestricted_mv;
245
        put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
246
        put_bits(&s->pb,1,0); /* SAC: off */
247
        put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
248
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
249
        put_bits(&s->pb,1,0); /* Deblocking Filter: off */
250
        put_bits(&s->pb,1,0); /* Slice Structured: off */
251
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
252
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
253
        put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
254
        put_bits(&s->pb,1,0); /* Modified Quantization: off */
255
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
256
        put_bits(&s->pb,3,0); /* Reserved */
257
                
258
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
259
                
260
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
261
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
262
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
263
        put_bits(&s->pb,2,0); /* Reserved */
264
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
265
                
266
        /* This should be here if PLUSPTYPE */
267
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
268
                
269
                if (format == 7) {
270
            /* Custom Picture Format (CPFMT) */
271
            float_aspect_to_info(s, s->avctx->aspect_ratio);
272

    
273
            put_bits(&s->pb,4,s->aspect_ratio_info);
274
            put_bits(&s->pb,9,(s->width >> 2) - 1);
275
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
276
            put_bits(&s->pb,9,(s->height >> 2));
277
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
278
            {
279
                put_bits(&s->pb, 8, s->aspected_width);
280
                put_bits(&s->pb, 8, s->aspected_height);
281
            }
282
        }
283
        
284
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
285
        if (s->umvplus)
286
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
287
            put_bits(&s->pb,2,1); /* unlimited */
288

    
289
        put_bits(&s->pb, 5, s->qscale);
290
    }
291

    
292
    put_bits(&s->pb, 1, 0);        /* no PEI */
293

    
294
    if(s->h263_aic){
295
         s->y_dc_scale_table= 
296
         s->c_dc_scale_table= h263_aic_dc_scale_table;
297
    }else{
298
        s->y_dc_scale_table=
299
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
300
    }
301
}
302

    
303
/**
304
 * Encodes a group of blocks header.
305
 */
306
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
307
{
308
           align_put_bits(&s->pb);
309
           flush_put_bits(&s->pb);
310
           /* Call the RTP callback to send the last GOB */
311
           if (s->rtp_callback) {
312
               int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
313
               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
314
           }
315
           put_bits(&s->pb, 17, 1); /* GBSC */
316
           s->gob_number = mb_line / s->gob_index;
317
           put_bits(&s->pb, 5, s->gob_number); /* GN */
318
           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
319
           put_bits(&s->pb, 5, s->qscale); /* GQUANT */
320
           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
321
    return 0;
322
}
323

    
324
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
325
{
326
    int score0=0, score1=0;
327
    int i, n;
328
    int8_t * const qscale_table= s->current_picture.qscale_table;
329

    
330
    for(n=0; n<6; n++){
331
        int16_t *ac_val, *ac_val1;
332

    
333
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
334
        ac_val1= ac_val;
335
        if(dir[n]){
336
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
337
            /* top prediction */
338
            ac_val-= s->block_wrap[n]*16;
339
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
340
                /* same qscale */
341
                for(i=1; i<8; i++){
342
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
343
                    score0+= ABS(level);
344
                    score1+= ABS(level - ac_val[i+8]);
345
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
346
                    ac_val1[i+8]= level;
347
                }
348
            }else{
349
                /* different qscale, we must rescale */
350
                for(i=1; i<8; i++){
351
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
352
                    score0+= ABS(level);
353
                    score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale));
354
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
355
                    ac_val1[i+8]= level;
356
                }
357
            }
358
        }else{
359
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
360
            /* left prediction */
361
            ac_val-= 16;
362
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
363
                /* same qscale */
364
                for(i=1; i<8; i++){
365
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
366
                    score0+= ABS(level);
367
                    score1+= ABS(level - ac_val[i]);
368
                    ac_val1[i  ]= level;
369
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
370
                }
371
            }else{
372
                /* different qscale, we must rescale */
373
                for(i=1; i<8; i++){
374
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
375
                    score0+= ABS(level);
376
                    score1+= ABS(level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale));
377
                    ac_val1[i  ]= level;
378
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
379
                }
380
            }
381
        }
382
    }
383

    
384
    return score0 > score1 ? 1 : 0;    
385
}
386

    
387
/**
388
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
389
 */
390
void ff_clean_h263_qscales(MpegEncContext *s){
391
    int i;
392
    int8_t * const qscale_table= s->current_picture.qscale_table;
393
    
394
    for(i=1; i<s->mb_num; i++){
395
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
396
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
397
    }
398
    for(i=s->mb_num-2; i>=0; i--){
399
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
400
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
401
    }
402
}
403

    
404
/**
405
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
406
 */
407
void ff_clean_mpeg4_qscales(MpegEncContext *s){
408
    int i;
409
    int8_t * const qscale_table= s->current_picture.qscale_table;
410

    
411
    ff_clean_h263_qscales(s);
412
    
413
    for(i=1; i<s->mb_num; i++){
414
        int mb_xy= s->mb_index2xy[i];
415
    
416
        if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){
417
            s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V;
418
            s->mb_type[mb_xy]|= MB_TYPE_INTER;
419
        }
420
    }
421

    
422
    if(s->pict_type== B_TYPE){
423
        int odd=0;
424
        /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
425
           for the actual adaptive quantization */
426
        
427
        for(i=0; i<s->mb_num; i++){
428
            int mb_xy= s->mb_index2xy[i];
429
            odd += qscale_table[mb_xy]&1;
430
        }
431
        
432
        if(2*odd > s->mb_num) odd=1;
433
        else                  odd=0;
434
        
435
        for(i=0; i<s->mb_num; i++){
436
            int mb_xy= s->mb_index2xy[i];
437
            if((qscale_table[mb_xy]&1) != odd)
438
                qscale_table[mb_xy]++;
439
            if(qscale_table[mb_xy] > 31)
440
                qscale_table[mb_xy]= 31;
441
        }            
442
    
443
        for(i=1; i<s->mb_num; i++){
444
            int mb_xy= s->mb_index2xy[i];
445
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){
446
                s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT;
447
                s->mb_type[mb_xy]|= MB_TYPE_BIDIR;
448
            }
449
        }
450
    }
451
}
452

    
453
#endif //CONFIG_ENCODERS
454
/**
455
 *
456
 * @return the mb_type
457
 */
458
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
459
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
460
    const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next?
461
    int xy= s->block_index[0];
462
    uint16_t time_pp= s->pp_time;
463
    uint16_t time_pb= s->pb_time;
464
    int i;
465
    
466
    //FIXME avoid divides
467
    
468
    if(IS_8X8(colocated_mb_type)){
469
        s->mv_type = MV_TYPE_8X8;
470
        for(i=0; i<4; i++){
471
            xy= s->block_index[i];
472
            s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
473
            s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
474
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
475
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
476
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1] 
477
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
478
        }
479
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
480
    } else if(IS_INTERLACED(colocated_mb_type)){
481
        s->mv_type = MV_TYPE_FIELD;
482
        for(i=0; i<2; i++){
483
            if(s->top_field_first){
484
                time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
485
                time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
486
            }else{
487
                time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
488
                time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
489
            }
490
            s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
491
            s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
492
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
493
                                : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
494
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] 
495
                                : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
496
        }
497
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
498
    }else{
499
        s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
500
        s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
501
        s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
502
                            : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
503
        s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
504
                            : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
505
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
506
            s->mv_type= MV_TYPE_16X16;
507
        else
508
            s->mv_type= MV_TYPE_8X8;
509
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
510
    }
511
}
512

    
513
void ff_h263_update_motion_val(MpegEncContext * s){
514
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
515
               //FIXME a lot of thet is only needed for !low_delay
516
    const int wrap = s->block_wrap[0];
517
    const int xy = s->block_index[0];
518
    
519
    s->current_picture.mbskip_table[mb_xy]= s->mb_skiped; 
520

    
521
    if(s->mv_type != MV_TYPE_8X8){
522
        int motion_x, motion_y;
523
        if (s->mb_intra) {
524
            motion_x = 0;
525
            motion_y = 0;
526
        } else if (s->mv_type == MV_TYPE_16X16) {
527
            motion_x = s->mv[0][0][0];
528
            motion_y = s->mv[0][0][1];
529
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
530
            int i;
531
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
532
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
533
            motion_x = (motion_x>>1) | (motion_x&1);
534
            for(i=0; i<2; i++){
535
                s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
536
                s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
537
                s->field_select_table[mb_xy][i]= s->field_select[0][i];
538
            }
539
        }
540
        
541
        /* no update if 8X8 because it has been done during parsing */
542
        s->motion_val[xy][0] = motion_x;
543
        s->motion_val[xy][1] = motion_y;
544
        s->motion_val[xy + 1][0] = motion_x;
545
        s->motion_val[xy + 1][1] = motion_y;
546
        s->motion_val[xy + wrap][0] = motion_x;
547
        s->motion_val[xy + wrap][1] = motion_y;
548
        s->motion_val[xy + 1 + wrap][0] = motion_x;
549
        s->motion_val[xy + 1 + wrap][1] = motion_y;
550
    }
551

    
552
    if(s->encoding){ //FIXME encoding MUST be cleaned up
553
        if (s->mv_type == MV_TYPE_8X8) 
554
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
555
        else
556
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
557
    }
558
}
559

    
560
#ifdef CONFIG_ENCODERS
561
void mpeg4_encode_mb(MpegEncContext * s,
562
                    DCTELEM block[6][64],
563
                    int motion_x, int motion_y)
564
{
565
    int cbpc, cbpy, pred_x, pred_y;
566
    int bits;
567
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
568
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
569
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
570
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
571
    const int dquant_code[5]= {1,0,9,2,3};
572
    
573
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
574
    if (!s->mb_intra) {
575
        /* compute cbp */
576
        int i, cbp = 0;
577
        for (i = 0; i < 6; i++) {
578
            if (s->block_last_index[i] >= 0)
579
                cbp |= 1 << (5 - i);
580
        }
581

    
582
        if(s->pict_type==B_TYPE){
583
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
584
            int mb_type=  mb_type_table[s->mv_dir];
585
            
586
            if(s->mb_x==0){
587
                s->last_mv[0][0][0]= 
588
                s->last_mv[0][0][1]= 
589
                s->last_mv[1][0][0]= 
590
                s->last_mv[1][0][1]= 0;
591
            }
592
            
593
            assert(s->dquant>=-2 && s->dquant<=2);
594
            assert((s->dquant&1)==0);
595
            assert(mb_type>=0);
596

    
597
            /* nothing to do if this MB was skiped in the next P Frame */
598
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
599
                s->skip_count++;
600
                s->mv[0][0][0]= 
601
                s->mv[0][0][1]= 
602
                s->mv[1][0][0]= 
603
                s->mv[1][0][1]= 0;
604
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
605
                s->qscale -= s->dquant;
606
//                s->mb_skiped=1;
607

    
608
                return;
609
            }
610
            
611
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
612
                /* direct MB with MV={0,0} */
613
                assert(s->dquant==0);
614
                
615
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
616

    
617
                if(interleaved_stats){
618
                    s->misc_bits++;
619
                    s->last_bits++;
620
                }
621
                s->skip_count++;
622
                return;
623
            }
624
            
625
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
626
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
627
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
628
            if(cbp) put_bits(&s->pb, 6, cbp);
629
            
630
            if(cbp && mb_type){
631
                if(s->dquant)
632
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
633
                else
634
                    put_bits(&s->pb, 1, 0);
635
            }else
636
                s->qscale -= s->dquant;
637
            
638
            if(!s->progressive_sequence){
639
                if(cbp)
640
                    put_bits(&s->pb, 1, s->interlaced_dct);
641
                if(mb_type) // not diect mode
642
                    put_bits(&s->pb, 1, 0); // no interlaced ME yet
643
            }
644

    
645
            if(interleaved_stats){
646
                s->misc_bits+= get_bits_diff(s);
647
            }
648

    
649
            switch(mb_type)
650
            {
651
            case 0: /* direct */
652
                h263_encode_motion(s, motion_x, 1);
653
                h263_encode_motion(s, motion_y, 1);                
654
                s->b_count++;
655
                s->f_count++;
656
                break;
657
            case 1: /* bidir */
658
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
659
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
660
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
661
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
662
                s->last_mv[0][0][0]= s->mv[0][0][0];
663
                s->last_mv[0][0][1]= s->mv[0][0][1];
664
                s->last_mv[1][0][0]= s->mv[1][0][0];
665
                s->last_mv[1][0][1]= s->mv[1][0][1];
666
                s->b_count++;
667
                s->f_count++;
668
                break;
669
            case 2: /* backward */
670
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
671
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
672
                s->last_mv[1][0][0]= motion_x;
673
                s->last_mv[1][0][1]= motion_y;
674
                s->b_count++;
675
                break;
676
            case 3: /* forward */
677
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
678
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
679
                s->last_mv[0][0][0]= motion_x;
680
                s->last_mv[0][0][1]= motion_y;
681
                s->f_count++;
682
                break;
683
            default:
684
                printf("unknown mb type\n");
685
                return;
686
            }
687

    
688
            if(interleaved_stats){
689
                s->mv_bits+= get_bits_diff(s);
690
            }
691

    
692
            /* encode each block */
693
            for (i = 0; i < 6; i++) {
694
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
695
            }
696

    
697
            if(interleaved_stats){
698
                s->p_tex_bits+= get_bits_diff(s);
699
            }
700
        }else{ /* s->pict_type==B_TYPE */
701
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
702
                /* check if the B frames can skip it too, as we must skip it if we skip here 
703
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
704
                if(s->max_b_frames>0){
705
                    int i;
706
                    int x,y, offset;
707
                    uint8_t *p_pic;
708

    
709
                    x= s->mb_x*16;
710
                    y= s->mb_y*16;
711
                    if(x+16 > s->width)  x= s->width-16;
712
                    if(y+16 > s->height) y= s->height-16;
713

    
714
                    offset= x + y*s->linesize;
715
                    p_pic= s->new_picture.data[0] + offset;
716
                    
717
                    s->mb_skiped=1;
718
                    for(i=0; i<s->max_b_frames; i++){
719
                        uint8_t *b_pic;
720
                        int diff;
721
                        Picture *pic= s->reordered_input_picture[i+1];
722

    
723
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
724

    
725
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
726
                        diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
727
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
728
                            s->mb_skiped=0;
729
                            break;
730
                        }
731
                    }
732
                }else
733
                    s->mb_skiped=1; 
734

    
735
                if(s->mb_skiped==1){
736
                    /* skip macroblock */
737
                    put_bits(&s->pb, 1, 1);
738

    
739
                    if(interleaved_stats){
740
                        s->misc_bits++;
741
                        s->last_bits++;
742
                    }
743
                    s->skip_count++;
744
                    
745
                    return;
746
                }
747
            }
748

    
749
            put_bits(&s->pb, 1, 0);        /* mb coded */
750
            if(s->mv_type==MV_TYPE_16X16){
751
                cbpc = cbp & 3;
752
                if(s->dquant) cbpc+= 8;
753
                put_bits(&s->pb,
754
                        inter_MCBPC_bits[cbpc],
755
                        inter_MCBPC_code[cbpc]);
756

    
757
                cbpy = cbp >> 2;
758
                cbpy ^= 0xf;
759
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
760
                if(s->dquant)
761
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
762

    
763
                if(!s->progressive_sequence){
764
                    if(cbp)
765
                        put_bits(pb2, 1, s->interlaced_dct);
766
                    put_bits(pb2, 1, 0); // no interlaced ME yet
767
                }
768
                    
769
                if(interleaved_stats){
770
                    s->misc_bits+= get_bits_diff(s);
771
                }
772

    
773
                /* motion vectors: 16x16 mode */
774
                h263_pred_motion(s, 0, &pred_x, &pred_y);
775
            
776
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
777
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
778
            }else{
779
                cbpc = (cbp & 3)+16;
780
                put_bits(&s->pb,
781
                        inter_MCBPC_bits[cbpc],
782
                        inter_MCBPC_code[cbpc]);
783
                cbpy = cbp >> 2;
784
                cbpy ^= 0xf;
785
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
786

    
787
                if(!s->progressive_sequence){
788
                    if(cbp)
789
                        put_bits(pb2, 1, s->interlaced_dct);
790
                }
791
    
792
                if(interleaved_stats){
793
                    s->misc_bits+= get_bits_diff(s);
794
                }
795

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

    
800
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
801
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
802
                }
803
            }
804

    
805
            if(interleaved_stats){ 
806
                s->mv_bits+= get_bits_diff(s);
807
            }
808

    
809
            /* encode each block */
810
            for (i = 0; i < 6; i++) {
811
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
812
            }
813

    
814
            if(interleaved_stats){
815
                s->p_tex_bits+= get_bits_diff(s);
816
            }
817
            s->f_count++;
818
        }
819
    } else {
820
        int cbp;
821
        int dc_diff[6];   //dc values with the dc prediction subtracted 
822
        int dir[6];  //prediction direction
823
        int zigzag_last_index[6];
824
        uint8_t *scan_table[6];
825
        int i;
826

    
827
        for(i=0; i<6; i++){
828
            const int level= block[i][0];
829
            uint16_t *dc_ptr;
830

    
831
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
832
            if (i < 4) {
833
                *dc_ptr = level * s->y_dc_scale;
834
            } else {
835
                *dc_ptr = level * s->c_dc_scale;
836
            }
837
        }
838

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

    
841
        if(s->ac_pred){
842
            for(i=0; i<6; i++){
843
                uint8_t *st;
844
                int last_index;
845

    
846
                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
847
                if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
848
                else           st = s->intra_h_scantable.permutated; /* top */
849

    
850
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
851
                    if(block[i][st[last_index]]) break;
852
                zigzag_last_index[i]= s->block_last_index[i];
853
                s->block_last_index[i]= last_index;
854
                scan_table[i]= st;
855
            }
856
        }else{
857
            for(i=0; i<6; i++)
858
                scan_table[i]= s->intra_scantable.permutated;
859
        }
860

    
861
        /* compute cbp */
862
        cbp = 0;
863
        for (i = 0; i < 6; i++) {
864
            if (s->block_last_index[i] >= 1)
865
                cbp |= 1 << (5 - i);
866
        }
867

    
868
        cbpc = cbp & 3;
869
        if (s->pict_type == I_TYPE) {
870
            if(s->dquant) cbpc+=4;
871
            put_bits(&s->pb,
872
                intra_MCBPC_bits[cbpc],
873
                intra_MCBPC_code[cbpc]);
874
        } else {
875
            if(s->dquant) cbpc+=8;
876
            put_bits(&s->pb, 1, 0);        /* mb coded */
877
            put_bits(&s->pb,
878
                inter_MCBPC_bits[cbpc + 4],
879
                inter_MCBPC_code[cbpc + 4]);
880
        }
881
        put_bits(pb2, 1, s->ac_pred);
882
        cbpy = cbp >> 2;
883
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
884
        if(s->dquant)
885
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
886

    
887
        if(!s->progressive_sequence){
888
            put_bits(dc_pb, 1, s->interlaced_dct);
889
        }
890

    
891
        if(interleaved_stats){
892
            s->misc_bits+= get_bits_diff(s);
893
        }
894

    
895
        /* encode each block */
896
        for (i = 0; i < 6; i++) {
897
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
898
        }
899

    
900
        if(interleaved_stats){
901
            s->i_tex_bits+= get_bits_diff(s);
902
        }
903
        s->i_count++;
904

    
905
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
906
        if(s->ac_pred){
907
            for(i=0; i<6; i++){
908
                int j;    
909
                int16_t *ac_val;
910

    
911
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
912

    
913
                if(dir[i]){
914
                    for(j=1; j<8; j++) 
915
                        block[i][s->dsp.idct_permutation[j   ]]= ac_val[j+8];
916
                }else{
917
                    for(j=1; j<8; j++) 
918
                        block[i][s->dsp.idct_permutation[j<<3]]= ac_val[j  ];
919
                }
920
                s->block_last_index[i]= zigzag_last_index[i];
921
            }
922
        }
923
    }
924
}
925

    
926
void h263_encode_mb(MpegEncContext * s,
927
                    DCTELEM block[6][64],
928
                    int motion_x, int motion_y)
929
{
930
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
931
    int16_t pred_dc;
932
    int16_t rec_intradc[6];
933
    uint16_t *dc_ptr[6];
934
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
935
    const int dquant_code[5]= {1,0,9,2,3};
936
           
937
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
938
    if (!s->mb_intra) {
939
        /* compute cbp */
940
        cbp = 0;
941
        for (i = 0; i < 6; i++) {
942
            if (s->block_last_index[i] >= 0)
943
                cbp |= 1 << (5 - i);
944
        }
945
        if ((cbp | motion_x | motion_y | s->dquant) == 0) {
946
            /* skip macroblock */
947
            put_bits(&s->pb, 1, 1);
948
            if(interleaved_stats){
949
                s->misc_bits++;
950
                s->last_bits++;
951
            }
952
            return;
953
        }
954
        put_bits(&s->pb, 1, 0);        /* mb coded */
955
        cbpc = cbp & 3;
956
        if(s->dquant) cbpc+= 8;
957
        put_bits(&s->pb,
958
                    inter_MCBPC_bits[cbpc],
959
                    inter_MCBPC_code[cbpc]);
960
        cbpy = cbp >> 2;
961
        cbpy ^= 0xf;
962
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
963
        if(s->dquant)
964
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
965

    
966
        if(interleaved_stats){
967
            s->misc_bits+= get_bits_diff(s);
968
        }
969

    
970
        /* motion vectors: 16x16 mode only now */
971
        h263_pred_motion(s, 0, &pred_x, &pred_y);
972
      
973
        if (!s->umvplus) {  
974
            h263_encode_motion(s, motion_x - pred_x, s->f_code);
975
            h263_encode_motion(s, motion_y - pred_y, s->f_code);
976
        }
977
        else {
978
            h263p_encode_umotion(s, motion_x - pred_x);
979
            h263p_encode_umotion(s, motion_y - pred_y);
980
            if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
981
                /* To prevent Start Code emulation */
982
                put_bits(&s->pb,1,1);
983
        }
984

    
985
        if(interleaved_stats){
986
            s->mv_bits+= get_bits_diff(s);
987
        }
988
    } else {
989
        int li = s->h263_aic ? 0 : 1;
990
        
991
        cbp = 0;
992
        for(i=0; i<6; i++) {
993
            /* Predict DC */
994
            if (s->h263_aic && s->mb_intra) {
995
                int16_t level = block[i][0];
996
            
997
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
998
                level -= pred_dc;
999
                /* Quant */
1000
                if (level < 0)
1001
                    level = (level + (s->qscale >> 1))/(s->y_dc_scale);
1002
                else
1003
                    level = (level - (s->qscale >> 1))/(s->y_dc_scale);
1004
                    
1005
                /* AIC can change CBP */
1006
                if (level == 0 && s->block_last_index[i] == 0)
1007
                    s->block_last_index[i] = -1;
1008
                else if (level < -127)
1009
                    level = -127;
1010
                else if (level > 127)
1011
                    level = 127;
1012
                
1013
                block[i][0] = level;
1014
                /* Reconstruction */ 
1015
                rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
1016
                /* Oddify */
1017
                rec_intradc[i] |= 1;
1018
                //if ((rec_intradc[i] % 2) == 0)
1019
                //    rec_intradc[i]++;
1020
                /* Clipping */
1021
                if (rec_intradc[i] < 0)
1022
                    rec_intradc[i] = 0;
1023
                else if (rec_intradc[i] > 2047)
1024
                    rec_intradc[i] = 2047;
1025
                                
1026
                /* Update AC/DC tables */
1027
                *dc_ptr[i] = rec_intradc[i];
1028
            }
1029
            /* compute cbp */
1030
            if (s->block_last_index[i] >= li)
1031
                cbp |= 1 << (5 - i);
1032
        }
1033

    
1034
        cbpc = cbp & 3;
1035
        if (s->pict_type == I_TYPE) {
1036
            if(s->dquant) cbpc+=4;
1037
            put_bits(&s->pb,
1038
                intra_MCBPC_bits[cbpc],
1039
                intra_MCBPC_code[cbpc]);
1040
        } else {
1041
            if(s->dquant) cbpc+=8;
1042
            put_bits(&s->pb, 1, 0);        /* mb coded */
1043
            put_bits(&s->pb,
1044
                inter_MCBPC_bits[cbpc + 4],
1045
                inter_MCBPC_code[cbpc + 4]);
1046
        }
1047
        if (s->h263_aic) {
1048
            /* XXX: currently, we do not try to use ac prediction */
1049
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
1050
        }
1051
        cbpy = cbp >> 2;
1052
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1053
        if(s->dquant)
1054
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1055

    
1056
        if(interleaved_stats){
1057
            s->misc_bits+= get_bits_diff(s);
1058
        }
1059
    }
1060

    
1061
    for(i=0; i<6; i++) {
1062
        /* encode each block */
1063
        h263_encode_block(s, block[i], i);
1064
    
1065
        /* Update INTRADC for decoding */
1066
        if (s->h263_aic && s->mb_intra) {
1067
            block[i][0] = rec_intradc[i];
1068
            
1069
        }
1070
    }
1071

    
1072
    if(interleaved_stats){
1073
        if (!s->mb_intra) {
1074
            s->p_tex_bits+= get_bits_diff(s);
1075
            s->f_count++;
1076
        }else{
1077
            s->i_tex_bits+= get_bits_diff(s);
1078
            s->i_count++;
1079
        }
1080
    }
1081
}
1082
#endif
1083

    
1084
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1085
{
1086
    int x, y, wrap, a, c, pred_dc, scale;
1087
    int16_t *dc_val, *ac_val;
1088

    
1089
    /* find prediction */
1090
    if (n < 4) {
1091
        x = 2 * s->mb_x + 1 + (n & 1);
1092
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1093
        wrap = s->mb_width * 2 + 2;
1094
        dc_val = s->dc_val[0];
1095
        ac_val = s->ac_val[0][0];
1096
        scale = s->y_dc_scale;
1097
    } else {
1098
        x = s->mb_x + 1;
1099
        y = s->mb_y + 1;
1100
        wrap = s->mb_width + 2;
1101
        dc_val = s->dc_val[n - 4 + 1];
1102
        ac_val = s->ac_val[n - 4 + 1][0];
1103
        scale = s->c_dc_scale;
1104
    }
1105
    /* B C
1106
     * A X 
1107
     */
1108
    a = dc_val[(x - 1) + (y) * wrap];
1109
    c = dc_val[(x) + (y - 1) * wrap];
1110
    
1111
    /* No prediction outside GOB boundary */
1112
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1113
        c = 1024;
1114
    pred_dc = 1024;
1115
    /* just DC prediction */
1116
    if (a != 1024 && c != 1024)
1117
        pred_dc = (a + c) >> 1;
1118
    else if (a != 1024)
1119
        pred_dc = a;
1120
    else
1121
        pred_dc = c;
1122
    
1123
    /* we assume pred is positive */
1124
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1125
    *dc_val_ptr = &dc_val[x + y * wrap];
1126
    return pred_dc;
1127
}
1128

    
1129
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1130
{
1131
    int x, y, wrap, a, c, pred_dc, scale, i;
1132
    int16_t *dc_val, *ac_val, *ac_val1;
1133

    
1134
    /* find prediction */
1135
    if (n < 4) {
1136
        x = 2 * s->mb_x + 1 + (n & 1);
1137
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1138
        wrap = s->mb_width * 2 + 2;
1139
        dc_val = s->dc_val[0];
1140
        ac_val = s->ac_val[0][0];
1141
        scale = s->y_dc_scale;
1142
    } else {
1143
        x = s->mb_x + 1;
1144
        y = s->mb_y + 1;
1145
        wrap = s->mb_width + 2;
1146
        dc_val = s->dc_val[n - 4 + 1];
1147
        ac_val = s->ac_val[n - 4 + 1][0];
1148
        scale = s->c_dc_scale;
1149
    }
1150
    
1151
    ac_val += ((y) * wrap + (x)) * 16;
1152
    ac_val1 = ac_val;
1153
    
1154
    /* B C
1155
     * A X 
1156
     */
1157
    a = dc_val[(x - 1) + (y) * wrap];
1158
    c = dc_val[(x) + (y - 1) * wrap];
1159
    
1160
    /* No prediction outside GOB boundary */
1161
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1162
        c = 1024;
1163
    pred_dc = 1024;
1164
    if (s->ac_pred) {
1165
        if (s->h263_aic_dir) {
1166
            /* left prediction */
1167
            if (a != 1024) {
1168
                ac_val -= 16;
1169
                for(i=1;i<8;i++) {
1170
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1171
                }
1172
                pred_dc = a;
1173
            }
1174
        } else {
1175
            /* top prediction */
1176
            if (c != 1024) {
1177
                ac_val -= 16 * wrap;
1178
                for(i=1;i<8;i++) {
1179
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1180
                }
1181
                pred_dc = c;
1182
            }
1183
        }
1184
    } else {
1185
        /* just DC prediction */
1186
        if (a != 1024 && c != 1024)
1187
            pred_dc = (a + c) >> 1;
1188
        else if (a != 1024)
1189
            pred_dc = a;
1190
        else
1191
            pred_dc = c;
1192
    }
1193
    
1194
    /* we assume pred is positive */
1195
    block[0]=block[0]*scale + pred_dc;
1196
    
1197
    if (block[0] < 0)
1198
        block[0] = 0;
1199
    else if (!(block[0] & 1))
1200
        block[0]++;
1201
    
1202
    /* Update AC/DC tables */
1203
    dc_val[(x) + (y) * wrap] = block[0];
1204
    
1205
    /* left copy */
1206
    for(i=1;i<8;i++)
1207
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1208
    /* top copy */
1209
    for(i=1;i<8;i++)
1210
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1211
}
1212

    
1213
int16_t *h263_pred_motion(MpegEncContext * s, int block, 
1214
                        int *px, int *py)
1215
{
1216
    int xy, wrap;
1217
    int16_t *A, *B, *C, *mot_val;
1218
    static const int off[4]= {2, 1, 1, -1};
1219

    
1220
    wrap = s->block_wrap[0];
1221
    xy = s->block_index[block];
1222

    
1223
    mot_val = s->motion_val[xy];
1224

    
1225
    A = s->motion_val[xy - 1];
1226
    /* special case for first (slice) line */
1227
    if (s->first_slice_line && block<3) {
1228
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1229
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1230
        if(block==0){ //most common case
1231
            if(s->mb_x  == s->resync_mb_x){ //rare
1232
                *px= *py = 0;
1233
            }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1234
                C = s->motion_val[xy + off[block] - wrap];
1235
                if(s->mb_x==0){
1236
                    *px = C[0];
1237
                    *py = C[1];
1238
                }else{
1239
                    *px = mid_pred(A[0], 0, C[0]);
1240
                    *py = mid_pred(A[1], 0, C[1]);
1241
                }
1242
            }else{
1243
                *px = A[0];
1244
                *py = A[1];
1245
            }
1246
        }else if(block==1){
1247
            if(s->mb_x + 1 == s->resync_mb_x){ //rare
1248
                C = s->motion_val[xy + off[block] - wrap];
1249
                *px = mid_pred(A[0], 0, C[0]);
1250
                *py = mid_pred(A[1], 0, C[1]);
1251
            }else{
1252
                *px = A[0];
1253
                *py = A[1];
1254
            }
1255
        }else{ /* block==2*/
1256
            B = s->motion_val[xy - wrap];
1257
            C = s->motion_val[xy + off[block] - wrap];
1258
            if(s->mb_x == s->resync_mb_x) //rare
1259
                A[0]=A[1]=0;
1260
    
1261
            *px = mid_pred(A[0], B[0], C[0]);
1262
            *py = mid_pred(A[1], B[1], C[1]);
1263
        }
1264
    } else {
1265
        B = s->motion_val[xy - wrap];
1266
        C = s->motion_val[xy + off[block] - wrap];
1267
        *px = mid_pred(A[0], B[0], C[0]);
1268
        *py = mid_pred(A[1], B[1], C[1]);
1269
    }
1270
    return mot_val;
1271
}
1272

    
1273
#ifdef CONFIG_ENCODERS
1274
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1275
{
1276
    int range, l, bit_size, sign, code, bits;
1277

    
1278
    if (val == 0) {
1279
        /* zero vector */
1280
        code = 0;
1281
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1282
    } else {
1283
        bit_size = f_code - 1;
1284
        range = 1 << bit_size;
1285
        /* modulo encoding */
1286
        l = range * 32;
1287
#if 1
1288
        val+= l;
1289
        val&= 2*l-1;
1290
        val-= l;
1291
        sign = val>>31;
1292
        val= (val^sign)-sign;
1293
        sign&=1;
1294
#else
1295
        if (val < -l) {
1296
            val += 2*l;
1297
        } else if (val >= l) {
1298
            val -= 2*l;
1299
        }
1300

    
1301
        assert(val>=-l && val<l);
1302

    
1303
        if (val >= 0) {
1304
            sign = 0;
1305
        } else {
1306
            val = -val;
1307
            sign = 1;
1308
        }
1309
#endif
1310
        val--;
1311
        code = (val >> bit_size) + 1;
1312
        bits = val & (range - 1);
1313

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

    
1320
}
1321

    
1322
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1323
static void h263p_encode_umotion(MpegEncContext * s, int val)
1324
{
1325
    short sval = 0; 
1326
    short i = 0;
1327
    short n_bits = 0;
1328
    short temp_val;
1329
    int code = 0;
1330
    int tcode;
1331
    
1332
    if ( val == 0)
1333
        put_bits(&s->pb, 1, 1);
1334
    else if (val == 1)
1335
        put_bits(&s->pb, 3, 0);
1336
    else if (val == -1)
1337
        put_bits(&s->pb, 3, 2);
1338
    else {
1339
        
1340
        sval = ((val < 0) ? (short)(-val):(short)val);
1341
        temp_val = sval;
1342
        
1343
        while (temp_val != 0) {
1344
            temp_val = temp_val >> 1;
1345
            n_bits++;
1346
        }
1347
        
1348
        i = n_bits - 1;
1349
        while (i > 0) {
1350
            tcode = (sval & (1 << (i-1))) >> (i-1);
1351
            tcode = (tcode << 1) | 1;
1352
            code = (code << 2) | tcode;
1353
            i--;
1354
        }
1355
        code = ((code << 1) | (val < 0)) << 1;
1356
        put_bits(&s->pb, (2*n_bits)+1, code);
1357
        //printf("\nVal = %d\tCode = %d", sval, code);
1358
    }
1359
}
1360

    
1361
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1362
{
1363
    int f_code;
1364
    int mv;
1365
    
1366
    if(mv_penalty==NULL)
1367
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1368
    
1369
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1370
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1371
            int len;
1372

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

    
1377
                bit_size = s->f_code - 1;
1378
                range = 1 << bit_size;
1379

    
1380
                val=mv;
1381
                if (val < 0) 
1382
                    val = -val;
1383
                val--;
1384
                code = (val >> bit_size) + 1;
1385
                if(code<33){
1386
                    len= mvtab[code][1] + 1 + bit_size;
1387
                }else{
1388
                    len= mvtab[32][1] + 2 + bit_size;
1389
                }
1390
            }
1391

    
1392
            mv_penalty[f_code][mv+MAX_MV]= len;
1393
        }
1394
    }
1395

    
1396
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1397
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1398
            fcode_tab[mv+MAX_MV]= f_code;
1399
        }
1400
    }
1401

    
1402
    for(mv=0; mv<MAX_MV*2+1; mv++){
1403
        umv_fcode_tab[mv]= 1;
1404
    }
1405
}
1406
#endif
1407

    
1408
#ifdef CONFIG_ENCODERS
1409

    
1410
static void init_uni_dc_tab(void)
1411
{
1412
    int level, uni_code, uni_len;
1413

    
1414
    for(level=-256; level<256; level++){
1415
        int size, v, l;
1416
        /* find number of bits */
1417
        size = 0;
1418
        v = abs(level);
1419
        while (v) {
1420
            v >>= 1;
1421
            size++;
1422
        }
1423

    
1424
        if (level < 0)
1425
            l= (-level) ^ ((1 << size) - 1);
1426
        else
1427
            l= level;
1428

    
1429
        /* luminance */
1430
        uni_code= DCtab_lum[size][0];
1431
        uni_len = DCtab_lum[size][1];
1432

    
1433
        if (size > 0) {
1434
            uni_code<<=size; uni_code|=l;
1435
            uni_len+=size;
1436
            if (size > 8){
1437
                uni_code<<=1; uni_code|=1;
1438
                uni_len++;
1439
            }
1440
        }
1441
        uni_DCtab_lum_bits[level+256]= uni_code;
1442
        uni_DCtab_lum_len [level+256]= uni_len;
1443

    
1444
        /* chrominance */
1445
        uni_code= DCtab_chrom[size][0];
1446
        uni_len = DCtab_chrom[size][1];
1447
        
1448
        if (size > 0) {
1449
            uni_code<<=size; uni_code|=l;
1450
            uni_len+=size;
1451
            if (size > 8){
1452
                uni_code<<=1; uni_code|=1;
1453
                uni_len++;
1454
            }
1455
        }
1456
        uni_DCtab_chrom_bits[level+256]= uni_code;
1457
        uni_DCtab_chrom_len [level+256]= uni_len;
1458

    
1459
    }
1460
}
1461

    
1462
#endif //CONFIG_ENCODERS
1463

    
1464
#ifdef CONFIG_ENCODERS
1465
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1466
    int slevel, run, last;
1467
    
1468
    assert(MAX_LEVEL >= 64);
1469
    assert(MAX_RUN   >= 63);
1470

    
1471
    for(slevel=-64; slevel<64; slevel++){
1472
        if(slevel==0) continue;
1473
        for(run=0; run<64; run++){
1474
            for(last=0; last<=1; last++){
1475
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1476
                int level= slevel < 0 ? -slevel : slevel;
1477
                int sign= slevel < 0 ? 1 : 0;
1478
                int bits, len, code;
1479
                int level1, run1;
1480
                
1481
                len_tab[index]= 100;
1482
                     
1483
                /* ESC0 */
1484
                code= get_rl_index(rl, last, run, level);
1485
                bits= rl->table_vlc[code][0];
1486
                len=  rl->table_vlc[code][1];
1487
                bits=bits*2+sign; len++;
1488
                
1489
                if(code!=rl->n && len < len_tab[index]){
1490
                    bits_tab[index]= bits;
1491
                    len_tab [index]= len;
1492
                }
1493
#if 1
1494
                /* ESC1 */
1495
                bits= rl->table_vlc[rl->n][0];
1496
                len=  rl->table_vlc[rl->n][1];
1497
                bits=bits*2;    len++; //esc1
1498
                level1= level - rl->max_level[last][run];
1499
                if(level1>0){
1500
                    code= get_rl_index(rl, last, run, level1);
1501
                    bits<<= rl->table_vlc[code][1];
1502
                    len  += rl->table_vlc[code][1];
1503
                    bits += rl->table_vlc[code][0];
1504
                    bits=bits*2+sign; len++;
1505
                
1506
                    if(code!=rl->n && len < len_tab[index]){
1507
                        bits_tab[index]= bits;
1508
                        len_tab [index]= len;
1509
                    }
1510
                }
1511
#endif 
1512
#if 1
1513
                /* ESC2 */
1514
                bits= rl->table_vlc[rl->n][0];
1515
                len=  rl->table_vlc[rl->n][1];
1516
                bits=bits*4+2;    len+=2; //esc2
1517
                run1 = run - rl->max_run[last][level] - 1;
1518
                if(run1>=0){
1519
                    code= get_rl_index(rl, last, run1, level);
1520
                    bits<<= rl->table_vlc[code][1];
1521
                    len  += rl->table_vlc[code][1];
1522
                    bits += rl->table_vlc[code][0];
1523
                    bits=bits*2+sign; len++;
1524
                
1525
                    if(code!=rl->n && len < len_tab[index]){
1526
                        bits_tab[index]= bits;
1527
                        len_tab [index]= len;
1528
                    }
1529
                }
1530
#endif           
1531
                /* ESC3 */        
1532
                bits= rl->table_vlc[rl->n][0];
1533
                len = rl->table_vlc[rl->n][1];
1534
                bits=bits*4+3;    len+=2; //esc3
1535
                bits=bits*2+last; len++;
1536
                bits=bits*64+run; len+=6;
1537
                bits=bits*2+1;    len++;  //marker
1538
                bits=bits*4096+(slevel&0xfff); len+=12;
1539
                bits=bits*2+1;    len++;  //marker
1540
                
1541
                if(len < len_tab[index]){
1542
                    bits_tab[index]= bits;
1543
                    len_tab [index]= len;
1544
                }
1545
            }
1546
        }
1547
    }
1548
}
1549

    
1550
void h263_encode_init(MpegEncContext *s)
1551
{
1552
    static int done = 0;
1553

    
1554
    if (!done) {
1555
        done = 1;
1556

    
1557
        init_uni_dc_tab();
1558

    
1559
        init_rl(&rl_inter);
1560
        init_rl(&rl_intra);
1561
        init_rl(&rl_intra_aic);
1562
        
1563
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1564
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1565

    
1566
        init_mv_penalty_and_fcode(s);
1567
    }
1568
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1569
    
1570
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1571
    switch(s->codec_id){
1572
    case CODEC_ID_MPEG4:
1573
        s->fcode_tab= fcode_tab;
1574
        s->min_qcoeff= -2048;
1575
        s->max_qcoeff=  2047;
1576
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1577
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1578
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1579
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1580
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
1581
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1582
        s->ac_esc_length= 7+2+1+6+1+12+1;
1583
        break;
1584
    case CODEC_ID_H263P:
1585
        s->fcode_tab= umv_fcode_tab;
1586
        s->min_qcoeff= -127;
1587
        s->max_qcoeff=  127;
1588
        break;
1589
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1590
    case CODEC_ID_FLV1:
1591
        if (s->h263_flv > 1) {
1592
            s->min_qcoeff= -1023;
1593
            s->max_qcoeff=  1023;
1594
        } else {
1595
            s->min_qcoeff= -127;
1596
            s->max_qcoeff=  127;
1597
        }
1598
        s->y_dc_scale_table=
1599
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1600
        break;
1601
    default: //nothing needed default table allready set in mpegvideo.c
1602
        s->min_qcoeff= -127;
1603
        s->max_qcoeff=  127;
1604
        s->y_dc_scale_table=
1605
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1606
    }
1607
}
1608

    
1609
/**
1610
 * encodes a 8x8 block.
1611
 * @param block the 8x8 block
1612
 * @param n block index (0-3 are luma, 4-5 are chroma)
1613
 */
1614
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1615
{
1616
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1617
    RLTable *rl;
1618

    
1619
    rl = &rl_inter;
1620
    if (s->mb_intra && !s->h263_aic) {
1621
        /* DC coef */
1622
        level = block[0];
1623
        /* 255 cannot be represented, so we clamp */
1624
        if (level > 254) {
1625
            level = 254;
1626
            block[0] = 254;
1627
        }
1628
        /* 0 cannot be represented also */
1629
        else if (level < 1) {
1630
            level = 1;
1631
            block[0] = 1;
1632
        }
1633
        if (level == 128) //FIXME check rv10
1634
            put_bits(&s->pb, 8, 0xff);
1635
        else
1636
            put_bits(&s->pb, 8, level & 0xff);
1637
        i = 1;
1638
    } else {
1639
        i = 0;
1640
        if (s->h263_aic && s->mb_intra)
1641
            rl = &rl_intra_aic;
1642
    }
1643
   
1644
    /* AC coefs */
1645
    last_index = s->block_last_index[n];
1646
    last_non_zero = i - 1;
1647
    for (; i <= last_index; i++) {
1648
        j = s->intra_scantable.permutated[i];
1649
        level = block[j];
1650
        if (level) {
1651
            run = i - last_non_zero - 1;
1652
            last = (i == last_index);
1653
            sign = 0;
1654
            slevel = level;
1655
            if (level < 0) {
1656
                sign = 1;
1657
                level = -level;
1658
            }
1659
            code = get_rl_index(rl, last, run, level);
1660
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1661
            if (code == rl->n) {
1662
              if(s->h263_flv <= 1){
1663
                put_bits(&s->pb, 1, last);
1664
                put_bits(&s->pb, 6, run);
1665
                
1666
                assert(slevel != 0);
1667

    
1668
                if(slevel < 128 && slevel > -128) 
1669
                    put_bits(&s->pb, 8, slevel & 0xff);
1670
                else{
1671
                    put_bits(&s->pb, 8, 128);
1672
                    put_bits(&s->pb, 5, slevel & 0x1f);
1673
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
1674
                }
1675
              }else{
1676
                    if(slevel < 64 && slevel > -64) {
1677
                        /* 7-bit level */
1678
                        put_bits(&s->pb, 1, 0);
1679
                        put_bits(&s->pb, 1, last);
1680
                        put_bits(&s->pb, 6, run);
1681

    
1682
                        put_bits(&s->pb, 7, slevel & 0x7f);
1683
                    } else {
1684
                        /* 11-bit level */
1685
                        put_bits(&s->pb, 1, 1);
1686
                        put_bits(&s->pb, 1, last);
1687
                        put_bits(&s->pb, 6, run);
1688

    
1689
                        put_bits(&s->pb, 11, slevel & 0x7ff);
1690
                    }
1691
              }
1692
            } else {
1693
                put_bits(&s->pb, 1, sign);
1694
            }
1695
            last_non_zero = i;
1696
        }
1697
    }
1698
}
1699
#endif
1700

    
1701
#ifdef CONFIG_ENCODERS
1702

    
1703
/***************************************************/
1704
/**
1705
 * add mpeg4 stuffing bits (01...1)
1706
 */
1707
void ff_mpeg4_stuffing(PutBitContext * pbc)
1708
{
1709
    int length;
1710
    put_bits(pbc, 1, 0);
1711
    length= (-get_bit_count(pbc))&7;
1712
    if(length) put_bits(pbc, length, (1<<length)-1);
1713
}
1714

    
1715
/* must be called before writing the header */
1716
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1717
    int time_div, time_mod;
1718

    
1719
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1720
        int dummy;
1721
        av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1722
        
1723
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1724
    }
1725
    
1726
    if(s->current_picture.pts)
1727
        s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1728
    else
1729
        s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
1730
    time_div= s->time/s->time_increment_resolution;
1731
    time_mod= s->time%s->time_increment_resolution;
1732

    
1733
    if(s->pict_type==B_TYPE){
1734
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1735
    }else{
1736
        s->last_time_base= s->time_base;
1737
        s->time_base= time_div;
1738
        s->pp_time= s->time - s->last_non_b_time;
1739
        s->last_non_b_time= s->time;
1740
    }
1741
}
1742

    
1743
static void mpeg4_encode_gop_header(MpegEncContext * s){
1744
    int hours, minutes, seconds;
1745
    
1746
    put_bits(&s->pb, 16, 0);
1747
    put_bits(&s->pb, 16, GOP_STARTCODE);
1748
    
1749
    seconds= s->time/s->time_increment_resolution;
1750
    minutes= seconds/60; seconds %= 60;
1751
    hours= minutes/60; minutes %= 60;
1752
    hours%=24;
1753

    
1754
    put_bits(&s->pb, 5, hours);
1755
    put_bits(&s->pb, 6, minutes);
1756
    put_bits(&s->pb, 1, 1);
1757
    put_bits(&s->pb, 6, seconds);
1758
    
1759
    put_bits(&s->pb, 1, 0); //closed gov == NO
1760
    put_bits(&s->pb, 1, 0); //broken link == NO
1761

    
1762
    ff_mpeg4_stuffing(&s->pb);
1763
}
1764

    
1765
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1766
    int profile_and_level_indication;
1767
    int vo_ver_id;
1768
    
1769
    if(s->max_b_frames || s->quarter_sample){
1770
        profile_and_level_indication= 0xF1; // adv simple level 1
1771
        vo_ver_id= 5;
1772
    }else{
1773
        profile_and_level_indication= 0x01; // simple level 1
1774
        vo_ver_id= 1;
1775
    }
1776
    //FIXME levels
1777

    
1778
    put_bits(&s->pb, 16, 0);
1779
    put_bits(&s->pb, 16, VOS_STARTCODE);
1780

    
1781
    put_bits(&s->pb, 8, profile_and_level_indication);
1782

    
1783
    put_bits(&s->pb, 16, 0);
1784
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1785
    
1786
    put_bits(&s->pb, 1, 1);
1787
        put_bits(&s->pb, 4, vo_ver_id);
1788
        put_bits(&s->pb, 3, 1); //priority
1789
 
1790
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
1791
    
1792
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1793

    
1794
    ff_mpeg4_stuffing(&s->pb);
1795
}
1796

    
1797
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
1798
{
1799
    int vo_ver_id;
1800

    
1801
    if(s->max_b_frames || s->quarter_sample){
1802
        vo_ver_id= 5;
1803
        s->vo_type= ADV_SIMPLE_VO_TYPE;
1804
    }else{
1805
        vo_ver_id= 1;
1806
        s->vo_type= SIMPLE_VO_TYPE;
1807
    }
1808

    
1809
    put_bits(&s->pb, 16, 0);
1810
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
1811
    put_bits(&s->pb, 16, 0);
1812
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
1813

    
1814
    put_bits(&s->pb, 1, 0);                /* random access vol */
1815
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1816
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1817
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1818
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1819
    
1820
    float_aspect_to_info(s, s->avctx->aspect_ratio);
1821

    
1822
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1823
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1824
    {
1825
        put_bits(&s->pb, 8, s->aspected_width);
1826
        put_bits(&s->pb, 8, s->aspected_height);
1827
    }
1828

    
1829
    if(s->low_delay){
1830
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1831
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1832
        put_bits(&s->pb, 1, s->low_delay);
1833
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1834
    }else{
1835
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1836
    }
1837

    
1838
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1839
    put_bits(&s->pb, 1, 1);                /* marker bit */
1840
    
1841
    put_bits(&s->pb, 16, s->time_increment_resolution);
1842
    if (s->time_increment_bits < 1)
1843
        s->time_increment_bits = 1;
1844
    put_bits(&s->pb, 1, 1);                /* marker bit */
1845
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1846
    put_bits(&s->pb, 1, 1);                /* marker bit */
1847
    put_bits(&s->pb, 13, s->width);        /* vol width */
1848
    put_bits(&s->pb, 1, 1);                /* marker bit */
1849
    put_bits(&s->pb, 13, s->height);        /* vol height */
1850
    put_bits(&s->pb, 1, 1);                /* marker bit */
1851
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1852
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1853
    if (vo_ver_id == 1) {
1854
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1855
    }else{
1856
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1857
    }
1858
    
1859
    s->quant_precision=5;
1860
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
1861
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
1862
    if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1863

    
1864
    if (vo_ver_id != 1)
1865
        put_bits(&s->pb, 1, s->quarter_sample);
1866
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1867
    s->resync_marker= s->rtp_mode;
1868
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1869
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1870
    if(s->data_partitioning){
1871
        put_bits(&s->pb, 1, 0);                /* no rvlc */
1872
    }
1873

    
1874
    if (vo_ver_id != 1){
1875
        put_bits(&s->pb, 1, 0);                /* newpred */
1876
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1877
    }
1878
    put_bits(&s->pb, 1, 0);                /* scalability */
1879
    
1880
    ff_mpeg4_stuffing(&s->pb);
1881

    
1882
    /* user data */
1883
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
1884
        put_bits(&s->pb, 16, 0);
1885
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1886
        put_string(&s->pb, LIBAVCODEC_IDENT);
1887
        ff_mpeg4_stuffing(&s->pb);
1888
    }
1889
}
1890

    
1891
/* write mpeg4 VOP header */
1892
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1893
{
1894
    int time_incr;
1895
    int time_div, time_mod;
1896
    
1897
    if(s->pict_type==I_TYPE){
1898
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1899
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
1900
                mpeg4_encode_visual_object_header(s);
1901
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
1902
                mpeg4_encode_vol_header(s, 0, 0);
1903
        }
1904
        mpeg4_encode_gop_header(s);
1905
    }
1906
    
1907
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1908

    
1909
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1910
    
1911
    put_bits(&s->pb, 16, 0);                /* vop header */
1912
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
1913
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1914

    
1915
    time_div= s->time/s->time_increment_resolution;
1916
    time_mod= s->time%s->time_increment_resolution;
1917
    time_incr= time_div - s->last_time_base;
1918
    while(time_incr--)
1919
        put_bits(&s->pb, 1, 1);
1920
        
1921
    put_bits(&s->pb, 1, 0);
1922

    
1923
    put_bits(&s->pb, 1, 1);        /* marker */
1924
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1925
    put_bits(&s->pb, 1, 1);        /* marker */
1926
    put_bits(&s->pb, 1, 1);        /* vop coded */
1927
    if (    s->pict_type == P_TYPE 
1928
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1929
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1930
    }
1931
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1932
    if(!s->progressive_sequence){
1933
         put_bits(&s->pb, 1, s->top_field_first);
1934
         put_bits(&s->pb, 1, s->alternate_scan);
1935
    }
1936
    //FIXME sprite stuff
1937

    
1938
    put_bits(&s->pb, 5, s->qscale);
1939

    
1940
    if (s->pict_type != I_TYPE)
1941
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1942
    if (s->pict_type == B_TYPE)
1943
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1944
    //    printf("****frame %d\n", picture_number);
1945

    
1946
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
1947
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1948
}
1949

    
1950
#endif //CONFIG_ENCODERS
1951

    
1952
/**
1953
 * change qscale by given dquant and update qscale dependant variables.
1954
 */
1955
static void change_qscale(MpegEncContext * s, int dquant)
1956
{
1957
    s->qscale += dquant;
1958

    
1959
    if (s->qscale < 1)
1960
        s->qscale = 1;
1961
    else if (s->qscale > 31)
1962
        s->qscale = 31;
1963

    
1964
    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1965
    s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1966
}
1967

    
1968
/**
1969
 * predicts the dc.
1970
 * @param n block index (0-3 are luma, 4-5 are chroma)
1971
 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
1972
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
1973
 * @return the quantized predicted dc
1974
 */
1975
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
1976
{
1977
    int a, b, c, wrap, pred, scale;
1978
    uint16_t *dc_val;
1979

    
1980
    /* find prediction */
1981
    if (n < 4) {
1982
        scale = s->y_dc_scale;
1983
    } else {
1984
        scale = s->c_dc_scale;
1985
    }
1986
    if(IS_3IV1)
1987
        scale= 8;
1988

    
1989
    wrap= s->block_wrap[n];
1990
    dc_val = s->dc_val[0] + s->block_index[n];
1991

    
1992
    /* B C
1993
     * A X 
1994
     */
1995
    a = dc_val[ - 1];
1996
    b = dc_val[ - 1 - wrap];
1997
    c = dc_val[ - wrap];
1998

    
1999
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2000
    if(s->first_slice_line && n!=3){
2001
        if(n!=2) b=c= 1024;
2002
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2003
    }
2004
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2005
        if(n==0 || n==4 || n==5)
2006
            b=1024;
2007
    }
2008

    
2009
    if (abs(a - b) < abs(b - c)) {
2010
        pred = c;
2011
        *dir_ptr = 1; /* top */
2012
    } else {
2013
        pred = a;
2014
        *dir_ptr = 0; /* left */
2015
    }
2016
    /* we assume pred is positive */
2017
    pred = FASTDIV((pred + (scale >> 1)), scale);
2018

    
2019
    /* prepare address for prediction update */
2020
    *dc_val_ptr = &dc_val[0];
2021

    
2022
    return pred;
2023
}
2024

    
2025
/**
2026
 * predicts the ac.
2027
 * @param n block index (0-3 are luma, 4-5 are chroma)
2028
 * @param dir the ac prediction direction
2029
 */
2030
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2031
                   int dir)
2032
{
2033
    int i;
2034
    int16_t *ac_val, *ac_val1;
2035
    int8_t * const qscale_table= s->current_picture.qscale_table;
2036

    
2037
    /* find prediction */
2038
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2039
    ac_val1 = ac_val;
2040
    if (s->ac_pred) {
2041
        if (dir == 0) {
2042
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2043
            /* left prediction */
2044
            ac_val -= 16;
2045
            
2046
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2047
                /* same qscale */
2048
                for(i=1;i<8;i++) {
2049
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2050
                }
2051
            }else{
2052
                /* different qscale, we must rescale */
2053
                for(i=1;i<8;i++) {
2054
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2055
                }
2056
            }
2057
        } else {
2058
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2059
            /* top prediction */
2060
            ac_val -= 16 * s->block_wrap[n];
2061

    
2062
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2063
                /* same qscale */
2064
                for(i=1;i<8;i++) {
2065
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2066
                }
2067
            }else{
2068
                /* different qscale, we must rescale */
2069
                for(i=1;i<8;i++) {
2070
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2071
                }
2072
            }
2073
        }
2074
    }
2075
    /* left copy */
2076
    for(i=1;i<8;i++)
2077
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2078

    
2079
    /* top copy */
2080
    for(i=1;i<8;i++)
2081
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2082

    
2083
}
2084

    
2085
#ifdef CONFIG_ENCODERS
2086

    
2087
static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2088
                              int dir)
2089
{
2090
    int i;
2091
    int16_t *ac_val;
2092
    int8_t * const qscale_table= s->current_picture.qscale_table;
2093

    
2094
    /* find prediction */
2095
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2096
 
2097
    if (dir == 0) {
2098
        const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2099
        /* left prediction */
2100
        ac_val -= 16;
2101
        if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2102
            /* same qscale */
2103
            for(i=1;i<8;i++) {
2104
                block[s->dsp.idct_permutation[i<<3]] -= ac_val[i];
2105
            }
2106
        }else{
2107
            /* different qscale, we must rescale */
2108
            for(i=1;i<8;i++) {
2109
                block[s->dsp.idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2110
            }
2111
        }
2112
    } else {
2113
        const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2114
        /* top prediction */
2115
        ac_val -= 16 * s->block_wrap[n];
2116
        if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2117
            /* same qscale */
2118
            for(i=1;i<8;i++) {
2119
                block[s->dsp.idct_permutation[i]] -= ac_val[i + 8];
2120
            }
2121
        }else{
2122
            /* different qscale, we must rescale */
2123
            for(i=1;i<8;i++) {
2124
                block[s->dsp.idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2125
            }
2126
        }
2127
    }
2128
}
2129

    
2130
/**
2131
 * encodes the dc value.
2132
 * @param n block index (0-3 are luma, 4-5 are chroma)
2133
 */
2134
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2135
{
2136
#if 1
2137
//    if(level<-255 || level>255) printf("dc overflow\n");
2138
    level+=256;
2139
    if (n < 4) {
2140
        /* luminance */
2141
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2142
    } else {
2143
        /* chrominance */
2144
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2145
    }
2146
#else
2147
    int size, v;
2148
    /* find number of bits */
2149
    size = 0;
2150
    v = abs(level);
2151
    while (v) {
2152
        v >>= 1;
2153
        size++;
2154
    }
2155

    
2156
    if (n < 4) {
2157
        /* luminance */
2158
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2159
    } else {
2160
        /* chrominance */
2161
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2162
    }
2163

    
2164
    /* encode remaining bits */
2165
    if (size > 0) {
2166
        if (level < 0)
2167
            level = (-level) ^ ((1 << size) - 1);
2168
        put_bits(&s->pb, size, level);
2169
        if (size > 8)
2170
            put_bits(&s->pb, 1, 1);
2171
    }
2172
#endif
2173
}
2174

    
2175
/**
2176
 * encodes a 8x8 block
2177
 * @param n block index (0-3 are luma, 4-5 are chroma)
2178
 */
2179
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2180
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2181
{
2182
    int i, last_non_zero;
2183
#if 0 //variables for the outcommented version
2184
    int code, sign, last;
2185
#endif
2186
    const RLTable *rl;
2187
    uint32_t *bits_tab;
2188
    uint8_t *len_tab;
2189
    const int last_index = s->block_last_index[n];
2190

    
2191
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2192
        /* mpeg4 based DC predictor */
2193
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2194
        if(last_index<1) return;
2195
        i = 1;
2196
        rl = &rl_intra;
2197
        bits_tab= uni_mpeg4_intra_rl_bits;
2198
        len_tab = uni_mpeg4_intra_rl_len;
2199
    } else {
2200
        if(last_index<0) return;
2201
        i = 0;
2202
        rl = &rl_inter;
2203
        bits_tab= uni_mpeg4_inter_rl_bits;
2204
        len_tab = uni_mpeg4_inter_rl_len;
2205
    }
2206

    
2207
    /* AC coefs */
2208
    last_non_zero = i - 1;
2209
#if 1
2210
    for (; i < last_index; i++) {
2211
        int level = block[ scan_table[i] ];
2212
        if (level) {
2213
            int run = i - last_non_zero - 1;
2214
            level+=64;
2215
            if((level&(~127)) == 0){
2216
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2217
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2218
            }else{ //ESC3
2219
                put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
2220
            }
2221
            last_non_zero = i;
2222
        }
2223
    }
2224
    /*if(i<=last_index)*/{
2225
        int level = block[ scan_table[i] ];
2226
        int run = i - last_non_zero - 1;
2227
        level+=64;
2228
        if((level&(~127)) == 0){
2229
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2230
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2231
        }else{ //ESC3
2232
            put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
2233
        }
2234
    }
2235
#else
2236
    for (; i <= last_index; i++) {
2237
        const int slevel = block[ scan_table[i] ];
2238
        if (slevel) {
2239
            int level;
2240
            int run = i - last_non_zero - 1;
2241
            last = (i == last_index);
2242
            sign = 0;
2243
            level = slevel;
2244
            if (level < 0) {
2245
                sign = 1;
2246
                level = -level;
2247
            }
2248
            code = get_rl_index(rl, last, run, level);
2249
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2250
            if (code == rl->n) {
2251
                int level1, run1;
2252
                level1 = level - rl->max_level[last][run];
2253
                if (level1 < 1) 
2254
                    goto esc2;
2255
                code = get_rl_index(rl, last, run, level1);
2256
                if (code == rl->n) {
2257
                esc2:
2258
                    put_bits(ac_pb, 1, 1);
2259
                    if (level > MAX_LEVEL)
2260
                        goto esc3;
2261
                    run1 = run - rl->max_run[last][level] - 1;
2262
                    if (run1 < 0)
2263
                        goto esc3;
2264
                    code = get_rl_index(rl, last, run1, level);
2265
                    if (code == rl->n) {
2266
                    esc3:
2267
                        /* third escape */
2268
                        put_bits(ac_pb, 1, 1);
2269
                        put_bits(ac_pb, 1, last);
2270
                        put_bits(ac_pb, 6, run);
2271
                        put_bits(ac_pb, 1, 1);
2272
                        put_bits(ac_pb, 12, slevel & 0xfff);
2273
                        put_bits(ac_pb, 1, 1);
2274
                    } else {
2275
                        /* second escape */
2276
                        put_bits(ac_pb, 1, 0);
2277
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2278
                        put_bits(ac_pb, 1, sign);
2279
                    }
2280
                } else {
2281
                    /* first escape */
2282
                    put_bits(ac_pb, 1, 0);
2283
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2284
                    put_bits(ac_pb, 1, sign);
2285
                }
2286
            } else {
2287
                put_bits(ac_pb, 1, sign);
2288
            }
2289
            last_non_zero = i;
2290
        }
2291
    }
2292
#endif
2293
}
2294

    
2295
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2296
                               uint8_t *scan_table)
2297
{
2298
    int i, last_non_zero;
2299
    const RLTable *rl;
2300
    uint8_t *len_tab;
2301
    const int last_index = s->block_last_index[n];
2302
    int len=0;
2303

    
2304
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2305
        /* mpeg4 based DC predictor */
2306
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2307
        if(last_index<1) return len;
2308
        i = 1;
2309
        rl = &rl_intra;
2310
        len_tab = uni_mpeg4_intra_rl_len;
2311
    } else {
2312
        if(last_index<0) return 0;
2313
        i = 0;
2314
        rl = &rl_inter;
2315
        len_tab = uni_mpeg4_inter_rl_len;
2316
    }
2317

    
2318
    /* AC coefs */
2319
    last_non_zero = i - 1;
2320
    for (; i < last_index; i++) {
2321
        int level = block[ scan_table[i] ];
2322
        if (level) {
2323
            int run = i - last_non_zero - 1;
2324
            level+=64;
2325
            if((level&(~127)) == 0){
2326
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2327
                len += len_tab[index];
2328
            }else{ //ESC3
2329
                len += 7+2+1+6+1+12+1;
2330
            }
2331
            last_non_zero = i;
2332
        }
2333
    }
2334
    /*if(i<=last_index)*/{
2335
        int level = block[ scan_table[i] ];
2336
        int run = i - last_non_zero - 1;
2337
        level+=64;
2338
        if((level&(~127)) == 0){
2339
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2340
            len += len_tab[index];
2341
        }else{ //ESC3
2342
            len += 7+2+1+6+1+12+1;
2343
        }
2344
    }
2345
    
2346
    return len;
2347
}
2348

    
2349
#endif
2350

    
2351

    
2352
/***********************************************/
2353
/* decoding */
2354

    
2355
static VLC intra_MCBPC_vlc;
2356
static VLC inter_MCBPC_vlc;
2357
static VLC cbpy_vlc;
2358
static VLC mv_vlc;
2359
static VLC dc_lum, dc_chrom;
2360
static VLC sprite_trajectory;
2361
static VLC mb_type_b_vlc;
2362

    
2363
void init_vlc_rl(RLTable *rl)
2364
{
2365
    int i, q;
2366
    
2367
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2368
             &rl->table_vlc[0][1], 4, 2,
2369
             &rl->table_vlc[0][0], 4, 2);
2370

    
2371
    
2372
    for(q=0; q<32; q++){
2373
        int qmul= q*2;
2374
        int qadd= (q-1)|1;
2375
        
2376
        if(q==0){
2377
            qmul=1;
2378
            qadd=0;
2379
        }
2380
        
2381
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2382
        for(i=0; i<rl->vlc.table_size; i++){
2383
            int code= rl->vlc.table[i][0];
2384
            int len = rl->vlc.table[i][1];
2385
            int level, run;
2386
        
2387
            if(len==0){ // illegal code
2388
                run= 66;
2389
                level= MAX_LEVEL;
2390
            }else if(len<0){ //more bits needed
2391
                run= 0;
2392
                level= code;
2393
            }else{
2394
                if(code==rl->n){ //esc
2395
                    run= 66;
2396
                    level= 0;
2397
                }else{
2398
                    run=   rl->table_run  [code] + 1;
2399
                    level= rl->table_level[code] * qmul + qadd;
2400
                    if(code >= rl->last) run+=192;
2401
                }
2402
            }
2403
            rl->rl_vlc[q][i].len= len;
2404
            rl->rl_vlc[q][i].level= level;
2405
            rl->rl_vlc[q][i].run= run;
2406
        }
2407
    }
2408
}
2409

    
2410
/* init vlcs */
2411

    
2412
/* XXX: find a better solution to handle static init */
2413
void h263_decode_init_vlc(MpegEncContext *s)
2414
{
2415
    static int done = 0;
2416

    
2417
    if (!done) {
2418
        done = 1;
2419

    
2420
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8, 
2421
                 intra_MCBPC_bits, 1, 1,
2422
                 intra_MCBPC_code, 1, 1);
2423
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25, 
2424
                 inter_MCBPC_bits, 1, 1,
2425
                 inter_MCBPC_code, 1, 1);
2426
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2427
                 &cbpy_tab[0][1], 2, 1,
2428
                 &cbpy_tab[0][0], 2, 1);
2429
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2430
                 &mvtab[0][1], 2, 1,
2431
                 &mvtab[0][0], 2, 1);
2432
        init_rl(&rl_inter);
2433
        init_rl(&rl_intra);
2434
        init_rl(&rvlc_rl_inter);
2435
        init_rl(&rvlc_rl_intra);
2436
        init_rl(&rl_intra_aic);
2437
        init_vlc_rl(&rl_inter);
2438
        init_vlc_rl(&rl_intra);
2439
        init_vlc_rl(&rvlc_rl_inter);
2440
        init_vlc_rl(&rvlc_rl_intra);
2441
        init_vlc_rl(&rl_intra_aic);
2442
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2443
                 &DCtab_lum[0][1], 2, 1,
2444
                 &DCtab_lum[0][0], 2, 1);
2445
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2446
                 &DCtab_chrom[0][1], 2, 1,
2447
                 &DCtab_chrom[0][0], 2, 1);
2448
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2449
                 &sprite_trajectory_tab[0][1], 4, 2,
2450
                 &sprite_trajectory_tab[0][0], 4, 2);
2451
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2452
                 &mb_type_b_tab[0][1], 2, 1,
2453
                 &mb_type_b_tab[0][0], 2, 1);
2454
    }
2455
}
2456

    
2457
/**
2458
 * Get the GOB height based on picture height.
2459
 */
2460
int ff_h263_get_gob_height(MpegEncContext *s){
2461
    if (s->height <= 400)
2462
        return 1;
2463
    else if (s->height <= 800)
2464
        return  2;
2465
    else
2466
        return 4;
2467
}
2468

    
2469
/**
2470
 * decodes the group of blocks header.
2471
 * @return <0 if an error occured
2472
 */
2473
static int h263_decode_gob_header(MpegEncContext *s)
2474
{
2475
    unsigned int val, gfid;
2476
    int left;
2477
    
2478
    /* Check for GOB Start Code */
2479
    val = show_bits(&s->gb, 16);
2480
    if(val)
2481
        return -1;
2482

    
2483
        /* We have a GBSC probably with GSTUFF */
2484
    skip_bits(&s->gb, 16); /* Drop the zeros */
2485
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2486
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2487
    for(;left>13; left--){
2488
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2489
    }
2490
    if(left<=13) 
2491
        return -1;
2492

    
2493
#ifdef DEBUG
2494
    fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2495
#endif
2496
    s->gob_number = get_bits(&s->gb, 5); /* GN */
2497
    gfid = get_bits(&s->gb, 2); /* GFID */
2498
    s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2499
    if(s->qscale==0) 
2500
        return -1;
2501
    s->mb_x= 0;
2502
    s->mb_y= s->gob_index* s->gob_number;
2503
    if(s->mb_y >= s->mb_height) 
2504
        return -1;
2505
#ifdef DEBUG
2506
    fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2507
#endif
2508
    return 0;
2509
}
2510

    
2511
static inline void memsetw(short *tab, int val, int n)
2512
{
2513
    int i;
2514
    for(i=0;i<n;i++)
2515
        tab[i] = val;
2516
}
2517

    
2518
#ifdef CONFIG_ENCODERS
2519

    
2520
void ff_mpeg4_init_partitions(MpegEncContext *s)
2521
{
2522
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2523
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
2524
}
2525

    
2526
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2527
{
2528
    const int pb2_len   = get_bit_count(&s->pb2   );
2529
    const int tex_pb_len= get_bit_count(&s->tex_pb);
2530
    const int bits= get_bit_count(&s->pb);
2531

    
2532
    if(s->pict_type==I_TYPE){
2533
        put_bits(&s->pb, 19, DC_MARKER);
2534
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2535
        s->i_tex_bits+= tex_pb_len;
2536
    }else{
2537
        put_bits(&s->pb, 17, MOTION_MARKER);
2538
        s->misc_bits+=17 + pb2_len;
2539
        s->mv_bits+= bits - s->last_bits;
2540
        s->p_tex_bits+= tex_pb_len;
2541
    }
2542

    
2543
    flush_put_bits(&s->pb2);
2544
    flush_put_bits(&s->tex_pb);
2545

    
2546
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2547
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2548
    s->last_bits= get_bit_count(&s->pb);
2549
}
2550

    
2551
#endif //CONFIG_ENCODERS
2552

    
2553
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2554
    switch(s->pict_type){
2555
        case I_TYPE:
2556
            return 16;
2557
        case P_TYPE:
2558
        case S_TYPE:
2559
            return s->f_code+15;
2560
        case B_TYPE:
2561
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2562
        default:
2563
            return -1;
2564
    }
2565
}
2566

    
2567
#ifdef CONFIG_ENCODERS
2568

    
2569
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2570
{
2571
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2572

    
2573
    ff_mpeg4_stuffing(&s->pb);
2574
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2575
    put_bits(&s->pb, 1, 1);
2576
    
2577
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2578
    put_bits(&s->pb, s->quant_precision, s->qscale);
2579
    put_bits(&s->pb, 1, 0); /* no HEC */
2580
}
2581

    
2582
#endif //CONFIG_ENCODERS
2583

    
2584
/**
2585
 * check if the next stuff is a resync marker or the end.
2586
 * @return 0 if not
2587
 */
2588
static inline int mpeg4_is_resync(MpegEncContext *s){
2589
    const int bits_count= get_bits_count(&s->gb);
2590
    
2591
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
2592
        return 0;
2593
    }
2594

    
2595
    if(bits_count + 8 >= s->gb.size_in_bits){
2596
        int v= show_bits(&s->gb, 8);
2597
        v|= 0x7F >> (7-(bits_count&7));
2598
                
2599
        if(v==0x7F)
2600
            return 1;
2601
    }else{
2602
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2603
            int len;
2604
            GetBitContext gb= s->gb;
2605
        
2606
            skip_bits(&s->gb, 1);
2607
            align_get_bits(&s->gb);
2608
        
2609
            for(len=0; len<32; len++){
2610
                if(get_bits1(&s->gb)) break;
2611
            }
2612

    
2613
            s->gb= gb;
2614

    
2615
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2616
                return 1;
2617
        }
2618
    }
2619
    return 0;
2620
}
2621

    
2622
/**
2623
 * decodes the next video packet.
2624
 * @return <0 if something went wrong
2625
 */
2626
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2627
{
2628
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2629
    int header_extension=0, mb_num, len;
2630
    
2631
    /* is there enough space left for a video packet + header */
2632
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2633

    
2634
    for(len=0; len<32; len++){
2635
        if(get_bits1(&s->gb)) break;
2636
    }
2637

    
2638
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2639
        printf("marker does not match f_code\n");
2640
        return -1;
2641
    }
2642
    
2643
    if(s->shape != RECT_SHAPE){
2644
        header_extension= get_bits1(&s->gb);
2645
        //FIXME more stuff here
2646
    }
2647

    
2648
    mb_num= get_bits(&s->gb, mb_num_bits);
2649
    if(mb_num>=s->mb_num){
2650
        fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2651
        return -1;
2652
    }
2653
    if(s->pict_type == B_TYPE){
2654
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
2655
        if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
2656
    }
2657
    
2658
    s->mb_x= mb_num % s->mb_width;
2659
    s->mb_y= mb_num / s->mb_width;
2660

    
2661
    if(s->shape != BIN_ONLY_SHAPE){
2662
        int qscale= get_bits(&s->gb, s->quant_precision); 
2663
        if(qscale)
2664
            s->qscale= qscale;
2665
    }
2666

    
2667
    if(s->shape == RECT_SHAPE){
2668
        header_extension= get_bits1(&s->gb);
2669
    }
2670
    if(header_extension){
2671
        int time_increment;
2672
        int time_incr=0;
2673

    
2674
        while (get_bits1(&s->gb) != 0) 
2675
            time_incr++;
2676

    
2677
        check_marker(&s->gb, "before time_increment in video packed header");
2678
        time_increment= get_bits(&s->gb, s->time_increment_bits);
2679
        check_marker(&s->gb, "before vop_coding_type in video packed header");
2680
        
2681
        skip_bits(&s->gb, 2); /* vop coding type */
2682
        //FIXME not rect stuff here
2683

    
2684
        if(s->shape != BIN_ONLY_SHAPE){
2685
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2686
//FIXME dont just ignore everything
2687
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2688
                mpeg4_decode_sprite_trajectory(s);
2689
                fprintf(stderr, "untested\n");
2690
            }
2691

    
2692
            //FIXME reduced res stuff here
2693
            
2694
            if (s->pict_type != I_TYPE) {
2695
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
2696
                if(f_code==0){
2697
                    printf("Error, video packet header damaged (f_code=0)\n");
2698
                }
2699
            }
2700
            if (s->pict_type == B_TYPE) {
2701
                int b_code = get_bits(&s->gb, 3);
2702
                if(b_code==0){
2703
                    printf("Error, video packet header damaged (b_code=0)\n");
2704
                }
2705
            }       
2706
        }
2707
    }
2708
    //FIXME new-pred stuff
2709
    
2710
//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));
2711

    
2712
    return 0;
2713
}
2714

    
2715
void ff_mpeg4_clean_buffers(MpegEncContext *s)
2716
{
2717
    int c_wrap, c_xy, l_wrap, l_xy;
2718

    
2719
    l_wrap= s->block_wrap[0];
2720
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2721
    c_wrap= s->block_wrap[4];
2722
    c_xy= s->mb_y*c_wrap + s->mb_x;
2723

    
2724
#if 0
2725
    /* clean DC */
2726
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2727
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2728
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2729
#endif
2730

    
2731
    /* clean AC */
2732
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
2733
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2734
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2735

    
2736
    /* clean MV */
2737
    // we cant clear the MVs as they might be needed by a b frame
2738
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2739
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2740
    s->last_mv[0][0][0]=
2741
    s->last_mv[0][0][1]=
2742
    s->last_mv[1][0][0]=
2743
    s->last_mv[1][0][1]= 0;
2744
}
2745

    
2746
/**
2747
 * decodes the group of blocks / video packet header.
2748
 * @return <0 if no resync found
2749
 */
2750
int ff_h263_resync(MpegEncContext *s){
2751
    int left, ret;
2752
    
2753
    if(s->codec_id==CODEC_ID_MPEG4)
2754
        skip_bits1(&s->gb);
2755
    
2756
    align_get_bits(&s->gb);
2757

    
2758
    if(show_bits(&s->gb, 16)==0){
2759
        if(s->codec_id==CODEC_ID_MPEG4)
2760
            ret= mpeg4_decode_video_packet_header(s);
2761
        else
2762
            ret= h263_decode_gob_header(s);
2763
        if(ret>=0)
2764
            return 0;
2765
    }
2766
    //ok, its not where its supposed to be ...
2767
    s->gb= s->last_resync_gb;
2768
    align_get_bits(&s->gb);
2769
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2770
    
2771
    for(;left>16+1+5+5; left-=8){ 
2772
        if(show_bits(&s->gb, 16)==0){
2773
            GetBitContext bak= s->gb;
2774

    
2775
            if(s->codec_id==CODEC_ID_MPEG4)
2776
                ret= mpeg4_decode_video_packet_header(s);
2777
            else
2778
                ret= h263_decode_gob_header(s);
2779
            if(ret>=0)
2780
                return 0;
2781

    
2782
            s->gb= bak;
2783
        }
2784
        skip_bits(&s->gb, 8);
2785
    }
2786
    
2787
    return -1;
2788
}
2789

    
2790
/**
2791
 * gets the average motion vector for a GMC MB.
2792
 * @param n either 0 for the x component or 1 for y
2793
 * @returns the average MV for a GMC MB
2794
 */
2795
static inline int get_amv(MpegEncContext *s, int n){
2796
    int x, y, mb_v, sum, dx, dy, shift;
2797
    int len = 1 << (s->f_code + 4);
2798
    const int a= s->sprite_warping_accuracy;
2799

    
2800
    if(s->real_sprite_warping_points==1){
2801
        if(s->divx_version==500 && s->divx_build==413)
2802
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2803
        else
2804
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2805
    }else{
2806
        dx= s->sprite_delta[n][0];
2807
        dy= s->sprite_delta[n][1];
2808
        shift= s->sprite_shift[0];
2809
        if(n) dy -= 1<<(shift + a + 1);
2810
        else  dx -= 1<<(shift + a + 1);
2811
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2812

    
2813
        sum=0;
2814
        for(y=0; y<16; y++){
2815
            int v;
2816
        
2817
            v= mb_v + dy*y;
2818
            //XXX FIXME optimize
2819
            for(x=0; x<16; x++){
2820
                sum+= v>>shift;
2821
                v+= dx;
2822
            }
2823
        }
2824
        sum= RSHIFT(sum, a+8-s->quarter_sample);
2825
    }
2826

    
2827
    if      (sum < -len) sum= -len;
2828
    else if (sum >= len) sum= len-1;
2829

    
2830
    return sum;
2831
}
2832

    
2833
/**
2834
 * decodes first partition.
2835
 * @return number of MBs decoded or <0 if an error occured
2836
 */
2837
static int mpeg4_decode_partition_a(MpegEncContext *s){
2838
    int mb_num;
2839
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2840
    
2841
    /* decode first partition */
2842
    mb_num=0;
2843
    s->first_slice_line=1;
2844
    for(; s->mb_y<s->mb_height; s->mb_y++){
2845
        ff_init_block_index(s);
2846
        for(; s->mb_x<s->mb_width; s->mb_x++){
2847
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
2848
            int cbpc;
2849
            int dir=0;
2850
            
2851
            mb_num++;
2852
            ff_update_block_index(s);
2853
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2854
                s->first_slice_line=0;
2855
            
2856
            if(s->pict_type==I_TYPE){
2857
                int i;
2858

    
2859
                if(show_bits_long(&s->gb, 19)==DC_MARKER){
2860
                    return mb_num-1;
2861
                }
2862

    
2863
                cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2864
                if (cbpc < 0){
2865

    
2866
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2867
                    return -1;
2868
                }
2869
                s->cbp_table[xy]= cbpc & 3;
2870
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2871
                s->mb_intra = 1;
2872

    
2873
                if(cbpc & 4) {
2874
                    change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2875
                }
2876
                s->current_picture.qscale_table[xy]= s->qscale;
2877

    
2878
                s->mbintra_table[xy]= 1;
2879
                for(i=0; i<6; i++){
2880
                    int dc_pred_dir;
2881
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2882
                    if(dc < 0){
2883
                        fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2884
                        return -1;
2885
                    }
2886
                    dir<<=1;
2887
                    if(dc_pred_dir) dir|=1;
2888
                }
2889
                s->pred_dir_table[xy]= dir;
2890
            }else{ /* P/S_TYPE */
2891
                int mx, my, pred_x, pred_y, bits;
2892
                int16_t * const mot_val= s->motion_val[s->block_index[0]];
2893
                const int stride= s->block_wrap[0]*2;
2894

    
2895
                bits= show_bits(&s->gb, 17);
2896
                if(bits==MOTION_MARKER){
2897
                    return mb_num-1;
2898
                }
2899
                skip_bits1(&s->gb);
2900
                if(bits&0x10000){
2901
                    /* skip mb */
2902
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2903
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
2904
                        mx= get_amv(s, 0);
2905
                        my= get_amv(s, 1);
2906
                    }else{
2907
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
2908
                        mx=my=0;
2909
                    }
2910
                    mot_val[0       ]= mot_val[2       ]=
2911
                    mot_val[0+stride]= mot_val[2+stride]= mx;
2912
                    mot_val[1       ]= mot_val[3       ]=
2913
                    mot_val[1+stride]= mot_val[3+stride]= my;
2914

    
2915
                    if(s->mbintra_table[xy])
2916
                        ff_clean_intra_table_entries(s);
2917
                    continue;
2918
                }
2919
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2920
                if (cbpc < 0){
2921
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2922
                    return -1;
2923
                }
2924
                if (cbpc > 20)
2925
                    cbpc+=3;
2926
                else if (cbpc == 20)
2927
                    fprintf(stderr, "Stuffing !");
2928
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2929
    
2930
                s->mb_intra = ((cbpc & 4) != 0);
2931
        
2932
                if(s->mb_intra){
2933
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2934
                    s->mbintra_table[xy]= 1;
2935
                    mot_val[0       ]= mot_val[2       ]= 
2936
                    mot_val[0+stride]= mot_val[2+stride]= 0;
2937
                    mot_val[1       ]= mot_val[3       ]=
2938
                    mot_val[1+stride]= mot_val[3+stride]= 0;
2939
                }else{
2940
                    if(s->mbintra_table[xy])
2941
                        ff_clean_intra_table_entries(s);
2942

    
2943
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2944
                        s->mcsel= get_bits1(&s->gb);
2945
                    else s->mcsel= 0;
2946
        
2947
                    if ((cbpc & 16) == 0) {
2948
                        /* 16x16 motion prediction */
2949

    
2950
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
2951
                        if(!s->mcsel){
2952
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2953
                            if (mx >= 0xffff)
2954
                                return -1;
2955

    
2956
                            my = h263_decode_motion(s, pred_y, s->f_code);
2957
                            if (my >= 0xffff)
2958
                                return -1;
2959
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
2960
                        } else {
2961
                            mx = get_amv(s, 0);
2962
                            my = get_amv(s, 1);
2963
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
2964
                        }
2965

    
2966
                        mot_val[0       ]= mot_val[2       ] =
2967
                        mot_val[0+stride]= mot_val[2+stride]= mx;
2968
                        mot_val[1       ]= mot_val[3       ]=
2969
                        mot_val[1+stride]= mot_val[3+stride]= my;
2970
                    } else {
2971
                        int i;
2972
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
2973
                        for(i=0;i<4;i++) {
2974
                            int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2975
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2976
                            if (mx >= 0xffff)
2977
                                return -1;
2978
                
2979
                            my = h263_decode_motion(s, pred_y, s->f_code);
2980
                            if (my >= 0xffff)
2981
                                return -1;
2982
                            mot_val[0] = mx;
2983
                            mot_val[1] = my;
2984
                        }
2985
                    }
2986
                }
2987
            }
2988
        }
2989
        s->mb_x= 0;
2990
    }
2991

    
2992
    return mb_num;
2993
}
2994

    
2995
/**
2996
 * decode second partition.
2997
 * @return <0 if an error occured
2998
 */
2999
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3000
    int mb_num=0;
3001
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3002

    
3003
    s->mb_x= s->resync_mb_x;
3004
    s->first_slice_line=1;
3005
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3006
        ff_init_block_index(s);
3007
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3008
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3009

    
3010
            mb_num++;
3011
            ff_update_block_index(s);
3012
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3013
                s->first_slice_line=0;
3014
            
3015
            if(s->pict_type==I_TYPE){
3016
                int ac_pred= get_bits1(&s->gb);
3017
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3018
                if(cbpy<0){
3019
                    fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3020
                    return -1;
3021
                }
3022
                
3023
                s->cbp_table[xy]|= cbpy<<2;
3024
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3025
            }else{ /* P || S_TYPE */
3026
                if(IS_INTRA(s->current_picture.mb_type[xy])){          
3027
                    int dir=0,i;
3028
                    int ac_pred = get_bits1(&s->gb);
3029
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3030

    
3031
                    if(cbpy<0){
3032
                        fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3033
                        return -1;
3034
                    }
3035
                    
3036
                    if(s->cbp_table[xy] & 8) {
3037
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3038
                    }
3039
                    s->current_picture.qscale_table[xy]= s->qscale;
3040

    
3041
                    for(i=0; i<6; i++){
3042
                        int dc_pred_dir;
3043
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3044
                        if(dc < 0){
3045
                            fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3046
                            return -1;
3047
                        }
3048
                        dir<<=1;
3049
                        if(dc_pred_dir) dir|=1;
3050
                    }
3051
                    s->cbp_table[xy]&= 3; //remove dquant
3052
                    s->cbp_table[xy]|= cbpy<<2;
3053
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3054
                    s->pred_dir_table[xy]= dir;
3055
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3056
                    s->current_picture.qscale_table[xy]= s->qscale;
3057
                    s->cbp_table[xy]= 0;
3058
                }else{
3059
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3060

    
3061
                    if(cbpy<0){
3062
                        fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3063
                        return -1;
3064
                    }
3065
                    
3066
                    if(s->cbp_table[xy] & 8) {
3067
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3068
                    }
3069
                    s->current_picture.qscale_table[xy]= s->qscale;
3070

    
3071
                    s->cbp_table[xy]&= 3; //remove dquant
3072
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3073
                }
3074
            }
3075
        }
3076
        if(mb_num >= mb_count) return 0;
3077
        s->mb_x= 0;
3078
    }
3079
    return 0;
3080
}
3081

    
3082
/**
3083
 * decodes the first & second partition
3084
 * @return <0 if error (and sets error type in the error_status_table)
3085
 */
3086
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3087
{
3088
    int mb_num;
3089
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3090
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3091
    
3092
    mb_num= mpeg4_decode_partition_a(s);    
3093
    if(mb_num<0){
3094
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3095
        return -1;
3096
    }
3097
    
3098
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3099
        fprintf(stderr, "slice below monitor ...\n");
3100
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3101
        return -1;
3102
    }
3103

    
3104
    s->mb_num_left= mb_num;
3105
        
3106
    if(s->pict_type==I_TYPE){
3107
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3108
            fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3109
            return -1;
3110
        }
3111
    }else{
3112
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3113
            fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3114
            return -1;
3115
        }
3116
    }
3117
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3118
    
3119
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3120
        if(s->pict_type==P_TYPE)
3121
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3122
        return -1;
3123
    }else{
3124
        if(s->pict_type==P_TYPE)
3125
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3126
    }
3127

    
3128
    return 0;        
3129
}
3130

    
3131
/**
3132
 * decode partition C of one MB.
3133
 * @return <0 if an error occured
3134
 */
3135
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3136
{
3137
    int cbp, mb_type;
3138
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3139

    
3140
    mb_type= s->current_picture.mb_type[xy];
3141
    cbp = s->cbp_table[xy];
3142

    
3143
    if(s->current_picture.qscale_table[xy] != s->qscale){
3144
        s->qscale= s->current_picture.qscale_table[xy];
3145
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3146
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3147
    }
3148
    
3149
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3150
        int i;
3151
        for(i=0; i<4; i++){
3152
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3153
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3154
        }
3155
        s->mb_intra = IS_INTRA(mb_type);
3156

    
3157
        if (IS_SKIP(mb_type)) {
3158
            /* skip mb */
3159
            for(i=0;i<6;i++)
3160
                s->block_last_index[i] = -1;
3161
            s->mv_dir = MV_DIR_FORWARD;
3162
            s->mv_type = MV_TYPE_16X16;
3163
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3164
                s->mcsel=1;
3165
                s->mb_skiped = 0;
3166
            }else{
3167
                s->mcsel=0;
3168
                s->mb_skiped = 1;
3169
            }
3170
        }else if(s->mb_intra){
3171
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3172
        }else if(!s->mb_intra){
3173
//            s->mcsel= 0; //FIXME do we need to init that
3174
            
3175
            s->mv_dir = MV_DIR_FORWARD;
3176
            if (IS_8X8(mb_type)) {
3177
                s->mv_type = MV_TYPE_8X8;
3178
            } else {
3179
                s->mv_type = MV_TYPE_16X16;
3180
            }
3181
        }
3182
    } else { /* I-Frame */
3183
        s->mb_intra = 1;
3184
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3185
    }
3186

    
3187
    if (!IS_SKIP(mb_type)) {
3188
        int i;
3189
        /* decode each block */
3190
        for (i = 0; i < 6; i++) {
3191
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3192
                fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3193
                return -1;
3194
            }
3195
            cbp+=cbp;
3196
        }
3197
    }
3198

    
3199
    /* per-MB end of slice check */
3200

    
3201
    if(--s->mb_num_left <= 0){
3202
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3203
        if(mpeg4_is_resync(s))
3204
            return SLICE_END;
3205
        else
3206
            return SLICE_NOEND;     
3207
    }else{
3208
        if(mpeg4_is_resync(s)){
3209
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3210
            if(s->cbp_table[xy+delta])
3211
                return SLICE_END;
3212
        }
3213
        return SLICE_OK;
3214
    }
3215
}
3216

    
3217
int ff_h263_decode_mb(MpegEncContext *s,
3218
                      DCTELEM block[6][64])
3219
{
3220
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3221
    int16_t *mot_val;
3222
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3223
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3224

    
3225
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3226
        if (get_bits1(&s->gb)) {
3227
            /* skip mb */
3228
            s->mb_intra = 0;
3229
            for(i=0;i<6;i++)
3230
                s->block_last_index[i] = -1;
3231
            s->mv_dir = MV_DIR_FORWARD;
3232
            s->mv_type = MV_TYPE_16X16;
3233
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3234
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3235
                s->mcsel=1;
3236
                s->mv[0][0][0]= get_amv(s, 0);
3237
                s->mv[0][0][1]= get_amv(s, 1);
3238

    
3239
                s->mb_skiped = 0;
3240
            }else{
3241
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3242
                s->mcsel=0;
3243
                s->mv[0][0][0] = 0;
3244
                s->mv[0][0][1] = 0;
3245
                s->mb_skiped = 1;
3246
            }
3247
            goto end;
3248
        }
3249
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3250
        //fprintf(stderr, "\tCBPC: %d", cbpc);
3251
        if (cbpc < 0)
3252
            return -1;
3253
        if (cbpc > 20)
3254
            cbpc+=3;
3255
        else if (cbpc == 20)
3256
            fprintf(stderr, "Stuffing !");
3257
        
3258
        dquant = cbpc & 8;
3259
        s->mb_intra = ((cbpc & 4) != 0);
3260
        if (s->mb_intra) goto intra;
3261
        
3262
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3263
            s->mcsel= get_bits1(&s->gb);
3264
        else s->mcsel= 0;
3265
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3266
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
3267
        if (dquant) {
3268
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3269
        }
3270
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
3271
            s->interlaced_dct= get_bits1(&s->gb);
3272
        
3273
        s->mv_dir = MV_DIR_FORWARD;
3274
        if ((cbpc & 16) == 0) {
3275
            if(s->mcsel){
3276
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3277
                /* 16x16 global motion prediction */
3278
                s->mv_type = MV_TYPE_16X16;
3279
                mx= get_amv(s, 0);
3280
                my= get_amv(s, 1);
3281
                s->mv[0][0][0] = mx;
3282
                s->mv[0][0][1] = my;
3283
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3284
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; 
3285
                /* 16x8 field motion prediction */
3286
                s->mv_type= MV_TYPE_FIELD;
3287

    
3288
                s->field_select[0][0]= get_bits1(&s->gb);
3289
                s->field_select[0][1]= get_bits1(&s->gb);
3290

    
3291
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3292
                
3293
                for(i=0; i<2; i++){
3294
                    mx = h263_decode_motion(s, pred_x, s->f_code);
3295
                    if (mx >= 0xffff)
3296
                        return -1;
3297
            
3298
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
3299
                    if (my >= 0xffff)
3300
                        return -1;
3301

    
3302
                    s->mv[0][i][0] = mx;
3303
                    s->mv[0][i][1] = my;
3304
                }
3305
            }else{
3306
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
3307
                /* 16x16 motion prediction */
3308
                s->mv_type = MV_TYPE_16X16;
3309
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3310
                if (s->umvplus)
3311
                   mx = h263p_decode_umotion(s, pred_x);
3312
                else
3313
                   mx = h263_decode_motion(s, pred_x, s->f_code);
3314
            
3315
                if (mx >= 0xffff)
3316
                    return -1;
3317
            
3318
                if (s->umvplus)
3319
                   my = h263p_decode_umotion(s, pred_y);
3320
                else
3321
                   my = h263_decode_motion(s, pred_y, s->f_code);
3322
            
3323
                if (my >= 0xffff)
3324
                    return -1;
3325
                s->mv[0][0][0] = mx;
3326
                s->mv[0][0][1] = my;
3327

    
3328
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3329
                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3330
            }
3331
        } else {
3332
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3333
            s->mv_type = MV_TYPE_8X8;
3334
            for(i=0;i<4;i++) {
3335
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3336
                if (s->umvplus)
3337
                  mx = h263p_decode_umotion(s, pred_x);
3338
                else
3339
                  mx = h263_decode_motion(s, pred_x, s->f_code);
3340
                if (mx >= 0xffff)
3341
                    return -1;
3342
                
3343
                if (s->umvplus)
3344
                  my = h263p_decode_umotion(s, pred_y);
3345
                else    
3346
                  my = h263_decode_motion(s, pred_y, s->f_code);
3347
                if (my >= 0xffff)
3348
                    return -1;
3349
                s->mv[0][i][0] = mx;
3350
                s->mv[0][i][1] = my;
3351
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3352
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3353
                mot_val[0] = mx;
3354
                mot_val[1] = my;
3355
            }
3356
        }
3357
    } else if(s->pict_type==B_TYPE) {
3358
        int modb1; // first bit of modb
3359
        int modb2; // second bit of modb
3360
        int mb_type;
3361

    
3362
        s->mb_intra = 0; //B-frames never contain intra blocks
3363
        s->mcsel=0;      //     ...               true gmc blocks
3364

    
3365
        if(s->mb_x==0){
3366
            for(i=0; i<2; i++){
3367
                s->last_mv[i][0][0]= 
3368
                s->last_mv[i][0][1]= 
3369
                s->last_mv[i][1][0]= 
3370
                s->last_mv[i][1][1]= 0;
3371
            }
3372
        }
3373

    
3374
        /* if we skipped it in the future P Frame than skip it now too */
3375
        s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
3376

    
3377
        if(s->mb_skiped){
3378
                /* skip mb */
3379
            for(i=0;i<6;i++)
3380
                s->block_last_index[i] = -1;
3381

    
3382
            s->mv_dir = MV_DIR_FORWARD;
3383
            s->mv_type = MV_TYPE_16X16;
3384
            s->mv[0][0][0] = 0;
3385
            s->mv[0][0][1] = 0;
3386
            s->mv[1][0][0] = 0;
3387
            s->mv[1][0][1] = 0;
3388
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 
3389
            goto end;
3390
        }
3391

    
3392
        modb1= get_bits1(&s->gb); 
3393
        if(modb1){
3394
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
3395
            cbp=0;
3396
        }else{
3397
            modb2= get_bits1(&s->gb);
3398
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3399
            if(mb_type<0){
3400
                printf("illegal MB_type\n");
3401
                return -1;
3402
            }
3403
            mb_type= mb_type_b_map[ mb_type ];
3404
            if(modb2) cbp= 0;
3405
            else      cbp= get_bits(&s->gb, 6);
3406

    
3407
            if ((!IS_DIRECT(mb_type)) && cbp) {
3408
                if(get_bits1(&s->gb)){
3409
                    change_qscale(s, get_bits1(&s->gb)*4 - 2);
3410
                }
3411
            }
3412

    
3413
            if(!s->progressive_sequence){
3414
                if(cbp)
3415
                    s->interlaced_dct= get_bits1(&s->gb);
3416

    
3417
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
3418
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
3419
                    mb_type &= ~MB_TYPE_16x16;
3420

    
3421
                    if(USES_LIST(mb_type, 0)){
3422
                        s->field_select[0][0]= get_bits1(&s->gb);
3423
                        s->field_select[0][1]= get_bits1(&s->gb);
3424
                    }
3425
                    if(USES_LIST(mb_type, 1)){
3426
                        s->field_select[1][0]= get_bits1(&s->gb);
3427
                        s->field_select[1][1]= get_bits1(&s->gb);
3428
                    }
3429
                }
3430
            }
3431

    
3432
            s->mv_dir = 0;
3433
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
3434
                s->mv_type= MV_TYPE_16X16;
3435

    
3436
                if(USES_LIST(mb_type, 0)){
3437
                    s->mv_dir = MV_DIR_FORWARD;
3438

    
3439
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3440
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3441
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3442
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3443
                }
3444
    
3445
                if(USES_LIST(mb_type, 1)){
3446
                    s->mv_dir |= MV_DIR_BACKWARD;
3447

    
3448
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3449
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3450
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3451
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3452
                }
3453
            }else if(!IS_DIRECT(mb_type)){
3454
                s->mv_type= MV_TYPE_FIELD;
3455

    
3456
                if(USES_LIST(mb_type, 0)){
3457
                    s->mv_dir = MV_DIR_FORWARD;
3458
                
3459
                    for(i=0; i<2; i++){
3460
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3461
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3462
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3463
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3464
                    }
3465
                }
3466
    
3467
                if(USES_LIST(mb_type, 1)){
3468
                    s->mv_dir |= MV_DIR_BACKWARD;
3469

    
3470
                    for(i=0; i<2; i++){
3471
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
3472
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3473
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
3474
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3475
                    }
3476
                }
3477
            }
3478
        }
3479
          
3480
        if(IS_DIRECT(mb_type)){
3481
            if(IS_SKIP(mb_type))
3482
                mx=my=0;
3483
            else{
3484
                mx = h263_decode_motion(s, 0, 1);
3485
                my = h263_decode_motion(s, 0, 1);
3486
            }
3487
 
3488
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3489
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
3490
        }
3491
        s->current_picture.mb_type[xy]= mb_type;
3492
    } else { /* I-Frame */
3493
        cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
3494
        if (cbpc < 0)
3495
            return -1;
3496
        dquant = cbpc & 4;
3497
        s->mb_intra = 1;
3498
intra:
3499
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3500
        if (s->h263_pred || s->h263_aic) {
3501
            s->ac_pred = get_bits1(&s->gb);
3502
            if(s->ac_pred){
3503
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3504
            
3505
                if (s->h263_aic)
3506
                    s->h263_aic_dir = get_bits1(&s->gb);
3507
            }
3508
        }else
3509
            s->ac_pred = 0;
3510
        
3511
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3512
        if(cbpy<0) return -1;
3513
        cbp = (cbpc & 3) | (cbpy << 2);
3514
        if (dquant) {
3515
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3516
        }
3517
        
3518
        if(!s->progressive_sequence)
3519
            s->interlaced_dct= get_bits1(&s->gb);
3520

    
3521
        /* decode each block */
3522
        if (s->h263_pred) {
3523
            for (i = 0; i < 6; i++) {
3524
                if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
3525
                    return -1;
3526
                cbp+=cbp;
3527
            }
3528
        } else {
3529
            for (i = 0; i < 6; i++) {
3530
                if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3531
                    return -1;
3532
                cbp+=cbp;
3533
            }
3534
        }
3535
        goto end;
3536
    }
3537

    
3538
    /* decode each block */
3539
    if (s->h263_pred) {
3540
        for (i = 0; i < 6; i++) {
3541
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
3542
                return -1;
3543
            cbp+=cbp;
3544
        }
3545
    } else {
3546
        for (i = 0; i < 6; i++) {
3547
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3548
                return -1;
3549
            cbp+=cbp;
3550
        }
3551
    }
3552
end:
3553

    
3554
        /* per-MB end of slice check */
3555
    if(s->codec_id==CODEC_ID_MPEG4){
3556
        if(mpeg4_is_resync(s)){
3557
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3558
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
3559
                return SLICE_OK;
3560
            return SLICE_END;
3561
        }
3562
    }else{
3563
        int v= show_bits(&s->gb, 16);
3564
    
3565
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3566
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3567
        }
3568

    
3569
        if(v==0)
3570
            return SLICE_END;
3571
    }
3572

    
3573
    return SLICE_OK;     
3574
}
3575

    
3576
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3577
{
3578
    int code, val, sign, shift, l;
3579
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3580

    
3581
    if (code == 0)
3582
        return pred;
3583
    if (code < 0)
3584
        return 0xffff;
3585

    
3586
    sign = get_bits1(&s->gb);
3587
    shift = f_code - 1;
3588
    val = code;
3589
    if (shift) {
3590
        val = (val - 1) << shift;
3591
        val |= get_bits(&s->gb, shift);
3592
        val++;
3593
    }
3594
    if (sign)
3595
        val = -val;
3596
    val += pred;
3597

    
3598
    /* modulo decoding */
3599
    if (!s->h263_long_vectors) {
3600
        l = 1 << (f_code + 4);
3601
        val = ((val + l)&(l*2-1)) - l;
3602
    } else {
3603
        /* horrible h263 long vector mode */
3604
        if (pred < -31 && val < -63)
3605
            val += 64;
3606
        if (pred > 32 && val > 63)
3607
            val -= 64;
3608
        
3609
    }
3610
    return val;
3611
}
3612

    
3613
/* Decodes RVLC of H.263+ UMV */
3614
static int h263p_decode_umotion(MpegEncContext * s, int pred)
3615
{
3616
   int code = 0, sign;
3617
   
3618
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
3619
      return pred;
3620
   
3621
   code = 2 + get_bits1(&s->gb);
3622
   
3623
   while (get_bits1(&s->gb))
3624
   {
3625
      code <<= 1;
3626
      code += get_bits1(&s->gb);
3627
   }
3628
   sign = code & 1;
3629
   code >>= 1;
3630
   
3631
   code = (sign) ? (pred - code) : (pred + code);
3632
#ifdef DEBUG
3633
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3634
#endif
3635
   return code;   
3636

    
3637
}
3638

    
3639
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3640
                             int n, int coded)
3641
{
3642
    int code, level, i, j, last, run;
3643
    RLTable *rl = &rl_inter;
3644
    const uint8_t *scan_table;
3645

    
3646
    scan_table = s->intra_scantable.permutated;
3647
    if (s->h263_aic && s->mb_intra) {
3648
        rl = &rl_intra_aic;
3649
        i = 0;
3650
        if (s->ac_pred) {
3651
            if (s->h263_aic_dir) 
3652
                scan_table = s->intra_v_scantable.permutated; /* left */
3653
            else
3654
                scan_table = s->intra_h_scantable.permutated; /* top */
3655
        }
3656
    } else if (s->mb_intra) {
3657
        /* DC coef */
3658
        if(s->h263_rv10){
3659
          if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
3660
            int component, diff;
3661
            component = (n <= 3 ? 0 : n - 4 + 1);
3662
            level = s->last_dc[component];
3663
            if (s->rv10_first_dc_coded[component]) {
3664
                diff = rv_decode_dc(s, n);
3665
                if (diff == 0xffff)
3666
                    return -1;
3667
                level += diff;
3668
                level = level & 0xff; /* handle wrap round */
3669
                s->last_dc[component] = level;
3670
            } else {
3671
                s->rv10_first_dc_coded[component] = 1;
3672
            }
3673
          } else {
3674
                level = get_bits(&s->gb, 8);
3675
          }
3676
        }else{
3677
            level = get_bits(&s->gb, 8);
3678
            if((level&0x7F) == 0){
3679
                fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
3680
                return -1;
3681
            }
3682
            if (level == 255)
3683
                level = 128;
3684
        }
3685
        block[0] = level;
3686
        i = 1;
3687
    } else {
3688
        i = 0;
3689
    }
3690
    if (!coded) {
3691
        if (s->mb_intra && s->h263_aic)
3692
            goto not_coded;
3693
        s->block_last_index[n] = i - 1;
3694
        return 0;
3695
    }
3696

    
3697
    for(;;) {
3698
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3699
        if (code < 0){
3700
            fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3701
            return -1;
3702
        }
3703
        if (code == rl->n) {
3704
            /* escape */
3705
            if (s->h263_flv > 1) {
3706
                int is11 = get_bits1(&s->gb);
3707
                last = get_bits1(&s->gb);
3708
                run = get_bits(&s->gb, 6);
3709
                if(is11){
3710
                    level = get_sbits(&s->gb, 11);
3711
                } else {
3712
                    level = get_sbits(&s->gb, 7);
3713
                }
3714
            } else {
3715
                last = get_bits1(&s->gb);
3716
                run = get_bits(&s->gb, 6);
3717
                level = (int8_t)get_bits(&s->gb, 8);
3718
                if(level == -128){
3719
                    if (s->h263_rv10) {
3720
                        /* XXX: should patch encoder too */
3721
                        level = get_sbits(&s->gb, 12);
3722
                    }else{
3723
                        level = get_bits(&s->gb, 5);
3724
                        level |= get_sbits(&s->gb, 6)<<5;
3725
                    }
3726
                }
3727
            }
3728
        } else {
3729
            run = rl->table_run[code];
3730
            level = rl->table_level[code];
3731
            last = code >= rl->last;
3732
            if (get_bits1(&s->gb))
3733
                level = -level;
3734
        }
3735
        i += run;
3736
        if (i >= 64){
3737
            fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3738
            return -1;
3739
        }
3740
        j = scan_table[i];
3741
        block[j] = level;
3742
        if (last)
3743
            break;
3744
        i++;
3745
    }
3746
not_coded:    
3747
    if (s->mb_intra && s->h263_aic) {
3748
        h263_pred_acdc(s, block, n);
3749
        i = 63;
3750
    }
3751
    s->block_last_index[n] = i;
3752
    return 0;
3753
}
3754

    
3755
/**
3756
 * decodes the dc value.
3757
 * @param n block index (0-3 are luma, 4-5 are chroma)
3758
 * @param dir_ptr the prediction direction will be stored here
3759
 * @return the quantized dc
3760
 */
3761
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3762
{
3763
    int level, pred, code;
3764
    uint16_t *dc_val;
3765

    
3766
    if (n < 4) 
3767
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3768
    else 
3769
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3770
    if (code < 0 || code > 9 /* && s->nbit<9 */){
3771
        fprintf(stderr, "illegal dc vlc\n");
3772
        return -1;
3773
    }
3774
    if (code == 0) {
3775
        level = 0;
3776
    } else {
3777
        if(IS_3IV1){
3778
            if(code==1)
3779
                level= 2*get_bits1(&s->gb)-1;
3780
            else{
3781
                if(get_bits1(&s->gb))
3782
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
3783
                else
3784
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
3785
            }
3786
        }else{
3787
            level = get_xbits(&s->gb, code);
3788
        }
3789

    
3790
        if (code > 8){
3791
            if(get_bits1(&s->gb)==0){ /* marker */
3792
                if(s->error_resilience>=2){
3793
                    fprintf(stderr, "dc marker bit missing\n");
3794
                    return -1;
3795
                }
3796
            }
3797
        }
3798
    }
3799
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3800
    level += pred;
3801
    if (level < 0){
3802
        if(s->error_resilience>=3){
3803
            fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3804
            return -1;
3805
        }
3806
        level = 0;
3807
    }
3808
    if (n < 4) {
3809
        *dc_val = level * s->y_dc_scale;
3810
    } else {
3811
        *dc_val = level * s->c_dc_scale;
3812
    }
3813
    if(IS_3IV1)
3814
        *dc_val = level * 8;
3815
    
3816
    if(s->error_resilience>=3){
3817
        if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3818
            fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3819
            return -1;
3820
        }
3821
    }
3822
    return level;
3823
}
3824

    
3825
/**
3826
 * decodes a block.
3827
 * @return <0 if an error occured
3828
 */
3829
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3830
                              int n, int coded, int intra, int rvlc)
3831
{
3832
    int level, i, last, run;
3833
    int dc_pred_dir;
3834
    RLTable * rl;
3835
    RL_VLC_ELEM * rl_vlc;
3836
    const uint8_t * scan_table;
3837
    int qmul, qadd;
3838

    
3839
    //Note intra & rvlc should be optimized away if this is inlined
3840
    
3841
    if(intra) {
3842
        /* DC coef */
3843
        if(s->partitioned_frame){
3844
            level = s->dc_val[0][ s->block_index[n] ];
3845
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
3846
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
3847
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
3848
        }else{
3849
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3850
            if (level < 0)
3851
                return -1;
3852
        }
3853
        block[0] = level;
3854
        i = 0;
3855
        if (!coded) 
3856
            goto not_coded;
3857
        
3858
        if(rvlc){        
3859
            rl = &rvlc_rl_intra;
3860
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
3861
        }else{
3862
            rl = &rl_intra;
3863
            rl_vlc = rl_intra.rl_vlc[0];
3864
        }
3865
        if (s->ac_pred) {
3866
            if (dc_pred_dir == 0) 
3867
                scan_table = s->intra_v_scantable.permutated; /* left */
3868
            else
3869
                scan_table = s->intra_h_scantable.permutated; /* top */
3870
        } else {
3871
            scan_table = s->intra_scantable.permutated;
3872
        }
3873
        qmul=1;
3874
        qadd=0;
3875
    } else {
3876
        i = -1;
3877
        if (!coded) {
3878
            s->block_last_index[n] = i;
3879
            return 0;
3880
        }
3881
        if(rvlc) rl = &rvlc_rl_inter;
3882
        else     rl = &rl_inter;
3883
   
3884
        scan_table = s->intra_scantable.permutated;
3885

    
3886
        if(s->mpeg_quant){
3887
            qmul=1;
3888
            qadd=0;
3889
            if(rvlc){        
3890
                rl_vlc = rvlc_rl_inter.rl_vlc[0];        
3891
            }else{
3892
                rl_vlc = rl_inter.rl_vlc[0];        
3893
            }
3894
        }else{
3895
            qmul = s->qscale << 1;
3896
            qadd = (s->qscale - 1) | 1;
3897
            if(rvlc){        
3898
                rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];        
3899
            }else{
3900
                rl_vlc = rl_inter.rl_vlc[s->qscale];        
3901
            }
3902
        }
3903
    }
3904
  {
3905
    OPEN_READER(re, &s->gb);
3906
    for(;;) {
3907
        UPDATE_CACHE(re, &s->gb);
3908
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3909
        if (level==0) {
3910
          /* escape */                
3911
          if(rvlc){
3912
                if(SHOW_UBITS(re, &s->gb, 1)==0){
3913
                    fprintf(stderr, "1. marker bit missing in rvlc esc\n");
3914
                    return -1;
3915
                }; SKIP_CACHE(re, &s->gb, 1);
3916
 
3917
                last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3918
                run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3919
                SKIP_COUNTER(re, &s->gb, 1+1+6);
3920
                UPDATE_CACHE(re, &s->gb);
3921
              
3922
                if(SHOW_UBITS(re, &s->gb, 1)==0){
3923
                    fprintf(stderr, "2. marker bit missing in rvlc esc\n");
3924
                    return -1;
3925
                }; SKIP_CACHE(re, &s->gb, 1);
3926
 
3927
                level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
3928
 
3929
                if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
3930
                    fprintf(stderr, "reverse esc missing\n");
3931
                    return -1;
3932
                }; SKIP_CACHE(re, &s->gb, 5);
3933

    
3934
                level=  level * qmul + qadd;
3935
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
3936
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
3937

    
3938
                i+= run + 1;
3939
                if(last) i+=192;
3940
          }else{
3941
            int cache;
3942
            cache= GET_CACHE(re, &s->gb);
3943

    
3944
            if(IS_3IV1) 
3945
                cache ^= 0xC0000000;
3946

    
3947
            if (cache&0x80000000) {
3948
                if (cache&0x40000000) {
3949
                    /* third escape */
3950
                    SKIP_CACHE(re, &s->gb, 2);
3951
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3952
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3953
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
3954
                    UPDATE_CACHE(re, &s->gb);
3955

    
3956
                    if(IS_3IV1){
3957
                        level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
3958
                    }else{
3959
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
3960
                            fprintf(stderr, "1. marker bit missing in 3. esc\n");
3961
                            return -1;
3962
                        }; SKIP_CACHE(re, &s->gb, 1);
3963

    
3964
                        level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3965

    
3966
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
3967
                            fprintf(stderr, "2. marker bit missing in 3. esc\n");
3968
                            return -1;
3969
                        }; LAST_SKIP_CACHE(re, &s->gb, 1);
3970

    
3971
                        SKIP_COUNTER(re, &s->gb, 1+12+1);
3972
                    }
3973
 
3974
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
3975
                        fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3976
                        return -1;
3977
                    }
3978
#if 1 
3979
                    {
3980
                        const int abs_level= ABS(level);
3981
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
3982
                            const int run1= run - rl->max_run[last][abs_level] - 1;
3983
                            if(abs_level <= rl->max_level[last][run]){
3984
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3985
                                return -1;
3986
                            }
3987
                            if(s->error_resilience > FF_ER_COMPLIANT){
3988
                                if(abs_level <= rl->max_level[last][run]*2){
3989
                                    fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3990
                                    return -1;
3991
                                }
3992
                                if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3993
                                    fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3994
                                    return -1;
3995
                                }
3996
                            }
3997
                        }
3998
                    }
3999
#endif
4000
                    if (level>0) level= level * qmul + qadd;
4001
                    else         level= level * qmul - qadd;
4002

    
4003
                    i+= run + 1;
4004
                    if(last) i+=192;
4005
                } else {
4006
                    /* second escape */
4007
#if MIN_CACHE_BITS < 20
4008
                    LAST_SKIP_BITS(re, &s->gb, 2);
4009
                    UPDATE_CACHE(re, &s->gb);
4010
#else
4011
                    SKIP_BITS(re, &s->gb, 2);
4012
#endif
4013
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4014
                    i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4015
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4016
                    LAST_SKIP_BITS(re, &s->gb, 1);
4017
                }
4018
            } else {
4019
                /* first escape */
4020
#if MIN_CACHE_BITS < 19
4021
                LAST_SKIP_BITS(re, &s->gb, 1);
4022
                UPDATE_CACHE(re, &s->gb);
4023
#else
4024
                SKIP_BITS(re, &s->gb, 1);
4025
#endif
4026
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4027
                i+= run;
4028
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4029
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4030
                LAST_SKIP_BITS(re, &s->gb, 1);
4031
            }
4032
          }
4033
        } else {
4034
            i+= run;
4035
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4036
            LAST_SKIP_BITS(re, &s->gb, 1);
4037
        }
4038
        if (i > 62){
4039
            i-= 192;
4040
            if(i&(~63)){
4041
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4042
                return -1;
4043
            }
4044

    
4045
            block[scan_table[i]] = level;
4046
            break;
4047
        }
4048

    
4049
        block[scan_table[i]] = level;
4050
    }
4051
    CLOSE_READER(re, &s->gb);
4052
  }
4053
 not_coded:
4054
    if (s->mb_intra) {
4055
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
4056
        if (s->ac_pred) {
4057
            i = 63; /* XXX: not optimal */
4058
        }
4059
    }
4060
    s->block_last_index[n] = i;
4061
    return 0;
4062
}
4063

    
4064
/* most is hardcoded. should extend to handle all h263 streams */
4065
int h263_decode_picture_header(MpegEncContext *s)
4066
{
4067
    int format, width, height, i;
4068
    uint32_t startcode;
4069
    
4070
    align_get_bits(&s->gb);
4071

    
4072
    startcode= get_bits(&s->gb, 22-8);
4073

    
4074
    for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4075
        startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4076
        
4077
        if(startcode == 0x20)
4078
            break;
4079
    }
4080
        
4081
    if (startcode != 0x20) {
4082
        fprintf(stderr, "Bad picture start code\n");
4083
        return -1;
4084
    }
4085
    /* temporal reference */
4086
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4087

    
4088
    /* PTYPE starts here */    
4089
    if (get_bits1(&s->gb) != 1) {
4090
        /* marker */
4091
        fprintf(stderr, "Bad marker\n");
4092
        return -1;
4093
    }
4094
    if (get_bits1(&s->gb) != 0) {
4095
        fprintf(stderr, "Bad H263 id\n");
4096
        return -1;        /* h263 id */
4097
    }
4098
    skip_bits1(&s->gb);        /* split screen off */
4099
    skip_bits1(&s->gb);        /* camera  off */
4100
    skip_bits1(&s->gb);        /* freeze picture release off */
4101

    
4102
    /* Reset GOB number */
4103
    s->gob_number = 0;
4104
        
4105
    format = get_bits(&s->gb, 3);
4106
    /*
4107
        0    forbidden
4108
        1    sub-QCIF
4109
        10   QCIF
4110
        7        extended PTYPE (PLUSPTYPE)
4111
    */
4112

    
4113
    if (format != 7 && format != 6) {
4114
        s->h263_plus = 0;
4115
        /* H.263v1 */
4116
        width = h263_format[format][0];
4117
        height = h263_format[format][1];
4118
        if (!width)
4119
            return -1;
4120
        
4121
        s->pict_type = I_TYPE + get_bits1(&s->gb);
4122

    
4123
        s->unrestricted_mv = get_bits1(&s->gb); 
4124
        s->h263_long_vectors = s->unrestricted_mv;
4125

    
4126
        if (get_bits1(&s->gb) != 0) {
4127
            fprintf(stderr, "H263 SAC not supported\n");
4128
            return -1;        /* SAC: off */
4129
        }
4130
        if (get_bits1(&s->gb) != 0) {
4131
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
4132
        }   
4133
        
4134
        if (get_bits1(&s->gb) != 0) {
4135
            fprintf(stderr, "H263 PB frame not supported\n");
4136
            return -1;        /* not PB frame */
4137
        }
4138
        s->qscale = get_bits(&s->gb, 5);
4139
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
4140

    
4141
        s->width = width;
4142
        s->height = height;
4143
    } else {
4144
        int ufep;
4145
        
4146
        /* H.263v2 */
4147
        s->h263_plus = 1;
4148
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
4149

    
4150
        /* ufep other than 0 and 1 are reserved */        
4151
        if (ufep == 1) {
4152
            /* OPPTYPE */       
4153
            format = get_bits(&s->gb, 3);
4154
            dprintf("ufep=1, format: %d\n", format);
4155
            skip_bits(&s->gb,1); /* Custom PCF */
4156
            s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
4157
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
4158
            if (get_bits1(&s->gb) != 0) {
4159
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
4160
            }
4161
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
4162
                s->h263_aic = 1;
4163
            }
4164
            
4165
            if (get_bits1(&s->gb) != 0) {
4166
                fprintf(stderr, "Deblocking Filter not supported\n");
4167
            }
4168
            if (get_bits1(&s->gb) != 0) {
4169
                fprintf(stderr, "Slice Structured not supported\n");
4170
            }
4171
            if (get_bits1(&s->gb) != 0) {
4172
                fprintf(stderr, "Reference Picture Selection not supported\n");
4173
            }
4174
            if (get_bits1(&s->gb) != 0) {
4175
                fprintf(stderr, "Independent Segment Decoding not supported\n");
4176
            }
4177
            if (get_bits1(&s->gb) != 0) {
4178
                fprintf(stderr, "Alternative Inter VLC not supported\n");
4179
            }
4180
            if (get_bits1(&s->gb) != 0) {
4181
                fprintf(stderr, "Modified Quantization not supported\n");
4182
            }
4183
            
4184
            skip_bits(&s->gb, 1); /* Prevent start code emulation */
4185

    
4186
            skip_bits(&s->gb, 3); /* Reserved */
4187
        } else if (ufep != 0) {
4188
            fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
4189
            return -1;
4190
        }
4191
            
4192
        /* MPPTYPE */
4193
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
4194
        dprintf("pict_type: %d\n", s->pict_type);
4195
        if (s->pict_type != I_TYPE &&
4196
            s->pict_type != P_TYPE)
4197
            return -1;
4198
        skip_bits(&s->gb, 2);
4199
        s->no_rounding = get_bits1(&s->gb);
4200
        dprintf("RTYPE: %d\n", s->no_rounding);
4201
        skip_bits(&s->gb, 4);
4202
        
4203
        /* Get the picture dimensions */
4204
        if (ufep) {
4205
            if (format == 6) {
4206
                /* Custom Picture Format (CPFMT) */
4207
                s->aspect_ratio_info = get_bits(&s->gb, 4);
4208
                dprintf("aspect: %d\n", s->aspect_ratio_info);
4209
                /* aspect ratios:
4210
                0 - forbidden
4211
                1 - 1:1
4212
                2 - 12:11 (CIF 4:3)
4213
                3 - 10:11 (525-type 4:3)
4214
                4 - 16:11 (CIF 16:9)
4215
                5 - 40:33 (525-type 16:9)
4216
                6-14 - reserved
4217
                */
4218
                width = (get_bits(&s->gb, 9) + 1) * 4;
4219
                skip_bits1(&s->gb);
4220
                height = get_bits(&s->gb, 9) * 4;
4221
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
4222
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
4223
                    /* aspected dimensions */
4224
                    s->aspected_width = get_bits(&s->gb, 8);
4225
                    s->aspected_height = get_bits(&s->gb, 8);
4226
                }else{
4227
                    s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4228
                    s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4229
                }
4230
            } else {
4231
                width = h263_format[format][0];
4232
                height = h263_format[format][1];
4233
            }
4234
            if ((width == 0) || (height == 0))
4235
                return -1;
4236
            s->width = width;
4237
            s->height = height;
4238
            if (s->umvplus) {
4239
                if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4240
                    skip_bits1(&s->gb); 
4241
            }
4242
        }
4243
            
4244
        s->qscale = get_bits(&s->gb, 5);
4245
    }
4246
    /* PEI */
4247
    while (get_bits1(&s->gb) != 0) {
4248
        skip_bits(&s->gb, 8);
4249
    }
4250
    s->f_code = 1;
4251
    
4252
    if(s->h263_aic){
4253
         s->y_dc_scale_table= 
4254
         s->c_dc_scale_table= h263_aic_dc_scale_table;
4255
    }else{
4256
        s->y_dc_scale_table=
4257
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4258
    }
4259

    
4260
     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4261
         printf("qp:%d %c size:%d rnd:%d %s %s %s %s\n", 
4262
         s->qscale, av_get_pict_type_char(s->pict_type),
4263
         s->gb.size_in_bits, 1-s->no_rounding,
4264
         s->mv_type == MV_TYPE_8X8 ? "ADV" : "",
4265
         s->umvplus ? "UMV" : "",
4266
         s->h263_long_vectors ? "LONG" : "",
4267
         s->h263_plus ? "+" : ""
4268
         ); 
4269
     }
4270

    
4271
    
4272
    return 0;
4273
}
4274

    
4275
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4276
{
4277
    int i;
4278
    int a= 2<<s->sprite_warping_accuracy;
4279
    int rho= 3-s->sprite_warping_accuracy;
4280
    int r=16/a;
4281
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4282
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4283
    int sprite_ref[4][2];
4284
    int virtual_ref[2][2];
4285
    int w2, h2, w3, h3;
4286
    int alpha=0, beta=0;
4287
    int w= s->width;
4288
    int h= s->height;
4289
    int min_ab;
4290

    
4291
    for(i=0; i<s->num_sprite_warping_points; i++){
4292
        int length;
4293
        int x=0, y=0;
4294

    
4295
        length= get_vlc(&s->gb, &sprite_trajectory);
4296
        if(length){
4297
            x= get_xbits(&s->gb, length);
4298
        }
4299
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4300
        
4301
        length= get_vlc(&s->gb, &sprite_trajectory);
4302
        if(length){
4303
            y=get_xbits(&s->gb, length);
4304
        }
4305
        skip_bits1(&s->gb); /* marker bit */
4306
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4307
        d[i][0]= x;
4308
        d[i][1]= y;
4309
    }
4310

    
4311
    while((1<<alpha)<w) alpha++;
4312
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4313
    w2= 1<<alpha;
4314
    h2= 1<<beta;
4315

    
4316
// Note, the 4th point isnt used for GMC
4317
    if(s->divx_version==500 && s->divx_build==413){
4318
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
4319
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
4320
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
4321
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
4322
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
4323
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
4324
    } else {
4325
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
4326
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
4327
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
4328
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
4329
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
4330
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
4331
    }
4332
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
4333
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
4334
    
4335
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
4336
// perhaps it should be reordered to be more readable ...
4337
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
4338
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
4339
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
4340
        + 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);
4341
    virtual_ref[0][1]= 16*vop_ref[0][1] 
4342
        + 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);
4343
    virtual_ref[1][0]= 16*vop_ref[0][0] 
4344
        + 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);
4345
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
4346
        + 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);
4347
        
4348
    switch(s->num_sprite_warping_points)
4349
    {
4350
        case 0:
4351
            s->sprite_offset[0][0]= 0;
4352
            s->sprite_offset[0][1]= 0;
4353
            s->sprite_offset[1][0]= 0;
4354
            s->sprite_offset[1][1]= 0;
4355
            s->sprite_delta[0][0]= a;
4356
            s->sprite_delta[0][1]= 0;
4357
            s->sprite_delta[1][0]= 0;
4358
            s->sprite_delta[1][1]= a;
4359
            s->sprite_shift[0]= 0;
4360
            s->sprite_shift[1]= 0;
4361
            break;
4362
        case 1: //GMC only
4363
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
4364
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
4365
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
4366
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
4367
            s->sprite_delta[0][0]= a;
4368
            s->sprite_delta[0][1]= 0;
4369
            s->sprite_delta[1][0]= 0;
4370
            s->sprite_delta[1][1]= a;
4371
            s->sprite_shift[0]= 0;
4372
            s->sprite_shift[1]= 0;
4373
            break;
4374
        case 2:
4375
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
4376
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
4377
                                                  + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
4378
                                                  + (1<<(alpha+rho-1));
4379
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
4380
                                                  + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
4381
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
4382
                                                  + (1<<(alpha+rho-1));
4383
            s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4384
                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4385
                                     +2*w2*r*sprite_ref[0][0] 
4386
                                     - 16*w2 
4387
                                     + (1<<(alpha+rho+1)));
4388
            s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
4389
                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4390
                                     +2*w2*r*sprite_ref[0][1] 
4391
                                     - 16*w2
4392
                                     + (1<<(alpha+rho+1)));
4393
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4394
            s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4395
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4396
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4397
            
4398
            s->sprite_shift[0]= alpha+rho;
4399
            s->sprite_shift[1]= alpha+rho+2;
4400
            break;
4401
        case 3:
4402
            min_ab= FFMIN(alpha, beta);
4403
            w3= w2>>min_ab;
4404
            h3= h2>>min_ab;
4405
            s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
4406
                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
4407
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
4408
                                   + (1<<(alpha+beta+rho-min_ab-1));
4409
            s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
4410
                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
4411
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
4412
                                   + (1<<(alpha+beta+rho-min_ab-1));
4413
            s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
4414
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
4415
                                   + 2*w2*h3*r*sprite_ref[0][0]
4416
                                   - 16*w2*h3
4417
                                   + (1<<(alpha+beta+rho-min_ab+1));
4418
            s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4419
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4420
                                   + 2*w2*h3*r*sprite_ref[0][1]
4421
                                   - 16*w2*h3
4422
                                   + (1<<(alpha+beta+rho-min_ab+1));
4423
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4424
            s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4425
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4426
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4427
                                   
4428
            s->sprite_shift[0]= alpha + beta + rho - min_ab;
4429
            s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4430
            break;
4431
    }
4432
    /* try to simplify the situation */ 
4433
    if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4434
       && s->sprite_delta[0][1] == 0
4435
       && s->sprite_delta[1][0] == 0
4436
       && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4437
    {
4438
        s->sprite_offset[0][0]>>=s->sprite_shift[0];
4439
        s->sprite_offset[0][1]>>=s->sprite_shift[0];
4440
        s->sprite_offset[1][0]>>=s->sprite_shift[1];
4441
        s->sprite_offset[1][1]>>=s->sprite_shift[1];
4442
        s->sprite_delta[0][0]= a;
4443
        s->sprite_delta[0][1]= 0;
4444
        s->sprite_delta[1][0]= 0;
4445
        s->sprite_delta[1][1]= a;
4446
        s->sprite_shift[0]= 0;
4447
        s->sprite_shift[1]= 0;
4448
        s->real_sprite_warping_points=1;
4449
    }
4450
    else{
4451
        int shift_y= 16 - s->sprite_shift[0];
4452
        int shift_c= 16 - s->sprite_shift[1];
4453
//printf("shifts %d %d\n", shift_y, shift_c);
4454
        for(i=0; i<2; i++){
4455
            s->sprite_offset[0][i]<<= shift_y;
4456
            s->sprite_offset[1][i]<<= shift_c;
4457
            s->sprite_delta[0][i]<<= shift_y;
4458
            s->sprite_delta[1][i]<<= shift_y;
4459
            s->sprite_shift[i]= 16;
4460
        }
4461
        s->real_sprite_warping_points= s->num_sprite_warping_points;
4462
    }
4463
#if 0
4464
printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4465
    vop_ref[0][0], vop_ref[0][1],
4466
    vop_ref[1][0], vop_ref[1][1],
4467
    vop_ref[2][0], vop_ref[2][1],
4468
    sprite_ref[0][0], sprite_ref[0][1], 
4469
    sprite_ref[1][0], sprite_ref[1][1], 
4470
    sprite_ref[2][0], sprite_ref[2][1], 
4471
    virtual_ref[0][0], virtual_ref[0][1], 
4472
    virtual_ref[1][0], virtual_ref[1][1]
4473
    );
4474
    
4475
printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4476
    s->sprite_offset[0][0], s->sprite_offset[0][1],
4477
    s->sprite_delta[0][0], s->sprite_delta[0][1],
4478
    s->sprite_delta[1][0], s->sprite_delta[1][1],
4479
    s->sprite_shift[0]
4480
    );
4481
#endif
4482
}
4483

    
4484
static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
4485
    int hours, minutes, seconds;
4486

    
4487
    hours= get_bits(gb, 5);
4488
    minutes= get_bits(gb, 6);
4489
    skip_bits1(gb);
4490
    seconds= get_bits(gb, 6);
4491

    
4492
    s->time_base= seconds + 60*(minutes + 60*hours);
4493

    
4494
    skip_bits1(gb);
4495
    skip_bits1(gb);
4496
    
4497
    return 0;
4498
}
4499

    
4500
static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4501
    int width, height, vo_ver_id;
4502

    
4503
    /* vol header */
4504
    skip_bits(gb, 1); /* random access */
4505
    s->vo_type= get_bits(gb, 8);
4506
    if (get_bits1(gb) != 0) { /* is_ol_id */
4507
        vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4508
        skip_bits(gb, 3); /* vo_priority */
4509
    } else {
4510
        vo_ver_id = 1;
4511
    }
4512
//printf("vo type:%d\n",s->vo_type);
4513
    s->aspect_ratio_info= get_bits(gb, 4);
4514
    if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){            
4515
        s->aspected_width = get_bits(gb, 8); // par_width
4516
        s->aspected_height = get_bits(gb, 8); // par_height
4517
    }else{
4518
        s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4519
        s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4520
    }
4521

    
4522
    if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4523
        int chroma_format= get_bits(gb, 2);
4524
        if(chroma_format!=1){
4525
            printf("illegal chroma format\n");
4526
        }
4527
        s->low_delay= get_bits1(gb);
4528
        if(get_bits1(gb)){ /* vbv parameters */
4529
            get_bits(gb, 15);        /* first_half_bitrate */
4530
            skip_bits1(gb);        /* marker */
4531
            get_bits(gb, 15);        /* latter_half_bitrate */
4532
            skip_bits1(gb);        /* marker */
4533
            get_bits(gb, 15);        /* first_half_vbv_buffer_size */
4534
            skip_bits1(gb);        /* marker */
4535
            get_bits(gb, 3);        /* latter_half_vbv_buffer_size */
4536
            get_bits(gb, 11);        /* first_half_vbv_occupancy */
4537
            skip_bits1(gb);        /* marker */
4538
            get_bits(gb, 15);        /* latter_half_vbv_occupancy */
4539
            skip_bits1(gb);        /* marker */               
4540
        }
4541
    }else{
4542
        // set low delay flag only once so the smart? low delay detection wont be overriden
4543
        if(s->picture_number==0)
4544
            s->low_delay=0;
4545
    }
4546

    
4547
    s->shape = get_bits(gb, 2); /* vol shape */
4548
    if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4549
    if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4550
        printf("Gray shape not supported\n");
4551
        skip_bits(gb, 4);  //video_object_layer_shape_extension
4552
    }
4553

    
4554
    skip_bits1(gb);   /* marker */
4555
    
4556
    s->time_increment_resolution = get_bits(gb, 16);
4557
    
4558
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4559
    if (s->time_increment_bits < 1)
4560
        s->time_increment_bits = 1;
4561
    skip_bits1(gb);   /* marker */
4562

    
4563
    if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
4564
        skip_bits(gb, s->time_increment_bits);
4565
    }
4566

    
4567
    if (s->shape != BIN_ONLY_SHAPE) {
4568
        if (s->shape == RECT_SHAPE) {
4569
            skip_bits1(gb);   /* marker */
4570
            width = get_bits(gb, 13);
4571
            skip_bits1(gb);   /* marker */
4572
            height = get_bits(gb, 13);
4573
            skip_bits1(gb);   /* marker */
4574
            if(width && height){ /* they should be non zero but who knows ... */
4575
                s->width = width;
4576
                s->height = height;
4577
//                printf("width/height: %d %d\n", width, height);
4578
            }
4579
        }
4580
        
4581
        s->progressive_sequence= get_bits1(gb)^1;
4582
        if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) 
4583
            printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
4584
        if (vo_ver_id == 1) {
4585
            s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4586
        } else {
4587
            s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4588
        }
4589
        if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4590
        if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4591
            if(s->vol_sprite_usage==STATIC_SPRITE){
4592
                s->sprite_width = get_bits(gb, 13);
4593
                skip_bits1(gb); /* marker */
4594
                s->sprite_height= get_bits(gb, 13);
4595
                skip_bits1(gb); /* marker */
4596
                s->sprite_left  = get_bits(gb, 13);
4597
                skip_bits1(gb); /* marker */
4598
                s->sprite_top   = get_bits(gb, 13);
4599
                skip_bits1(gb); /* marker */
4600
            }
4601
            s->num_sprite_warping_points= get_bits(gb, 6);
4602
            s->sprite_warping_accuracy = get_bits(gb, 2);
4603
            s->sprite_brightness_change= get_bits1(gb);
4604
            if(s->vol_sprite_usage==STATIC_SPRITE)
4605
                s->low_latency_sprite= get_bits1(gb);            
4606
        }
4607
        // FIXME sadct disable bit if verid!=1 && shape not rect
4608
        
4609
        if (get_bits1(gb) == 1) {   /* not_8_bit */
4610
            s->quant_precision = get_bits(gb, 4); /* quant_precision */
4611
            if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4612
            if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4613
        } else {
4614
            s->quant_precision = 5;
4615
        }
4616
        
4617
        // FIXME a bunch of grayscale shape things
4618

    
4619
        if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4620
            int i, v;
4621
            
4622
            /* load default matrixes */
4623
            for(i=0; i<64; i++){
4624
                int j= s->dsp.idct_permutation[i];
4625
                v= ff_mpeg4_default_intra_matrix[i];
4626
                s->intra_matrix[j]= v;
4627
                s->chroma_intra_matrix[j]= v;
4628
                
4629
                v= ff_mpeg4_default_non_intra_matrix[i];
4630
                s->inter_matrix[j]= v;
4631
                s->chroma_inter_matrix[j]= v;
4632
            }
4633

    
4634
            /* load custom intra matrix */
4635
            if(get_bits1(gb)){
4636
                int last=0;
4637
                for(i=0; i<64; i++){
4638
                    int j;
4639
                    v= get_bits(gb, 8);
4640
                    if(v==0) break;
4641
                    
4642
                    last= v;
4643
                    j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4644
                    s->intra_matrix[j]= v;
4645
                    s->chroma_intra_matrix[j]= v;
4646
                }
4647

    
4648
                /* replicate last value */
4649
                for(; i<64; i++){
4650
                    int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4651
                    s->intra_matrix[j]= v;
4652
                    s->chroma_intra_matrix[j]= v;
4653
                }
4654
            }
4655

    
4656
            /* load custom non intra matrix */
4657
            if(get_bits1(gb)){
4658
                int last=0;
4659
                for(i=0; i<64; i++){
4660
                    int j;
4661
                    v= get_bits(gb, 8);
4662
                    if(v==0) break;
4663

    
4664
                    last= v;
4665
                    j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4666
                    s->inter_matrix[j]= v;
4667
                    s->chroma_inter_matrix[j]= v;
4668
                }
4669

    
4670
                /* replicate last value */
4671
                for(; i<64; i++){
4672
                    int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4673
                    s->inter_matrix[j]= last;
4674
                    s->chroma_inter_matrix[j]= last;
4675
                }
4676
            }
4677

    
4678
            // FIXME a bunch of grayscale shape things
4679
        }
4680

    
4681
        if(vo_ver_id != 1)
4682
             s->quarter_sample= get_bits1(gb);
4683
        else s->quarter_sample=0;
4684

    
4685
        if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4686

    
4687
        s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4688

    
4689
        s->data_partitioning= get_bits1(gb);
4690
        if(s->data_partitioning){
4691
            s->rvlc= get_bits1(gb);
4692
        }
4693
        
4694
        if(vo_ver_id != 1) {
4695
            s->new_pred= get_bits1(gb);
4696
            if(s->new_pred){
4697
                printf("new pred not supported\n");
4698
                skip_bits(gb, 2); /* requested upstream message type */
4699
                skip_bits1(gb); /* newpred segment type */
4700
            }
4701
            s->reduced_res_vop= get_bits1(gb);
4702
            if