Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ e4748d63

History | View | Annotate | Download (173 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_flv_encode_block(MpegEncContext * s, DCTELEM * block,
55
                                  int n);
56
static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
57
static void h263p_encode_umotion(MpegEncContext * s, int val);
58
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
59
                               int n, int dc, uint8_t *scan_table, 
60
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
61
#endif
62

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

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

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

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

    
96
/* mpeg4
97
inter
98
max level: 24/6
99
max run: 53/63
100

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

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

    
113
int h263_get_picture_format(int width, int height)
114
{
115
    int format;
116

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

    
132
#ifdef CONFIG_ENCODERS
133

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

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

    
142
    ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
143

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

    
155
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
156
{
157
      int format;
158

    
159
      align_put_bits(&s->pb);
160

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

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

    
201
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
202
{
203
    int format;
204

    
205
    align_put_bits(&s->pb);
206

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

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

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

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

    
291
        put_bits(&s->pb, 5, s->qscale);
292
    }
293

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

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

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

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

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

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

    
386
    return score0 > score1 ? 1 : 0;    
387
}
388

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

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

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

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

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

    
515
#ifdef CONFIG_ENCODERS
516
void mpeg4_encode_mb(MpegEncContext * s,
517
                    DCTELEM block[6][64],
518
                    int motion_x, int motion_y)
519
{
520
    int cbpc, cbpy, pred_x, pred_y;
521
    int bits;
522
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
523
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
524
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
525
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
526
    const int dquant_code[5]= {1,0,9,2,3};
527
    
528
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
529
    if (!s->mb_intra) {
530
        /* compute cbp */
531
        int i, cbp = 0;
532
        for (i = 0; i < 6; i++) {
533
            if (s->block_last_index[i] >= 0)
534
                cbp |= 1 << (5 - i);
535
        }
536

    
537
        if(s->pict_type==B_TYPE){
538
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
539
            int mb_type=  mb_type_table[s->mv_dir];
540
            
541
            if(s->mb_x==0){
542
                s->last_mv[0][0][0]= 
543
                s->last_mv[0][0][1]= 
544
                s->last_mv[1][0][0]= 
545
                s->last_mv[1][0][1]= 0;
546
            }
547
            
548
            assert(s->dquant>=-2 && s->dquant<=2);
549
            assert((s->dquant&1)==0);
550
            assert(mb_type>=0);
551

    
552
            /* nothing to do if this MB was skiped in the next P Frame */
553
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
554
                s->skip_count++;
555
                s->mv[0][0][0]= 
556
                s->mv[0][0][1]= 
557
                s->mv[1][0][0]= 
558
                s->mv[1][0][1]= 0;
559
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
560
                s->qscale -= s->dquant;
561
//                s->mb_skiped=1;
562

    
563
                return;
564
            }
565
            
566
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
567
                /* direct MB with MV={0,0} */
568
                assert(s->dquant==0);
569
                
570
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
571

    
572
                if(interleaved_stats){
573
                    s->misc_bits++;
574
                    s->last_bits++;
575
                }
576
                s->skip_count++;
577
                return;
578
            }
579
            
580
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
581
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
582
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
583
            if(cbp) put_bits(&s->pb, 6, cbp);
584
            
585
            if(cbp && mb_type){
586
                if(s->dquant)
587
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
588
                else
589
                    put_bits(&s->pb, 1, 0);
590
            }else
591
                s->qscale -= s->dquant;
592
            
593
            if(!s->progressive_sequence){
594
                if(cbp)
595
                    put_bits(&s->pb, 1, s->interlaced_dct);
596
                if(mb_type) // not diect mode
597
                    put_bits(&s->pb, 1, 0); // no interlaced ME yet
598
            }
599

    
600
            if(interleaved_stats){
601
                s->misc_bits+= get_bits_diff(s);
602
            }
603

    
604
            switch(mb_type)
605
            {
606
            case 0: /* direct */
607
                h263_encode_motion(s, motion_x, 1);
608
                h263_encode_motion(s, motion_y, 1);                
609
                s->b_count++;
610
                s->f_count++;
611
                break;
612
            case 1: /* bidir */
613
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
614
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
615
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
616
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
617
                s->last_mv[0][0][0]= s->mv[0][0][0];
618
                s->last_mv[0][0][1]= s->mv[0][0][1];
619
                s->last_mv[1][0][0]= s->mv[1][0][0];
620
                s->last_mv[1][0][1]= s->mv[1][0][1];
621
                s->b_count++;
622
                s->f_count++;
623
                break;
624
            case 2: /* backward */
625
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
626
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
627
                s->last_mv[1][0][0]= motion_x;
628
                s->last_mv[1][0][1]= motion_y;
629
                s->b_count++;
630
                break;
631
            case 3: /* forward */
632
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
633
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
634
                s->last_mv[0][0][0]= motion_x;
635
                s->last_mv[0][0][1]= motion_y;
636
                s->f_count++;
637
                break;
638
            default:
639
                printf("unknown mb type\n");
640
                return;
641
            }
642

    
643
            if(interleaved_stats){
644
                s->mv_bits+= get_bits_diff(s);
645
            }
646

    
647
            /* encode each block */
648
            for (i = 0; i < 6; i++) {
649
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
650
            }
651

    
652
            if(interleaved_stats){
653
                s->p_tex_bits+= get_bits_diff(s);
654
            }
655
        }else{ /* s->pict_type==B_TYPE */
656
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
657
                /* check if the B frames can skip it too, as we must skip it if we skip here 
658
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
659
                if(s->max_b_frames>0){
660
                    int i;
661
                    int x,y, offset;
662
                    uint8_t *p_pic;
663

    
664
                    x= s->mb_x*16;
665
                    y= s->mb_y*16;
666
                    if(x+16 > s->width)  x= s->width-16;
667
                    if(y+16 > s->height) y= s->height-16;
668

    
669
                    offset= x + y*s->linesize;
670
                    p_pic= s->new_picture.data[0] + offset;
671
                    
672
                    s->mb_skiped=1;
673
                    for(i=0; i<s->max_b_frames; i++){
674
                        uint8_t *b_pic;
675
                        int diff;
676
                        Picture *pic= s->reordered_input_picture[i+1];
677

    
678
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
679

    
680
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
681
                        diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
682
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
683
                            s->mb_skiped=0;
684
                            break;
685
                        }
686
                    }
687
                }else
688
                    s->mb_skiped=1; 
689

    
690
                if(s->mb_skiped==1){
691
                    /* skip macroblock */
692
                    put_bits(&s->pb, 1, 1);
693

    
694
                    if(interleaved_stats){
695
                        s->misc_bits++;
696
                        s->last_bits++;
697
                    }
698
                    s->skip_count++;
699
                    
700
                    return;
701
                }
702
            }
703

    
704
            put_bits(&s->pb, 1, 0);        /* mb coded */
705
            if(s->mv_type==MV_TYPE_16X16){
706
                cbpc = cbp & 3;
707
                if(s->dquant) cbpc+= 8;
708
                put_bits(&s->pb,
709
                        inter_MCBPC_bits[cbpc],
710
                        inter_MCBPC_code[cbpc]);
711

    
712
                cbpy = cbp >> 2;
713
                cbpy ^= 0xf;
714
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
715
                if(s->dquant)
716
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
717

    
718
                if(!s->progressive_sequence){
719
                    if(cbp)
720
                        put_bits(pb2, 1, s->interlaced_dct);
721
                    put_bits(pb2, 1, 0); // no interlaced ME yet
722
                }
723
                    
724
                if(interleaved_stats){
725
                    s->misc_bits+= get_bits_diff(s);
726
                }
727

    
728
                /* motion vectors: 16x16 mode */
729
                h263_pred_motion(s, 0, &pred_x, &pred_y);
730
            
731
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
732
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
733
            }else{
734
                cbpc = (cbp & 3)+16;
735
                put_bits(&s->pb,
736
                        inter_MCBPC_bits[cbpc],
737
                        inter_MCBPC_code[cbpc]);
738
                cbpy = cbp >> 2;
739
                cbpy ^= 0xf;
740
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
741

    
742
                if(!s->progressive_sequence){
743
                    if(cbp)
744
                        put_bits(pb2, 1, s->interlaced_dct);
745
                }
746
    
747
                if(interleaved_stats){
748
                    s->misc_bits+= get_bits_diff(s);
749
                }
750

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

    
755
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
756
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
757
                }
758
            }
759

    
760
            if(interleaved_stats){ 
761
                s->mv_bits+= get_bits_diff(s);
762
            }
763

    
764
            /* encode each block */
765
            for (i = 0; i < 6; i++) {
766
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
767
            }
768

    
769
            if(interleaved_stats){
770
                s->p_tex_bits+= get_bits_diff(s);
771
            }
772
            s->f_count++;
773
        }
774
    } else {
775
        int cbp;
776
        int dc_diff[6];   //dc values with the dc prediction subtracted 
777
        int dir[6];  //prediction direction
778
        int zigzag_last_index[6];
779
        uint8_t *scan_table[6];
780
        int i;
781

    
782
        for(i=0; i<6; i++){
783
            const int level= block[i][0];
784
            uint16_t *dc_ptr;
785

    
786
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
787
            if (i < 4) {
788
                *dc_ptr = level * s->y_dc_scale;
789
            } else {
790
                *dc_ptr = level * s->c_dc_scale;
791
            }
792
        }
793

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

    
796
        if(s->ac_pred){
797
            for(i=0; i<6; i++){
798
                uint8_t *st;
799
                int last_index;
800

    
801
                mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
802
                if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
803
                else           st = s->intra_h_scantable.permutated; /* top */
804

    
805
                for(last_index=63; last_index>=0; last_index--) //FIXME optimize
806
                    if(block[i][st[last_index]]) break;
807
                zigzag_last_index[i]= s->block_last_index[i];
808
                s->block_last_index[i]= last_index;
809
                scan_table[i]= st;
810
            }
811
        }else{
812
            for(i=0; i<6; i++)
813
                scan_table[i]= s->intra_scantable.permutated;
814
        }
815

    
816
        /* compute cbp */
817
        cbp = 0;
818
        for (i = 0; i < 6; i++) {
819
            if (s->block_last_index[i] >= 1)
820
                cbp |= 1 << (5 - i);
821
        }
822

    
823
        cbpc = cbp & 3;
824
        if (s->pict_type == I_TYPE) {
825
            if(s->dquant) cbpc+=4;
826
            put_bits(&s->pb,
827
                intra_MCBPC_bits[cbpc],
828
                intra_MCBPC_code[cbpc]);
829
        } else {
830
            if(s->dquant) cbpc+=8;
831
            put_bits(&s->pb, 1, 0);        /* mb coded */
832
            put_bits(&s->pb,
833
                inter_MCBPC_bits[cbpc + 4],
834
                inter_MCBPC_code[cbpc + 4]);
835
        }
836
        put_bits(pb2, 1, s->ac_pred);
837
        cbpy = cbp >> 2;
838
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
839
        if(s->dquant)
840
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
841

    
842
        if(!s->progressive_sequence){
843
            put_bits(dc_pb, 1, s->interlaced_dct);
844
        }
845

    
846
        if(interleaved_stats){
847
            s->misc_bits+= get_bits_diff(s);
848
        }
849

    
850
        /* encode each block */
851
        for (i = 0; i < 6; i++) {
852
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
853
        }
854

    
855
        if(interleaved_stats){
856
            s->i_tex_bits+= get_bits_diff(s);
857
        }
858
        s->i_count++;
859

    
860
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
861
        if(s->ac_pred){
862
            for(i=0; i<6; i++){
863
                int j;    
864
                int16_t *ac_val;
865

    
866
                ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
867

    
868
                if(dir[i]){
869
                    for(j=1; j<8; j++) 
870
                        block[i][s->dsp.idct_permutation[j   ]]= ac_val[j+8];
871
                }else{
872
                    for(j=1; j<8; j++) 
873
                        block[i][s->dsp.idct_permutation[j<<3]]= ac_val[j  ];
874
                }
875
                s->block_last_index[i]= zigzag_last_index[i];
876
            }
877
        }
878
    }
879
}
880

    
881
void h263_encode_mb(MpegEncContext * s,
882
                    DCTELEM block[6][64],
883
                    int motion_x, int motion_y)
884
{
885
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
886
    int16_t pred_dc;
887
    int16_t rec_intradc[6];
888
    uint16_t *dc_ptr[6];
889
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
890
    const int dquant_code[5]= {1,0,9,2,3};
891
           
892
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
893
    if (!s->mb_intra) {
894
        /* compute cbp */
895
        cbp = 0;
896
        for (i = 0; i < 6; i++) {
897
            if (s->block_last_index[i] >= 0)
898
                cbp |= 1 << (5 - i);
899
        }
900
        if ((cbp | motion_x | motion_y | s->dquant) == 0) {
901
            /* skip macroblock */
902
            put_bits(&s->pb, 1, 1);
903
            if(interleaved_stats){
904
                s->misc_bits++;
905
                s->last_bits++;
906
            }
907
            return;
908
        }
909
        put_bits(&s->pb, 1, 0);        /* mb coded */
910
        cbpc = cbp & 3;
911
        if(s->dquant) cbpc+= 8;
912
        put_bits(&s->pb,
913
                    inter_MCBPC_bits[cbpc],
914
                    inter_MCBPC_code[cbpc]);
915
        cbpy = cbp >> 2;
916
        cbpy ^= 0xf;
917
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
918
        if(s->dquant)
919
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
920

    
921
        if(interleaved_stats){
922
            s->misc_bits+= get_bits_diff(s);
923
        }
924

    
925
        /* motion vectors: 16x16 mode only now */
926
        h263_pred_motion(s, 0, &pred_x, &pred_y);
927
      
928
        if (!s->umvplus) {  
929
            h263_encode_motion(s, motion_x - pred_x, s->f_code);
930
            h263_encode_motion(s, motion_y - pred_y, s->f_code);
931
        }
932
        else {
933
            h263p_encode_umotion(s, motion_x - pred_x);
934
            h263p_encode_umotion(s, motion_y - pred_y);
935
            if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
936
                /* To prevent Start Code emulation */
937
                put_bits(&s->pb,1,1);
938
        }
939

    
940
        if(interleaved_stats){
941
            s->mv_bits+= get_bits_diff(s);
942
        }
943
    } else {
944
        int li = s->h263_aic ? 0 : 1;
945
        
946
        cbp = 0;
947
        for(i=0; i<6; i++) {
948
            /* Predict DC */
949
            if (s->h263_aic && s->mb_intra) {
950
                int16_t level = block[i][0];
951
            
952
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
953
                level -= pred_dc;
954
                /* Quant */
955
                if (level < 0)
956
                    level = (level + (s->qscale >> 1))/(s->y_dc_scale);
957
                else
958
                    level = (level - (s->qscale >> 1))/(s->y_dc_scale);
959
                    
960
                /* AIC can change CBP */
961
                if (level == 0 && s->block_last_index[i] == 0)
962
                    s->block_last_index[i] = -1;
963
                else if (level < -127)
964
                    level = -127;
965
                else if (level > 127)
966
                    level = 127;
967
                
968
                block[i][0] = level;
969
                /* Reconstruction */ 
970
                rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
971
                /* Oddify */
972
                rec_intradc[i] |= 1;
973
                //if ((rec_intradc[i] % 2) == 0)
974
                //    rec_intradc[i]++;
975
                /* Clipping */
976
                if (rec_intradc[i] < 0)
977
                    rec_intradc[i] = 0;
978
                else if (rec_intradc[i] > 2047)
979
                    rec_intradc[i] = 2047;
980
                                
981
                /* Update AC/DC tables */
982
                *dc_ptr[i] = rec_intradc[i];
983
            }
984
            /* compute cbp */
985
            if (s->block_last_index[i] >= li)
986
                cbp |= 1 << (5 - i);
987
        }
988

    
989
        cbpc = cbp & 3;
990
        if (s->pict_type == I_TYPE) {
991
            if(s->dquant) cbpc+=4;
992
            put_bits(&s->pb,
993
                intra_MCBPC_bits[cbpc],
994
                intra_MCBPC_code[cbpc]);
995
        } else {
996
            if(s->dquant) cbpc+=8;
997
            put_bits(&s->pb, 1, 0);        /* mb coded */
998
            put_bits(&s->pb,
999
                inter_MCBPC_bits[cbpc + 4],
1000
                inter_MCBPC_code[cbpc + 4]);
1001
        }
1002
        if (s->h263_aic) {
1003
            /* XXX: currently, we do not try to use ac prediction */
1004
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
1005
        }
1006
        cbpy = cbp >> 2;
1007
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1008
        if(s->dquant)
1009
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1010

    
1011
        if(interleaved_stats){
1012
            s->misc_bits+= get_bits_diff(s);
1013
        }
1014
    }
1015

    
1016
    for(i=0; i<6; i++) {
1017
        /* encode each block */
1018
        h263_encode_block(s, block[i], i);
1019
    
1020
        /* Update INTRADC for decoding */
1021
        if (s->h263_aic && s->mb_intra) {
1022
            block[i][0] = rec_intradc[i];
1023
            
1024
        }
1025
    }
1026

    
1027
    if(interleaved_stats){
1028
        if (!s->mb_intra) {
1029
            s->p_tex_bits+= get_bits_diff(s);
1030
            s->f_count++;
1031
        }else{
1032
            s->i_tex_bits+= get_bits_diff(s);
1033
            s->i_count++;
1034
        }
1035
    }
1036
}
1037
#endif
1038

    
1039
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1040
{
1041
    int x, y, wrap, a, c, pred_dc, scale;
1042
    int16_t *dc_val, *ac_val;
1043

    
1044
    /* find prediction */
1045
    if (n < 4) {
1046
        x = 2 * s->mb_x + 1 + (n & 1);
1047
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1048
        wrap = s->mb_width * 2 + 2;
1049
        dc_val = s->dc_val[0];
1050
        ac_val = s->ac_val[0][0];
1051
        scale = s->y_dc_scale;
1052
    } else {
1053
        x = s->mb_x + 1;
1054
        y = s->mb_y + 1;
1055
        wrap = s->mb_width + 2;
1056
        dc_val = s->dc_val[n - 4 + 1];
1057
        ac_val = s->ac_val[n - 4 + 1][0];
1058
        scale = s->c_dc_scale;
1059
    }
1060
    /* B C
1061
     * A X 
1062
     */
1063
    a = dc_val[(x - 1) + (y) * wrap];
1064
    c = dc_val[(x) + (y - 1) * wrap];
1065
    
1066
    /* No prediction outside GOB boundary */
1067
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1068
        c = 1024;
1069
    pred_dc = 1024;
1070
    /* just DC prediction */
1071
    if (a != 1024 && c != 1024)
1072
        pred_dc = (a + c) >> 1;
1073
    else if (a != 1024)
1074
        pred_dc = a;
1075
    else
1076
        pred_dc = c;
1077
    
1078
    /* we assume pred is positive */
1079
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1080
    *dc_val_ptr = &dc_val[x + y * wrap];
1081
    return pred_dc;
1082
}
1083

    
1084
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1085
{
1086
    int x, y, wrap, a, c, pred_dc, scale, i;
1087
    int16_t *dc_val, *ac_val, *ac_val1;
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
    
1106
    ac_val += ((y) * wrap + (x)) * 16;
1107
    ac_val1 = ac_val;
1108
    
1109
    /* B C
1110
     * A X 
1111
     */
1112
    a = dc_val[(x - 1) + (y) * wrap];
1113
    c = dc_val[(x) + (y - 1) * wrap];
1114
    
1115
    /* No prediction outside GOB boundary */
1116
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1117
        c = 1024;
1118
    pred_dc = 1024;
1119
    if (s->ac_pred) {
1120
        if (s->h263_aic_dir) {
1121
            /* left prediction */
1122
            if (a != 1024) {
1123
                ac_val -= 16;
1124
                for(i=1;i<8;i++) {
1125
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1126
                }
1127
                pred_dc = a;
1128
            }
1129
        } else {
1130
            /* top prediction */
1131
            if (c != 1024) {
1132
                ac_val -= 16 * wrap;
1133
                for(i=1;i<8;i++) {
1134
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1135
                }
1136
                pred_dc = c;
1137
            }
1138
        }
1139
    } else {
1140
        /* just DC prediction */
1141
        if (a != 1024 && c != 1024)
1142
            pred_dc = (a + c) >> 1;
1143
        else if (a != 1024)
1144
            pred_dc = a;
1145
        else
1146
            pred_dc = c;
1147
    }
1148
    
1149
    /* we assume pred is positive */
1150
    block[0]=block[0]*scale + pred_dc;
1151
    
1152
    if (block[0] < 0)
1153
        block[0] = 0;
1154
    else if (!(block[0] & 1))
1155
        block[0]++;
1156
    
1157
    /* Update AC/DC tables */
1158
    dc_val[(x) + (y) * wrap] = block[0];
1159
    
1160
    /* left copy */
1161
    for(i=1;i<8;i++)
1162
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1163
    /* top copy */
1164
    for(i=1;i<8;i++)
1165
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1166
}
1167

    
1168
int16_t *h263_pred_motion(MpegEncContext * s, int block, 
1169
                        int *px, int *py)
1170
{
1171
    int xy, wrap;
1172
    int16_t *A, *B, *C, *mot_val;
1173
    static const int off[4]= {2, 1, 1, -1};
1174

    
1175
    wrap = s->block_wrap[0];
1176
    xy = s->block_index[block];
1177

    
1178
    mot_val = s->motion_val[xy];
1179

    
1180
    A = s->motion_val[xy - 1];
1181
    /* special case for first (slice) line */
1182
    if (s->first_slice_line && block<3) {
1183
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1184
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1185
        if(block==0){ //most common case
1186
            if(s->mb_x  == s->resync_mb_x){ //rare
1187
                *px= *py = 0;
1188
            }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1189
                C = s->motion_val[xy + off[block] - wrap];
1190
                if(s->mb_x==0){
1191
                    *px = C[0];
1192
                    *py = C[1];
1193
                }else{
1194
                    *px = mid_pred(A[0], 0, C[0]);
1195
                    *py = mid_pred(A[1], 0, C[1]);
1196
                }
1197
            }else{
1198
                *px = A[0];
1199
                *py = A[1];
1200
            }
1201
        }else if(block==1){
1202
            if(s->mb_x + 1 == s->resync_mb_x){ //rare
1203
                C = s->motion_val[xy + off[block] - wrap];
1204
                *px = mid_pred(A[0], 0, C[0]);
1205
                *py = mid_pred(A[1], 0, C[1]);
1206
            }else{
1207
                *px = A[0];
1208
                *py = A[1];
1209
            }
1210
        }else{ /* block==2*/
1211
            B = s->motion_val[xy - wrap];
1212
            C = s->motion_val[xy + off[block] - wrap];
1213
            if(s->mb_x == s->resync_mb_x) //rare
1214
                A[0]=A[1]=0;
1215
    
1216
            *px = mid_pred(A[0], B[0], C[0]);
1217
            *py = mid_pred(A[1], B[1], C[1]);
1218
        }
1219
    } else {
1220
        B = s->motion_val[xy - wrap];
1221
        C = s->motion_val[xy + off[block] - wrap];
1222
        *px = mid_pred(A[0], B[0], C[0]);
1223
        *py = mid_pred(A[1], B[1], C[1]);
1224
    }
1225
    return mot_val;
1226
}
1227

    
1228
#ifdef CONFIG_ENCODERS
1229
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1230
{
1231
    int range, l, bit_size, sign, code, bits;
1232

    
1233
    if (val == 0) {
1234
        /* zero vector */
1235
        code = 0;
1236
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1237
    } else {
1238
        bit_size = f_code - 1;
1239
        range = 1 << bit_size;
1240
        /* modulo encoding */
1241
        l = range * 32;
1242
#if 1
1243
        val+= l;
1244
        val&= 2*l-1;
1245
        val-= l;
1246
        sign = val>>31;
1247
        val= (val^sign)-sign;
1248
        sign&=1;
1249
#else
1250
        if (val < -l) {
1251
            val += 2*l;
1252
        } else if (val >= l) {
1253
            val -= 2*l;
1254
        }
1255

    
1256
        assert(val>=-l && val<l);
1257

    
1258
        if (val >= 0) {
1259
            sign = 0;
1260
        } else {
1261
            val = -val;
1262
            sign = 1;
1263
        }
1264
#endif
1265
        val--;
1266
        code = (val >> bit_size) + 1;
1267
        bits = val & (range - 1);
1268

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

    
1275
}
1276

    
1277
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1278
static void h263p_encode_umotion(MpegEncContext * s, int val)
1279
{
1280
    short sval = 0; 
1281
    short i = 0;
1282
    short n_bits = 0;
1283
    short temp_val;
1284
    int code = 0;
1285
    int tcode;
1286
    
1287
    if ( val == 0)
1288
        put_bits(&s->pb, 1, 1);
1289
    else if (val == 1)
1290
        put_bits(&s->pb, 3, 0);
1291
    else if (val == -1)
1292
        put_bits(&s->pb, 3, 2);
1293
    else {
1294
        
1295
        sval = ((val < 0) ? (short)(-val):(short)val);
1296
        temp_val = sval;
1297
        
1298
        while (temp_val != 0) {
1299
            temp_val = temp_val >> 1;
1300
            n_bits++;
1301
        }
1302
        
1303
        i = n_bits - 1;
1304
        while (i > 0) {
1305
            tcode = (sval & (1 << (i-1))) >> (i-1);
1306
            tcode = (tcode << 1) | 1;
1307
            code = (code << 2) | tcode;
1308
            i--;
1309
        }
1310
        code = ((code << 1) | (val < 0)) << 1;
1311
        put_bits(&s->pb, (2*n_bits)+1, code);
1312
        //printf("\nVal = %d\tCode = %d", sval, code);
1313
    }
1314
}
1315

    
1316
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1317
{
1318
    int f_code;
1319
    int mv;
1320
    
1321
    if(mv_penalty==NULL)
1322
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1323
    
1324
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1325
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1326
            int len;
1327

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

    
1332
                bit_size = s->f_code - 1;
1333
                range = 1 << bit_size;
1334

    
1335
                val=mv;
1336
                if (val < 0) 
1337
                    val = -val;
1338
                val--;
1339
                code = (val >> bit_size) + 1;
1340
                if(code<33){
1341
                    len= mvtab[code][1] + 1 + bit_size;
1342
                }else{
1343
                    len= mvtab[32][1] + 2 + bit_size;
1344
                }
1345
            }
1346

    
1347
            mv_penalty[f_code][mv+MAX_MV]= len;
1348
        }
1349
    }
1350

    
1351
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1352
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1353
            fcode_tab[mv+MAX_MV]= f_code;
1354
        }
1355
    }
1356

    
1357
    for(mv=0; mv<MAX_MV*2+1; mv++){
1358
        umv_fcode_tab[mv]= 1;
1359
    }
1360
}
1361
#endif
1362

    
1363
#ifdef CONFIG_ENCODERS
1364

    
1365
static void init_uni_dc_tab(void)
1366
{
1367
    int level, uni_code, uni_len;
1368

    
1369
    for(level=-256; level<256; level++){
1370
        int size, v, l;
1371
        /* find number of bits */
1372
        size = 0;
1373
        v = abs(level);
1374
        while (v) {
1375
            v >>= 1;
1376
            size++;
1377
        }
1378

    
1379
        if (level < 0)
1380
            l= (-level) ^ ((1 << size) - 1);
1381
        else
1382
            l= level;
1383

    
1384
        /* luminance */
1385
        uni_code= DCtab_lum[size][0];
1386
        uni_len = DCtab_lum[size][1];
1387

    
1388
        if (size > 0) {
1389
            uni_code<<=size; uni_code|=l;
1390
            uni_len+=size;
1391
            if (size > 8){
1392
                uni_code<<=1; uni_code|=1;
1393
                uni_len++;
1394
            }
1395
        }
1396
        uni_DCtab_lum_bits[level+256]= uni_code;
1397
        uni_DCtab_lum_len [level+256]= uni_len;
1398

    
1399
        /* chrominance */
1400
        uni_code= DCtab_chrom[size][0];
1401
        uni_len = DCtab_chrom[size][1];
1402
        
1403
        if (size > 0) {
1404
            uni_code<<=size; uni_code|=l;
1405
            uni_len+=size;
1406
            if (size > 8){
1407
                uni_code<<=1; uni_code|=1;
1408
                uni_len++;
1409
            }
1410
        }
1411
        uni_DCtab_chrom_bits[level+256]= uni_code;
1412
        uni_DCtab_chrom_len [level+256]= uni_len;
1413

    
1414
    }
1415
}
1416

    
1417
#endif //CONFIG_ENCODERS
1418

    
1419
#ifdef CONFIG_ENCODERS
1420
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1421
    int slevel, run, last;
1422
    
1423
    assert(MAX_LEVEL >= 64);
1424
    assert(MAX_RUN   >= 63);
1425

    
1426
    for(slevel=-64; slevel<64; slevel++){
1427
        if(slevel==0) continue;
1428
        for(run=0; run<64; run++){
1429
            for(last=0; last<=1; last++){
1430
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1431
                int level= slevel < 0 ? -slevel : slevel;
1432
                int sign= slevel < 0 ? 1 : 0;
1433
                int bits, len, code;
1434
                int level1, run1;
1435
                
1436
                len_tab[index]= 100;
1437
                     
1438
                /* ESC0 */
1439
                code= get_rl_index(rl, last, run, level);
1440
                bits= rl->table_vlc[code][0];
1441
                len=  rl->table_vlc[code][1];
1442
                bits=bits*2+sign; len++;
1443
                
1444
                if(code!=rl->n && len < len_tab[index]){
1445
                    bits_tab[index]= bits;
1446
                    len_tab [index]= len;
1447
                }
1448
#if 1
1449
                /* ESC1 */
1450
                bits= rl->table_vlc[rl->n][0];
1451
                len=  rl->table_vlc[rl->n][1];
1452
                bits=bits*2;    len++; //esc1
1453
                level1= level - rl->max_level[last][run];
1454
                if(level1>0){
1455
                    code= get_rl_index(rl, last, run, level1);
1456
                    bits<<= rl->table_vlc[code][1];
1457
                    len  += rl->table_vlc[code][1];
1458
                    bits += rl->table_vlc[code][0];
1459
                    bits=bits*2+sign; len++;
1460
                
1461
                    if(code!=rl->n && len < len_tab[index]){
1462
                        bits_tab[index]= bits;
1463
                        len_tab [index]= len;
1464
                    }
1465
                }
1466
#endif 
1467
#if 1
1468
                /* ESC2 */
1469
                bits= rl->table_vlc[rl->n][0];
1470
                len=  rl->table_vlc[rl->n][1];
1471
                bits=bits*4+2;    len+=2; //esc2
1472
                run1 = run - rl->max_run[last][level] - 1;
1473
                if(run1>=0){
1474
                    code= get_rl_index(rl, last, run1, level);
1475
                    bits<<= rl->table_vlc[code][1];
1476
                    len  += rl->table_vlc[code][1];
1477
                    bits += rl->table_vlc[code][0];
1478
                    bits=bits*2+sign; len++;
1479
                
1480
                    if(code!=rl->n && len < len_tab[index]){
1481
                        bits_tab[index]= bits;
1482
                        len_tab [index]= len;
1483
                    }
1484
                }
1485
#endif           
1486
                /* ESC3 */        
1487
                bits= rl->table_vlc[rl->n][0];
1488
                len = rl->table_vlc[rl->n][1];
1489
                bits=bits*4+3;    len+=2; //esc3
1490
                bits=bits*2+last; len++;
1491
                bits=bits*64+run; len+=6;
1492
                bits=bits*2+1;    len++;  //marker
1493
                bits=bits*4096+(slevel&0xfff); len+=12;
1494
                bits=bits*2+1;    len++;  //marker
1495
                
1496
                if(len < len_tab[index]){
1497
                    bits_tab[index]= bits;
1498
                    len_tab [index]= len;
1499
                }
1500
            }
1501
        }
1502
    }
1503
}
1504

    
1505
void h263_encode_init(MpegEncContext *s)
1506
{
1507
    static int done = 0;
1508

    
1509
    if (!done) {
1510
        done = 1;
1511

    
1512
        init_uni_dc_tab();
1513

    
1514
        init_rl(&rl_inter);
1515
        init_rl(&rl_intra);
1516
        init_rl(&rl_intra_aic);
1517
        
1518
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1519
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1520

    
1521
        init_mv_penalty_and_fcode(s);
1522
    }
1523
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1524
    
1525
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1526
    switch(s->codec_id){
1527
    case CODEC_ID_MPEG4:
1528
        s->fcode_tab= fcode_tab;
1529
        s->min_qcoeff= -2048;
1530
        s->max_qcoeff=  2047;
1531
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1532
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1533
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1534
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1535
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
1536
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1537
        s->ac_esc_length= 7+2+1+6+1+12+1;
1538
        break;
1539
    case CODEC_ID_H263P:
1540
        s->fcode_tab= umv_fcode_tab;
1541
        s->min_qcoeff= -127;
1542
        s->max_qcoeff=  127;
1543
        break;
1544
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1545
    case CODEC_ID_FLV1:
1546
        if (s->h263_flv > 1) {
1547
            s->min_qcoeff= -1023;
1548
            s->max_qcoeff=  1023;
1549
        } else {
1550
            s->min_qcoeff= -127;
1551
            s->max_qcoeff=  127;
1552
        }
1553
        s->y_dc_scale_table=
1554
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1555
        break;
1556
    default: //nothing needed default table allready set in mpegvideo.c
1557
        s->min_qcoeff= -127;
1558
        s->max_qcoeff=  127;
1559
        s->y_dc_scale_table=
1560
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1561
    }
1562
}
1563

    
1564
/**
1565
 * encodes a 8x8 block.
1566
 * @param block the 8x8 block
1567
 * @param n block index (0-3 are luma, 4-5 are chroma)
1568
 */
1569
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1570
{
1571
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1572
    RLTable *rl;
1573

    
1574
    rl = &rl_inter;
1575
    if (s->mb_intra && !s->h263_aic) {
1576
        /* DC coef */
1577
        level = block[0];
1578
        /* 255 cannot be represented, so we clamp */
1579
        if (level > 254) {
1580
            level = 254;
1581
            block[0] = 254;
1582
        }
1583
        /* 0 cannot be represented also */
1584
        else if (level < 1) {
1585
            level = 1;
1586
            block[0] = 1;
1587
        }
1588
        if (level == 128) //FIXME check rv10
1589
            put_bits(&s->pb, 8, 0xff);
1590
        else
1591
            put_bits(&s->pb, 8, level & 0xff);
1592
        i = 1;
1593
    } else {
1594
        i = 0;
1595
        if (s->h263_aic && s->mb_intra)
1596
            rl = &rl_intra_aic;
1597
    }
1598
   
1599
    /* AC coefs */
1600
    last_index = s->block_last_index[n];
1601
    last_non_zero = i - 1;
1602
    for (; i <= last_index; i++) {
1603
        j = s->intra_scantable.permutated[i];
1604
        level = block[j];
1605
        if (level) {
1606
            run = i - last_non_zero - 1;
1607
            last = (i == last_index);
1608
            sign = 0;
1609
            slevel = level;
1610
            if (level < 0) {
1611
                sign = 1;
1612
                level = -level;
1613
            }
1614
            code = get_rl_index(rl, last, run, level);
1615
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1616
            if (code == rl->n) {
1617
              if(s->h263_flv <= 1){
1618
                put_bits(&s->pb, 1, last);
1619
                put_bits(&s->pb, 6, run);
1620
                
1621
                assert(slevel != 0);
1622

    
1623
                if(slevel < 128 && slevel > -128) 
1624
                    put_bits(&s->pb, 8, slevel & 0xff);
1625
                else{
1626
                    put_bits(&s->pb, 8, 128);
1627
                    put_bits(&s->pb, 5, slevel & 0x1f);
1628
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
1629
                }
1630
              }else{
1631
                    if(slevel < 64 && slevel > -64) {
1632
                        /* 7-bit level */
1633
                        put_bits(&s->pb, 1, 0);
1634
                        put_bits(&s->pb, 1, last);
1635
                        put_bits(&s->pb, 6, run);
1636

    
1637
                        put_bits(&s->pb, 7, slevel & 0x7f);
1638
                    } else {
1639
                        /* 11-bit level */
1640
                        put_bits(&s->pb, 1, 1);
1641
                        put_bits(&s->pb, 1, last);
1642
                        put_bits(&s->pb, 6, run);
1643

    
1644
                        put_bits(&s->pb, 11, slevel & 0x7ff);
1645
                    }
1646
              }
1647
            } else {
1648
                put_bits(&s->pb, 1, sign);
1649
            }
1650
            last_non_zero = i;
1651
        }
1652
    }
1653
}
1654
#endif
1655

    
1656
#ifdef CONFIG_ENCODERS
1657

    
1658
/***************************************************/
1659
/**
1660
 * add mpeg4 stuffing bits (01...1)
1661
 */
1662
void ff_mpeg4_stuffing(PutBitContext * pbc)
1663
{
1664
    int length;
1665
    put_bits(pbc, 1, 0);
1666
    length= (-get_bit_count(pbc))&7;
1667
    if(length) put_bits(pbc, length, (1<<length)-1);
1668
}
1669

    
1670
/* must be called before writing the header */
1671
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1672
    int time_div, time_mod;
1673

    
1674
    if(s->pict_type==I_TYPE){ //we will encode a vol header
1675
        int dummy;
1676
        av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1677
        
1678
        s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1679
    }
1680
    
1681
    if(s->current_picture.pts)
1682
        s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1683
    else
1684
        s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
1685
    time_div= s->time/s->time_increment_resolution;
1686
    time_mod= s->time%s->time_increment_resolution;
1687

    
1688
    if(s->pict_type==B_TYPE){
1689
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1690
    }else{
1691
        s->last_time_base= s->time_base;
1692
        s->time_base= time_div;
1693
        s->pp_time= s->time - s->last_non_b_time;
1694
        s->last_non_b_time= s->time;
1695
    }
1696
}
1697

    
1698
static void mpeg4_encode_gop_header(MpegEncContext * s){
1699
    int hours, minutes, seconds;
1700
    
1701
    put_bits(&s->pb, 16, 0);
1702
    put_bits(&s->pb, 16, GOP_STARTCODE);
1703
    
1704
    seconds= s->time/s->time_increment_resolution;
1705
    minutes= seconds/60; seconds %= 60;
1706
    hours= minutes/60; minutes %= 60;
1707
    hours%=24;
1708

    
1709
    put_bits(&s->pb, 5, hours);
1710
    put_bits(&s->pb, 6, minutes);
1711
    put_bits(&s->pb, 1, 1);
1712
    put_bits(&s->pb, 6, seconds);
1713
    
1714
    put_bits(&s->pb, 1, 0); //closed gov == NO
1715
    put_bits(&s->pb, 1, 0); //broken link == NO
1716

    
1717
    ff_mpeg4_stuffing(&s->pb);
1718
}
1719

    
1720
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1721
    int profile_and_level_indication;
1722
    int vo_ver_id;
1723
    
1724
    if(s->max_b_frames || s->quarter_sample){
1725
        profile_and_level_indication= 0xF1; // adv simple level 1
1726
        vo_ver_id= 5;
1727
    }else{
1728
        profile_and_level_indication= 0x01; // simple level 1
1729
        vo_ver_id= 1;
1730
    }
1731
    //FIXME levels
1732

    
1733
    put_bits(&s->pb, 16, 0);
1734
    put_bits(&s->pb, 16, VOS_STARTCODE);
1735

    
1736
    put_bits(&s->pb, 8, profile_and_level_indication);
1737

    
1738
    put_bits(&s->pb, 16, 0);
1739
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1740
    
1741
    put_bits(&s->pb, 1, 1);
1742
        put_bits(&s->pb, 4, vo_ver_id);
1743
        put_bits(&s->pb, 3, 1); //priority
1744
 
1745
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
1746
    
1747
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1748

    
1749
    ff_mpeg4_stuffing(&s->pb);
1750
}
1751

    
1752
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
1753
{
1754
    int vo_ver_id;
1755

    
1756
    if(s->max_b_frames || s->quarter_sample){
1757
        vo_ver_id= 5;
1758
        s->vo_type= ADV_SIMPLE_VO_TYPE;
1759
    }else{
1760
        vo_ver_id= 1;
1761
        s->vo_type= SIMPLE_VO_TYPE;
1762
    }
1763

    
1764
    put_bits(&s->pb, 16, 0);
1765
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
1766
    put_bits(&s->pb, 16, 0);
1767
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
1768

    
1769
    put_bits(&s->pb, 1, 0);                /* random access vol */
1770
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
1771
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
1772
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
1773
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
1774
    
1775
    float_aspect_to_info(s, s->avctx->aspect_ratio);
1776

    
1777
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1778
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1779
    {
1780
        put_bits(&s->pb, 8, s->aspected_width);
1781
        put_bits(&s->pb, 8, s->aspected_height);
1782
    }
1783

    
1784
    if(s->low_delay){
1785
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
1786
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
1787
        put_bits(&s->pb, 1, s->low_delay);
1788
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
1789
    }else{
1790
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
1791
    }
1792

    
1793
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
1794
    put_bits(&s->pb, 1, 1);                /* marker bit */
1795
    
1796
    put_bits(&s->pb, 16, s->time_increment_resolution);
1797
    if (s->time_increment_bits < 1)
1798
        s->time_increment_bits = 1;
1799
    put_bits(&s->pb, 1, 1);                /* marker bit */
1800
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
1801
    put_bits(&s->pb, 1, 1);                /* marker bit */
1802
    put_bits(&s->pb, 13, s->width);        /* vol width */
1803
    put_bits(&s->pb, 1, 1);                /* marker bit */
1804
    put_bits(&s->pb, 13, s->height);        /* vol height */
1805
    put_bits(&s->pb, 1, 1);                /* marker bit */
1806
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1807
    put_bits(&s->pb, 1, 1);                /* obmc disable */
1808
    if (vo_ver_id == 1) {
1809
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
1810
    }else{
1811
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
1812
    }
1813
    
1814
    s->quant_precision=5;
1815
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
1816
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
1817
    if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1818

    
1819
    if (vo_ver_id != 1)
1820
        put_bits(&s->pb, 1, s->quarter_sample);
1821
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
1822
    s->resync_marker= s->rtp_mode;
1823
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1824
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1825
    if(s->data_partitioning){
1826
        put_bits(&s->pb, 1, 0);                /* no rvlc */
1827
    }
1828

    
1829
    if (vo_ver_id != 1){
1830
        put_bits(&s->pb, 1, 0);                /* newpred */
1831
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
1832
    }
1833
    put_bits(&s->pb, 1, 0);                /* scalability */
1834
    
1835
    ff_mpeg4_stuffing(&s->pb);
1836

    
1837
    /* user data */
1838
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
1839
        put_bits(&s->pb, 16, 0);
1840
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1841
        put_string(&s->pb, LIBAVCODEC_IDENT);
1842
        ff_mpeg4_stuffing(&s->pb);
1843
    }
1844
}
1845

    
1846
/* write mpeg4 VOP header */
1847
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1848
{
1849
    int time_incr;
1850
    int time_div, time_mod;
1851
    
1852
    if(s->pict_type==I_TYPE){
1853
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1854
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
1855
                mpeg4_encode_visual_object_header(s);
1856
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
1857
                mpeg4_encode_vol_header(s, 0, 0);
1858
        }
1859
        mpeg4_encode_gop_header(s);
1860
    }
1861
    
1862
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1863

    
1864
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1865
    
1866
    put_bits(&s->pb, 16, 0);                /* vop header */
1867
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
1868
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
1869

    
1870
    time_div= s->time/s->time_increment_resolution;
1871
    time_mod= s->time%s->time_increment_resolution;
1872
    time_incr= time_div - s->last_time_base;
1873
    while(time_incr--)
1874
        put_bits(&s->pb, 1, 1);
1875
        
1876
    put_bits(&s->pb, 1, 0);
1877

    
1878
    put_bits(&s->pb, 1, 1);        /* marker */
1879
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
1880
    put_bits(&s->pb, 1, 1);        /* marker */
1881
    put_bits(&s->pb, 1, 1);        /* vop coded */
1882
    if (    s->pict_type == P_TYPE 
1883
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1884
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
1885
    }
1886
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
1887
    if(!s->progressive_sequence){
1888
         put_bits(&s->pb, 1, s->top_field_first);
1889
         put_bits(&s->pb, 1, s->alternate_scan);
1890
    }
1891
    //FIXME sprite stuff
1892

    
1893
    put_bits(&s->pb, 5, s->qscale);
1894

    
1895
    if (s->pict_type != I_TYPE)
1896
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
1897
    if (s->pict_type == B_TYPE)
1898
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
1899
    //    printf("****frame %d\n", picture_number);
1900

    
1901
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
1902
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1903
     s->h_edge_pos= s->width;
1904
     s->v_edge_pos= s->height;
1905
}
1906

    
1907
#endif //CONFIG_ENCODERS
1908

    
1909
/**
1910
 * change qscale by given dquant and update qscale dependant variables.
1911
 */
1912
static void change_qscale(MpegEncContext * s, int dquant)
1913
{
1914
    s->qscale += dquant;
1915

    
1916
    if (s->qscale < 1)
1917
        s->qscale = 1;
1918
    else if (s->qscale > 31)
1919
        s->qscale = 31;
1920

    
1921
    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1922
    s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1923
}
1924

    
1925
/**
1926
 * predicts the dc.
1927
 * @param n block index (0-3 are luma, 4-5 are chroma)
1928
 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
1929
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
1930
 * @return the quantized predicted dc
1931
 */
1932
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
1933
{
1934
    int a, b, c, wrap, pred, scale;
1935
    uint16_t *dc_val;
1936

    
1937
    /* find prediction */
1938
    if (n < 4) {
1939
        scale = s->y_dc_scale;
1940
    } else {
1941
        scale = s->c_dc_scale;
1942
    }
1943
    if(IS_3IV1)
1944
        scale= 8;
1945

    
1946
    wrap= s->block_wrap[n];
1947
    dc_val = s->dc_val[0] + s->block_index[n];
1948

    
1949
    /* B C
1950
     * A X 
1951
     */
1952
    a = dc_val[ - 1];
1953
    b = dc_val[ - 1 - wrap];
1954
    c = dc_val[ - wrap];
1955

    
1956
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1957
    if(s->first_slice_line && n!=3){
1958
        if(n!=2) b=c= 1024;
1959
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1960
    }
1961
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1962
        if(n==0 || n==4 || n==5)
1963
            b=1024;
1964
    }
1965

    
1966
    if (abs(a - b) < abs(b - c)) {
1967
        pred = c;
1968
        *dir_ptr = 1; /* top */
1969
    } else {
1970
        pred = a;
1971
        *dir_ptr = 0; /* left */
1972
    }
1973
    /* we assume pred is positive */
1974
    pred = FASTDIV((pred + (scale >> 1)), scale);
1975

    
1976
    /* prepare address for prediction update */
1977
    *dc_val_ptr = &dc_val[0];
1978

    
1979
    return pred;
1980
}
1981

    
1982
/**
1983
 * predicts the ac.
1984
 * @param n block index (0-3 are luma, 4-5 are chroma)
1985
 * @param dir the ac prediction direction
1986
 */
1987
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
1988
                   int dir)
1989
{
1990
    int i;
1991
    int16_t *ac_val, *ac_val1;
1992
    int8_t * const qscale_table= s->current_picture.qscale_table;
1993

    
1994
    /* find prediction */
1995
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1996
    ac_val1 = ac_val;
1997
    if (s->ac_pred) {
1998
        if (dir == 0) {
1999
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2000
            /* left prediction */
2001
            ac_val -= 16;
2002
            
2003
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2004
                /* same qscale */
2005
                for(i=1;i<8;i++) {
2006
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2007
                }
2008
            }else{
2009
                /* different qscale, we must rescale */
2010
                for(i=1;i<8;i++) {
2011
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2012
                }
2013
            }
2014
        } else {
2015
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2016
            /* top prediction */
2017
            ac_val -= 16 * s->block_wrap[n];
2018

    
2019
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2020
                /* same qscale */
2021
                for(i=1;i<8;i++) {
2022
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2023
                }
2024
            }else{
2025
                /* different qscale, we must rescale */
2026
                for(i=1;i<8;i++) {
2027
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2028
                }
2029
            }
2030
        }
2031
    }
2032
    /* left copy */
2033
    for(i=1;i<8;i++)
2034
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2035

    
2036
    /* top copy */
2037
    for(i=1;i<8;i++)
2038
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2039

    
2040
}
2041

    
2042
#ifdef CONFIG_ENCODERS
2043

    
2044
static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2045
                              int dir)
2046
{
2047
    int i;
2048
    int16_t *ac_val;
2049
    int8_t * const qscale_table= s->current_picture.qscale_table;
2050

    
2051
    /* find prediction */
2052
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2053
 
2054
    if (dir == 0) {
2055
        const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2056
        /* left prediction */
2057
        ac_val -= 16;
2058
        if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2059
            /* same qscale */
2060
            for(i=1;i<8;i++) {
2061
                block[s->dsp.idct_permutation[i<<3]] -= ac_val[i];
2062
            }
2063
        }else{
2064
            /* different qscale, we must rescale */
2065
            for(i=1;i<8;i++) {
2066
                block[s->dsp.idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2067
            }
2068
        }
2069
    } else {
2070
        const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2071
        /* top prediction */
2072
        ac_val -= 16 * s->block_wrap[n];
2073
        if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2074
            /* same qscale */
2075
            for(i=1;i<8;i++) {
2076
                block[s->dsp.idct_permutation[i]] -= ac_val[i + 8];
2077
            }
2078
        }else{
2079
            /* different qscale, we must rescale */
2080
            for(i=1;i<8;i++) {
2081
                block[s->dsp.idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2082
            }
2083
        }
2084
    }
2085
}
2086

    
2087
/**
2088
 * encodes the dc value.
2089
 * @param n block index (0-3 are luma, 4-5 are chroma)
2090
 */
2091
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2092
{
2093
#if 1
2094
//    if(level<-255 || level>255) printf("dc overflow\n");
2095
    level+=256;
2096
    if (n < 4) {
2097
        /* luminance */
2098
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2099
    } else {
2100
        /* chrominance */
2101
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2102
    }
2103
#else
2104
    int size, v;
2105
    /* find number of bits */
2106
    size = 0;
2107
    v = abs(level);
2108
    while (v) {
2109
        v >>= 1;
2110
        size++;
2111
    }
2112

    
2113
    if (n < 4) {
2114
        /* luminance */
2115
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2116
    } else {
2117
        /* chrominance */
2118
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2119
    }
2120

    
2121
    /* encode remaining bits */
2122
    if (size > 0) {
2123
        if (level < 0)
2124
            level = (-level) ^ ((1 << size) - 1);
2125
        put_bits(&s->pb, size, level);
2126
        if (size > 8)
2127
            put_bits(&s->pb, 1, 1);
2128
    }
2129
#endif
2130
}
2131

    
2132
/**
2133
 * encodes a 8x8 block
2134
 * @param n block index (0-3 are luma, 4-5 are chroma)
2135
 */
2136
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2137
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2138
{
2139
    int i, last_non_zero;
2140
#if 0 //variables for the outcommented version
2141
    int code, sign, last;
2142
#endif
2143
    const RLTable *rl;
2144
    uint32_t *bits_tab;
2145
    uint8_t *len_tab;
2146
    const int last_index = s->block_last_index[n];
2147

    
2148
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2149
        /* mpeg4 based DC predictor */
2150
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2151
        if(last_index<1) return;
2152
        i = 1;
2153
        rl = &rl_intra;
2154
        bits_tab= uni_mpeg4_intra_rl_bits;
2155
        len_tab = uni_mpeg4_intra_rl_len;
2156
    } else {
2157
        if(last_index<0) return;
2158
        i = 0;
2159
        rl = &rl_inter;
2160
        bits_tab= uni_mpeg4_inter_rl_bits;
2161
        len_tab = uni_mpeg4_inter_rl_len;
2162
    }
2163

    
2164
    /* AC coefs */
2165
    last_non_zero = i - 1;
2166
#if 1
2167
    for (; i < last_index; i++) {
2168
        int level = block[ scan_table[i] ];
2169
        if (level) {
2170
            int run = i - last_non_zero - 1;
2171
            level+=64;
2172
            if((level&(~127)) == 0){
2173
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2174
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2175
            }else{ //ESC3
2176
                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);
2177
            }
2178
            last_non_zero = i;
2179
        }
2180
    }
2181
    /*if(i<=last_index)*/{
2182
        int level = block[ scan_table[i] ];
2183
        int run = i - last_non_zero - 1;
2184
        level+=64;
2185
        if((level&(~127)) == 0){
2186
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2187
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2188
        }else{ //ESC3
2189
            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);
2190
        }
2191
    }
2192
#else
2193
    for (; i <= last_index; i++) {
2194
        const int slevel = block[ scan_table[i] ];
2195
        if (slevel) {
2196
            int level;
2197
            int run = i - last_non_zero - 1;
2198
            last = (i == last_index);
2199
            sign = 0;
2200
            level = slevel;
2201
            if (level < 0) {
2202
                sign = 1;
2203
                level = -level;
2204
            }
2205
            code = get_rl_index(rl, last, run, level);
2206
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2207
            if (code == rl->n) {
2208
                int level1, run1;
2209
                level1 = level - rl->max_level[last][run];
2210
                if (level1 < 1) 
2211
                    goto esc2;
2212
                code = get_rl_index(rl, last, run, level1);
2213
                if (code == rl->n) {
2214
                esc2:
2215
                    put_bits(ac_pb, 1, 1);
2216
                    if (level > MAX_LEVEL)
2217
                        goto esc3;
2218
                    run1 = run - rl->max_run[last][level] - 1;
2219
                    if (run1 < 0)
2220
                        goto esc3;
2221
                    code = get_rl_index(rl, last, run1, level);
2222
                    if (code == rl->n) {
2223
                    esc3:
2224
                        /* third escape */
2225
                        put_bits(ac_pb, 1, 1);
2226
                        put_bits(ac_pb, 1, last);
2227
                        put_bits(ac_pb, 6, run);
2228
                        put_bits(ac_pb, 1, 1);
2229
                        put_bits(ac_pb, 12, slevel & 0xfff);
2230
                        put_bits(ac_pb, 1, 1);
2231
                    } else {
2232
                        /* second escape */
2233
                        put_bits(ac_pb, 1, 0);
2234
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2235
                        put_bits(ac_pb, 1, sign);
2236
                    }
2237
                } else {
2238
                    /* first escape */
2239
                    put_bits(ac_pb, 1, 0);
2240
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2241
                    put_bits(ac_pb, 1, sign);
2242
                }
2243
            } else {
2244
                put_bits(ac_pb, 1, sign);
2245
            }
2246
            last_non_zero = i;
2247
        }
2248
    }
2249
#endif
2250
}
2251

    
2252
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2253
                               uint8_t *scan_table)
2254
{
2255
    int i, last_non_zero;
2256
    const RLTable *rl;
2257
    uint8_t *len_tab;
2258
    const int last_index = s->block_last_index[n];
2259
    int len=0;
2260

    
2261
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2262
        /* mpeg4 based DC predictor */
2263
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2264
        if(last_index<1) return len;
2265
        i = 1;
2266
        rl = &rl_intra;
2267
        len_tab = uni_mpeg4_intra_rl_len;
2268
    } else {
2269
        if(last_index<0) return 0;
2270
        i = 0;
2271
        rl = &rl_inter;
2272
        len_tab = uni_mpeg4_inter_rl_len;
2273
    }
2274

    
2275
    /* AC coefs */
2276
    last_non_zero = i - 1;
2277
    for (; i < last_index; i++) {
2278
        int level = block[ scan_table[i] ];
2279
        if (level) {
2280
            int run = i - last_non_zero - 1;
2281
            level+=64;
2282
            if((level&(~127)) == 0){
2283
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2284
                len += len_tab[index];
2285
            }else{ //ESC3
2286
                len += 7+2+1+6+1+12+1;
2287
            }
2288
            last_non_zero = i;
2289
        }
2290
    }
2291
    /*if(i<=last_index)*/{
2292
        int level = block[ scan_table[i] ];
2293
        int run = i - last_non_zero - 1;
2294
        level+=64;
2295
        if((level&(~127)) == 0){
2296
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2297
            len += len_tab[index];
2298
        }else{ //ESC3
2299
            len += 7+2+1+6+1+12+1;
2300
        }
2301
    }
2302
    
2303
    return len;
2304
}
2305

    
2306
#endif
2307

    
2308

    
2309
/***********************************************/
2310
/* decoding */
2311

    
2312
static VLC intra_MCBPC_vlc;
2313
static VLC inter_MCBPC_vlc;
2314
static VLC cbpy_vlc;
2315
static VLC mv_vlc;
2316
static VLC dc_lum, dc_chrom;
2317
static VLC sprite_trajectory;
2318
static VLC mb_type_b_vlc;
2319

    
2320
void init_vlc_rl(RLTable *rl)
2321
{
2322
    int i, q;
2323
    
2324
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2325
             &rl->table_vlc[0][1], 4, 2,
2326
             &rl->table_vlc[0][0], 4, 2);
2327

    
2328
    
2329
    for(q=0; q<32; q++){
2330
        int qmul= q*2;
2331
        int qadd= (q-1)|1;
2332
        
2333
        if(q==0){
2334
            qmul=1;
2335
            qadd=0;
2336
        }
2337
        
2338
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2339
        for(i=0; i<rl->vlc.table_size; i++){
2340
            int code= rl->vlc.table[i][0];
2341
            int len = rl->vlc.table[i][1];
2342
            int level, run;
2343
        
2344
            if(len==0){ // illegal code
2345
                run= 66;
2346
                level= MAX_LEVEL;
2347
            }else if(len<0){ //more bits needed
2348
                run= 0;
2349
                level= code;
2350
            }else{
2351
                if(code==rl->n){ //esc
2352
                    run= 66;
2353
                    level= 0;
2354
                }else{
2355
                    run=   rl->table_run  [code] + 1;
2356
                    level= rl->table_level[code] * qmul + qadd;
2357
                    if(code >= rl->last) run+=192;
2358
                }
2359
            }
2360
            rl->rl_vlc[q][i].len= len;
2361
            rl->rl_vlc[q][i].level= level;
2362
            rl->rl_vlc[q][i].run= run;
2363
        }
2364
    }
2365
}
2366

    
2367
/* init vlcs */
2368

    
2369
/* XXX: find a better solution to handle static init */
2370
void h263_decode_init_vlc(MpegEncContext *s)
2371
{
2372
    static int done = 0;
2373

    
2374
    if (!done) {
2375
        done = 1;
2376

    
2377
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8, 
2378
                 intra_MCBPC_bits, 1, 1,
2379
                 intra_MCBPC_code, 1, 1);
2380
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25, 
2381
                 inter_MCBPC_bits, 1, 1,
2382
                 inter_MCBPC_code, 1, 1);
2383
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2384
                 &cbpy_tab[0][1], 2, 1,
2385
                 &cbpy_tab[0][0], 2, 1);
2386
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2387
                 &mvtab[0][1], 2, 1,
2388
                 &mvtab[0][0], 2, 1);
2389
        init_rl(&rl_inter);
2390
        init_rl(&rl_intra);
2391
        init_rl(&rvlc_rl_inter);
2392
        init_rl(&rvlc_rl_intra);
2393
        init_rl(&rl_intra_aic);
2394
        init_vlc_rl(&rl_inter);
2395
        init_vlc_rl(&rl_intra);
2396
        init_vlc_rl(&rvlc_rl_inter);
2397
        init_vlc_rl(&rvlc_rl_intra);
2398
        init_vlc_rl(&rl_intra_aic);
2399
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2400
                 &DCtab_lum[0][1], 2, 1,
2401
                 &DCtab_lum[0][0], 2, 1);
2402
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2403
                 &DCtab_chrom[0][1], 2, 1,
2404
                 &DCtab_chrom[0][0], 2, 1);
2405
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2406
                 &sprite_trajectory_tab[0][1], 4, 2,
2407
                 &sprite_trajectory_tab[0][0], 4, 2);
2408
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2409
                 &mb_type_b_tab[0][1], 2, 1,
2410
                 &mb_type_b_tab[0][0], 2, 1);
2411
    }
2412
}
2413

    
2414
/**
2415
 * Get the GOB height based on picture height.
2416
 */
2417
int ff_h263_get_gob_height(MpegEncContext *s){
2418
    if (s->height <= 400)
2419
        return 1;
2420
    else if (s->height <= 800)
2421
        return  2;
2422
    else
2423
        return 4;
2424
}
2425

    
2426
/**
2427
 * decodes the group of blocks header.
2428
 * @return <0 if an error occured
2429
 */
2430
static int h263_decode_gob_header(MpegEncContext *s)
2431
{
2432
    unsigned int val, gfid;
2433
    int left;
2434
    
2435
    /* Check for GOB Start Code */
2436
    val = show_bits(&s->gb, 16);
2437
    if(val)
2438
        return -1;
2439

    
2440
        /* We have a GBSC probably with GSTUFF */
2441
    skip_bits(&s->gb, 16); /* Drop the zeros */
2442
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2443
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2444
    for(;left>13; left--){
2445
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2446
    }
2447
    if(left<=13) 
2448
        return -1;
2449

    
2450
#ifdef DEBUG
2451
    fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2452
#endif
2453
    s->gob_number = get_bits(&s->gb, 5); /* GN */
2454
    gfid = get_bits(&s->gb, 2); /* GFID */
2455
    s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2456
    if(s->qscale==0) 
2457
        return -1;
2458
    s->mb_x= 0;
2459
    s->mb_y= s->gob_index* s->gob_number;
2460
#ifdef DEBUG
2461
    fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2462
#endif
2463
    return 0;
2464
}
2465

    
2466
static inline void memsetw(short *tab, int val, int n)
2467
{
2468
    int i;
2469
    for(i=0;i<n;i++)
2470
        tab[i] = val;
2471
}
2472

    
2473
#ifdef CONFIG_ENCODERS
2474

    
2475
void ff_mpeg4_init_partitions(MpegEncContext *s)
2476
{
2477
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2478
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
2479
}
2480

    
2481
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2482
{
2483
    const int pb2_len   = get_bit_count(&s->pb2   );
2484
    const int tex_pb_len= get_bit_count(&s->tex_pb);
2485
    const int bits= get_bit_count(&s->pb);
2486

    
2487
    if(s->pict_type==I_TYPE){
2488
        put_bits(&s->pb, 19, DC_MARKER);
2489
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2490
        s->i_tex_bits+= tex_pb_len;
2491
    }else{
2492
        put_bits(&s->pb, 17, MOTION_MARKER);
2493
        s->misc_bits+=17 + pb2_len;
2494
        s->mv_bits+= bits - s->last_bits;
2495
        s->p_tex_bits+= tex_pb_len;
2496
    }
2497

    
2498
    flush_put_bits(&s->pb2);
2499
    flush_put_bits(&s->tex_pb);
2500

    
2501
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2502
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2503
    s->last_bits= get_bit_count(&s->pb);
2504
}
2505

    
2506
#endif //CONFIG_ENCODERS
2507

    
2508
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2509
    switch(s->pict_type){
2510
        case I_TYPE:
2511
            return 16;
2512
        case P_TYPE:
2513
        case S_TYPE:
2514
            return s->f_code+15;
2515
        case B_TYPE:
2516
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2517
        default:
2518
            return -1;
2519
    }
2520
}
2521

    
2522
#ifdef CONFIG_ENCODERS
2523

    
2524
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2525
{
2526
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2527

    
2528
    ff_mpeg4_stuffing(&s->pb);
2529
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2530
    put_bits(&s->pb, 1, 1);
2531
    
2532
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2533
    put_bits(&s->pb, s->quant_precision, s->qscale);
2534
    put_bits(&s->pb, 1, 0); /* no HEC */
2535
}
2536

    
2537
#endif //CONFIG_ENCODERS
2538

    
2539
/**
2540
 * check if the next stuff is a resync marker or the end.
2541
 * @return 0 if not
2542
 */
2543
static inline int mpeg4_is_resync(MpegEncContext *s){
2544
    const int bits_count= get_bits_count(&s->gb);
2545
    
2546
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
2547
        return 0;
2548
    }
2549

    
2550
    if(bits_count + 8 >= s->gb.size_in_bits){
2551
        int v= show_bits(&s->gb, 8);
2552
        v|= 0x7F >> (7-(bits_count&7));
2553
                
2554
        if(v==0x7F)
2555
            return 1;
2556
    }else{
2557
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2558
            int len;
2559
            GetBitContext gb= s->gb;
2560
        
2561
            skip_bits(&s->gb, 1);
2562
            align_get_bits(&s->gb);
2563
        
2564
            for(len=0; len<32; len++){
2565
                if(get_bits1(&s->gb)) break;
2566
            }
2567

    
2568
            s->gb= gb;
2569

    
2570
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2571
                return 1;
2572
        }
2573
    }
2574
    return 0;
2575
}
2576

    
2577
/**
2578
 * decodes the next video packet.
2579
 * @return <0 if something went wrong
2580
 */
2581
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2582
{
2583
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2584
    int header_extension=0, mb_num, len;
2585
    
2586
    /* is there enough space left for a video packet + header */
2587
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2588

    
2589
    for(len=0; len<32; len++){
2590
        if(get_bits1(&s->gb)) break;
2591
    }
2592

    
2593
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2594
        printf("marker does not match f_code\n");
2595
        return -1;
2596
    }
2597
    
2598
    if(s->shape != RECT_SHAPE){
2599
        header_extension= get_bits1(&s->gb);
2600
        //FIXME more stuff here
2601
    }
2602

    
2603
    mb_num= get_bits(&s->gb, mb_num_bits);
2604
    if(mb_num>=s->mb_num){
2605
        fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2606
        return -1;
2607
    }
2608
    if(s->pict_type == B_TYPE){
2609
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
2610
        if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
2611
    }
2612
    
2613
    s->mb_x= mb_num % s->mb_width;
2614
    s->mb_y= mb_num / s->mb_width;
2615

    
2616
    if(s->shape != BIN_ONLY_SHAPE){
2617
        int qscale= get_bits(&s->gb, s->quant_precision); 
2618
        if(qscale)
2619
            s->qscale= qscale;
2620
    }
2621

    
2622
    if(s->shape == RECT_SHAPE){
2623
        header_extension= get_bits1(&s->gb);
2624
    }
2625
    if(header_extension){
2626
        int time_increment;
2627
        int time_incr=0;
2628

    
2629
        while (get_bits1(&s->gb) != 0) 
2630
            time_incr++;
2631

    
2632
        check_marker(&s->gb, "before time_increment in video packed header");
2633
        time_increment= get_bits(&s->gb, s->time_increment_bits);
2634
        check_marker(&s->gb, "before vop_coding_type in video packed header");
2635
        
2636
        skip_bits(&s->gb, 2); /* vop coding type */
2637
        //FIXME not rect stuff here
2638

    
2639
        if(s->shape != BIN_ONLY_SHAPE){
2640
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2641
//FIXME dont just ignore everything
2642
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2643
                mpeg4_decode_sprite_trajectory(s);
2644
                fprintf(stderr, "untested\n");
2645
            }
2646

    
2647
            //FIXME reduced res stuff here
2648
            
2649
            if (s->pict_type != I_TYPE) {
2650
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
2651
                if(f_code==0){
2652
                    printf("Error, video packet header damaged (f_code=0)\n");
2653
                }
2654
            }
2655
            if (s->pict_type == B_TYPE) {
2656
                int b_code = get_bits(&s->gb, 3);
2657
                if(b_code==0){
2658
                    printf("Error, video packet header damaged (b_code=0)\n");
2659
                }
2660
            }       
2661
        }
2662
    }
2663
    //FIXME new-pred stuff
2664
    
2665
//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));
2666

    
2667
    return 0;
2668
}
2669

    
2670
void ff_mpeg4_clean_buffers(MpegEncContext *s)
2671
{
2672
    int c_wrap, c_xy, l_wrap, l_xy;
2673

    
2674
    l_wrap= s->block_wrap[0];
2675
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2676
    c_wrap= s->block_wrap[4];
2677
    c_xy= s->mb_y*c_wrap + s->mb_x;
2678

    
2679
#if 0
2680
    /* clean DC */
2681
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2682
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2683
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2684
#endif
2685

    
2686
    /* clean AC */
2687
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
2688
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2689
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2690

    
2691
    /* clean MV */
2692
    // we cant clear the MVs as they might be needed by a b frame
2693
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2694
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2695
    s->last_mv[0][0][0]=
2696
    s->last_mv[0][0][1]=
2697
    s->last_mv[1][0][0]=
2698
    s->last_mv[1][0][1]= 0;
2699
}
2700

    
2701
/**
2702
 * decodes the group of blocks / video packet header.
2703
 * @return <0 if no resync found
2704
 */
2705
int ff_h263_resync(MpegEncContext *s){
2706
    int left, ret;
2707
    
2708
    if(s->codec_id==CODEC_ID_MPEG4)
2709
        skip_bits1(&s->gb);
2710
    
2711
    align_get_bits(&s->gb);
2712

    
2713
    if(show_bits(&s->gb, 16)==0){
2714
        if(s->codec_id==CODEC_ID_MPEG4)
2715
            ret= mpeg4_decode_video_packet_header(s);
2716
        else
2717
            ret= h263_decode_gob_header(s);
2718
        if(ret>=0)
2719
            return 0;
2720
    }
2721
    //ok, its not where its supposed to be ...
2722
    s->gb= s->last_resync_gb;
2723
    align_get_bits(&s->gb);
2724
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2725
    
2726
    for(;left>16+1+5+5; left-=8){ 
2727
        if(show_bits(&s->gb, 16)==0){
2728
            GetBitContext bak= s->gb;
2729

    
2730
            if(s->codec_id==CODEC_ID_MPEG4)
2731
                ret= mpeg4_decode_video_packet_header(s);
2732
            else
2733
                ret= h263_decode_gob_header(s);
2734
            if(ret>=0)
2735
                return 0;
2736

    
2737
            s->gb= bak;
2738
        }
2739
        skip_bits(&s->gb, 8);
2740
    }
2741
    
2742
    return -1;
2743
}
2744

    
2745
/**
2746
 * gets the average motion vector for a GMC MB.
2747
 * @param n either 0 for the x component or 1 for y
2748
 * @returns the average MV for a GMC MB
2749
 */
2750
static inline int get_amv(MpegEncContext *s, int n){
2751
    int x, y, mb_v, sum, dx, dy, shift;
2752
    int len = 1 << (s->f_code + 4);
2753
    const int a= s->sprite_warping_accuracy;
2754

    
2755
    if(s->real_sprite_warping_points==1){
2756
        if(s->divx_version==500 && s->divx_build==413)
2757
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2758
        else
2759
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2760
    }else{
2761
        dx= s->sprite_delta[n][0];
2762
        dy= s->sprite_delta[n][1];
2763
        shift= s->sprite_shift[0];
2764
        if(n) dy -= 1<<(shift + a + 1);
2765
        else  dx -= 1<<(shift + a + 1);
2766
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2767

    
2768
        sum=0;
2769
        for(y=0; y<16; y++){
2770
            int v;
2771
        
2772
            v= mb_v + dy*y;
2773
            //XXX FIXME optimize
2774
            for(x=0; x<16; x++){
2775
                sum+= v>>shift;
2776
                v+= dx;
2777
            }
2778
        }
2779
        sum= RSHIFT(sum, a+8-s->quarter_sample);
2780
    }
2781

    
2782
    if      (sum < -len) sum= -len;
2783
    else if (sum >= len) sum= len-1;
2784

    
2785
    return sum;
2786
}
2787

    
2788
/**
2789
 * decodes first partition.
2790
 * @return number of MBs decoded or <0 if an error occured
2791
 */
2792
static int mpeg4_decode_partition_a(MpegEncContext *s){
2793
    int mb_num;
2794
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2795
    
2796
    /* decode first partition */
2797
    mb_num=0;
2798
    s->first_slice_line=1;
2799
    for(; s->mb_y<s->mb_height; s->mb_y++){
2800
        ff_init_block_index(s);
2801
        for(; s->mb_x<s->mb_width; s->mb_x++){
2802
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
2803
            int cbpc;
2804
            int dir=0;
2805
            
2806
            mb_num++;
2807
            ff_update_block_index(s);
2808
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2809
                s->first_slice_line=0;
2810
            
2811
            if(s->pict_type==I_TYPE){
2812
                int i;
2813

    
2814
                if(show_bits_long(&s->gb, 19)==DC_MARKER){
2815
                    return mb_num-1;
2816
                }
2817

    
2818
                cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2819
                if (cbpc < 0){
2820

    
2821
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2822
                    return -1;
2823
                }
2824
                s->cbp_table[xy]= cbpc & 3;
2825
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2826
                s->mb_intra = 1;
2827

    
2828
                if(cbpc & 4) {
2829
                    change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2830
                }
2831
                s->current_picture.qscale_table[xy]= s->qscale;
2832

    
2833
                s->mbintra_table[xy]= 1;
2834
                for(i=0; i<6; i++){
2835
                    int dc_pred_dir;
2836
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2837
                    if(dc < 0){
2838
                        fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2839
                        return -1;
2840
                    }
2841
                    dir<<=1;
2842
                    if(dc_pred_dir) dir|=1;
2843
                }
2844
                s->pred_dir_table[xy]= dir;
2845
            }else{ /* P/S_TYPE */
2846
                int mx, my, pred_x, pred_y, bits;
2847
                int16_t * const mot_val= s->motion_val[s->block_index[0]];
2848
                const int stride= s->block_wrap[0]*2;
2849

    
2850
                bits= show_bits(&s->gb, 17);
2851
                if(bits==MOTION_MARKER){
2852
                    return mb_num-1;
2853
                }
2854
                skip_bits1(&s->gb);
2855
                if(bits&0x10000){
2856
                    /* skip mb */
2857
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2858
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
2859
                        mx= get_amv(s, 0);
2860
                        my= get_amv(s, 1);
2861
                    }else{
2862
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
2863
                        mx=my=0;
2864
                    }
2865
                    mot_val[0       ]= mot_val[2       ]=
2866
                    mot_val[0+stride]= mot_val[2+stride]= mx;
2867
                    mot_val[1       ]= mot_val[3       ]=
2868
                    mot_val[1+stride]= mot_val[3+stride]= my;
2869

    
2870
                    if(s->mbintra_table[xy])
2871
                        ff_clean_intra_table_entries(s);
2872
                    continue;
2873
                }
2874
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2875
                if (cbpc < 0){
2876
                    fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2877
                    return -1;
2878
                }
2879
                if (cbpc > 20)
2880
                    cbpc+=3;
2881
                else if (cbpc == 20)
2882
                    fprintf(stderr, "Stuffing !");
2883
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2884
    
2885
                s->mb_intra = ((cbpc & 4) != 0);
2886
        
2887
                if(s->mb_intra){
2888
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2889
                    s->mbintra_table[xy]= 1;
2890
                    mot_val[0       ]= mot_val[2       ]= 
2891
                    mot_val[0+stride]= mot_val[2+stride]= 0;
2892
                    mot_val[1       ]= mot_val[3       ]=
2893
                    mot_val[1+stride]= mot_val[3+stride]= 0;
2894
                }else{
2895
                    if(s->mbintra_table[xy])
2896
                        ff_clean_intra_table_entries(s);
2897

    
2898
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2899
                        s->mcsel= get_bits1(&s->gb);
2900
                    else s->mcsel= 0;
2901
        
2902
                    if ((cbpc & 16) == 0) {
2903
                        /* 16x16 motion prediction */
2904

    
2905
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
2906
                        if(!s->mcsel){
2907
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2908
                            if (mx >= 0xffff)
2909
                                return -1;
2910

    
2911
                            my = h263_decode_motion(s, pred_y, s->f_code);
2912
                            if (my >= 0xffff)
2913
                                return -1;
2914
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
2915
                        } else {
2916
                            mx = get_amv(s, 0);
2917
                            my = get_amv(s, 1);
2918
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
2919
                        }
2920

    
2921
                        mot_val[0       ]= mot_val[2       ] =
2922
                        mot_val[0+stride]= mot_val[2+stride]= mx;
2923
                        mot_val[1       ]= mot_val[3       ]=
2924
                        mot_val[1+stride]= mot_val[3+stride]= my;
2925
                    } else {
2926
                        int i;
2927
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
2928
                        for(i=0;i<4;i++) {
2929
                            int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2930
                            mx = h263_decode_motion(s, pred_x, s->f_code);
2931
                            if (mx >= 0xffff)
2932
                                return -1;
2933
                
2934
                            my = h263_decode_motion(s, pred_y, s->f_code);
2935
                            if (my >= 0xffff)
2936
                                return -1;
2937
                            mot_val[0] = mx;
2938
                            mot_val[1] = my;
2939
                        }
2940
                    }
2941
                }
2942
            }
2943
        }
2944
        s->mb_x= 0;
2945
    }
2946

    
2947
    return mb_num;
2948
}
2949

    
2950
/**
2951
 * decode second partition.
2952
 * @return <0 if an error occured
2953
 */
2954
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
2955
    int mb_num=0;
2956
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2957

    
2958
    s->mb_x= s->resync_mb_x;
2959
    s->first_slice_line=1;
2960
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2961
        ff_init_block_index(s);
2962
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
2963
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
2964

    
2965
            mb_num++;
2966
            ff_update_block_index(s);
2967
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2968
                s->first_slice_line=0;
2969
            
2970
            if(s->pict_type==I_TYPE){
2971
                int ac_pred= get_bits1(&s->gb);
2972
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2973
                if(cbpy<0){
2974
                    fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2975
                    return -1;
2976
                }
2977
                
2978
                s->cbp_table[xy]|= cbpy<<2;
2979
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
2980
            }else{ /* P || S_TYPE */
2981
                if(IS_INTRA(s->current_picture.mb_type[xy])){          
2982
                    int dir=0,i;
2983
                    int ac_pred = get_bits1(&s->gb);
2984
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2985

    
2986
                    if(cbpy<0){
2987
                        fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2988
                        return -1;
2989
                    }
2990
                    
2991
                    if(s->cbp_table[xy] & 8) {
2992
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2993
                    }
2994
                    s->current_picture.qscale_table[xy]= s->qscale;
2995

    
2996
                    for(i=0; i<6; i++){
2997
                        int dc_pred_dir;
2998
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
2999
                        if(dc < 0){
3000
                            fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3001
                            return -1;
3002
                        }
3003
                        dir<<=1;
3004
                        if(dc_pred_dir) dir|=1;
3005
                    }
3006
                    s->cbp_table[xy]&= 3; //remove dquant
3007
                    s->cbp_table[xy]|= cbpy<<2;
3008
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3009
                    s->pred_dir_table[xy]= dir;
3010
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3011
                    s->current_picture.qscale_table[xy]= s->qscale;
3012
                    s->cbp_table[xy]= 0;
3013
                }else{
3014
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3015

    
3016
                    if(cbpy<0){
3017
                        fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3018
                        return -1;
3019
                    }
3020
                    
3021
                    if(s->cbp_table[xy] & 8) {
3022
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3023
                    }
3024
                    s->current_picture.qscale_table[xy]= s->qscale;
3025

    
3026
                    s->cbp_table[xy]&= 3; //remove dquant
3027
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3028
                }
3029
            }
3030
        }
3031
        if(mb_num >= mb_count) return 0;
3032
        s->mb_x= 0;
3033
    }
3034
    return 0;
3035
}
3036

    
3037
/**
3038
 * decodes the first & second partition
3039
 * @return <0 if error (and sets error type in the error_status_table)
3040
 */
3041
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3042
{
3043
    int mb_num;
3044
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3045
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3046
    
3047
    mb_num= mpeg4_decode_partition_a(s);    
3048
    if(mb_num<0){
3049
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3050
        return -1;
3051
    }
3052
    
3053
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3054
        fprintf(stderr, "slice below monitor ...\n");
3055
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3056
        return -1;
3057
    }
3058

    
3059
    s->mb_num_left= mb_num;
3060
        
3061
    if(s->pict_type==I_TYPE){
3062
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3063
            fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3064
            return -1;
3065
        }
3066
    }else{
3067
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3068
            fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3069
            return -1;
3070
        }
3071
    }
3072
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3073
    
3074
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3075
        if(s->pict_type==P_TYPE)
3076
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3077
        return -1;
3078
    }else{
3079
        if(s->pict_type==P_TYPE)
3080
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3081
    }
3082

    
3083
    return 0;        
3084
}
3085

    
3086
/**
3087
 * decode partition C of one MB.
3088
 * @return <0 if an error occured
3089
 */
3090
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3091
{
3092
    int cbp, mb_type;
3093
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3094

    
3095
    mb_type= s->current_picture.mb_type[xy];
3096
    cbp = s->cbp_table[xy];
3097

    
3098
    if(s->current_picture.qscale_table[xy] != s->qscale){
3099
        s->qscale= s->current_picture.qscale_table[xy];
3100
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3101
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3102
    }
3103
    
3104
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3105
        int i;
3106
        for(i=0; i<4; i++){
3107
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3108
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3109
        }
3110
        s->mb_intra = IS_INTRA(mb_type);
3111

    
3112
        if (IS_SKIP(mb_type)) {
3113
            /* skip mb */
3114
            for(i=0;i<6;i++)
3115
                s->block_last_index[i] = -1;
3116
            s->mv_dir = MV_DIR_FORWARD;
3117
            s->mv_type = MV_TYPE_16X16;
3118
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3119
                s->mcsel=1;
3120
                s->mb_skiped = 0;
3121
            }else{
3122
                s->mcsel=0;
3123
                s->mb_skiped = 1;
3124
            }
3125
        }else if(s->mb_intra){
3126
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3127
        }else if(!s->mb_intra){
3128
//            s->mcsel= 0; //FIXME do we need to init that
3129
            
3130
            s->mv_dir = MV_DIR_FORWARD;
3131
            if (IS_8X8(mb_type)) {
3132
                s->mv_type = MV_TYPE_8X8;
3133
            } else {
3134
                s->mv_type = MV_TYPE_16X16;
3135
            }
3136
        }
3137
    } else { /* I-Frame */
3138
        s->mb_intra = 1;
3139
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3140
    }
3141

    
3142
    if (!IS_SKIP(mb_type)) {
3143
        int i;
3144
        /* decode each block */
3145
        for (i = 0; i < 6; i++) {
3146
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3147
                fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3148
                return -1;
3149
            }
3150
            cbp+=cbp;
3151
        }
3152
    }
3153

    
3154
    /* per-MB end of slice check */
3155

    
3156
    if(--s->mb_num_left <= 0){
3157
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3158
        if(mpeg4_is_resync(s))
3159
            return SLICE_END;
3160
        else
3161
            return SLICE_NOEND;     
3162
    }else{
3163
        if(mpeg4_is_resync(s)){
3164
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3165
            if(s->cbp_table[xy+delta])
3166
                return SLICE_END;
3167
        }
3168
        return SLICE_OK;
3169
    }
3170
}
3171

    
3172
int ff_h263_decode_mb(MpegEncContext *s,
3173
                      DCTELEM block[6][64])
3174
{
3175
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3176
    int16_t *mot_val;
3177
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3178
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3179

    
3180
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3181
        if (get_bits1(&s->gb)) {
3182
            /* skip mb */
3183
            s->mb_intra = 0;
3184
            for(i=0;i<6;i++)
3185
                s->block_last_index[i] = -1;
3186
            s->mv_dir = MV_DIR_FORWARD;
3187
            s->mv_type = MV_TYPE_16X16;
3188
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3189
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3190
                s->mcsel=1;
3191
                s->mv[0][0][0]= get_amv(s, 0);
3192
                s->mv[0][0][1]= get_amv(s, 1);
3193

    
3194
                s->mb_skiped = 0;
3195
            }else{
3196
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3197
                s->mcsel=0;
3198
                s->mv[0][0][0] = 0;
3199
                s->mv[0][0][1] = 0;
3200
                s->mb_skiped = 1;
3201
            }
3202
            goto end;
3203
        }
3204
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3205
        //fprintf(stderr, "\tCBPC: %d", cbpc);
3206
        if (cbpc < 0)
3207
            return -1;
3208
        if (cbpc > 20)
3209
            cbpc+=3;
3210
        else if (cbpc == 20)
3211
            fprintf(stderr, "Stuffing !");
3212
        
3213
        dquant = cbpc & 8;
3214
        s->mb_intra = ((cbpc & 4) != 0);
3215
        if (s->mb_intra) goto intra;
3216
        
3217
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3218
            s->mcsel= get_bits1(&s->gb);
3219
        else s->mcsel= 0;
3220
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3221
        cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
3222
        if (dquant) {
3223
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3224
        }
3225
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
3226
            s->interlaced_dct= get_bits1(&s->gb);
3227
        
3228
        s->mv_dir = MV_DIR_FORWARD;
3229
        if ((cbpc & 16) == 0) {
3230
            if(s->mcsel){
3231
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3232
                /* 16x16 global motion prediction */
3233
                s->mv_type = MV_TYPE_16X16;
3234
                mx= get_amv(s, 0);
3235
                my= get_amv(s, 1);
3236
                s->mv[0][0][0] = mx;
3237
                s->mv[0][0][1] = my;
3238
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3239
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; 
3240
                /* 16x8 field motion prediction */
3241
                s->mv_type= MV_TYPE_FIELD;
3242

    
3243
                s->field_select[0][0]= get_bits1(&s->gb);
3244
                s->field_select[0][1]= get_bits1(&s->gb);
3245

    
3246
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3247
                
3248
                for(i=0; i<2; i++){
3249
                    mx = h263_decode_motion(s, pred_x, s->f_code);
3250
                    if (mx >= 0xffff)
3251
                        return -1;
3252
            
3253
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
3254
                    if (my >= 0xffff)
3255
                        return -1;
3256

    
3257
                    s->mv[0][i][0] = mx;
3258
                    s->mv[0][i][1] = my;
3259
                }
3260
            }else{
3261
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
3262
                /* 16x16 motion prediction */
3263
                s->mv_type = MV_TYPE_16X16;
3264
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3265
                if (s->umvplus)
3266
                   mx = h263p_decode_umotion(s, pred_x);
3267
                else
3268
                   mx = h263_decode_motion(s, pred_x, s->f_code);
3269
            
3270
                if (mx >= 0xffff)
3271
                    return -1;
3272
            
3273
                if (s->umvplus)
3274
                   my = h263p_decode_umotion(s, pred_y);
3275
                else
3276
                   my = h263_decode_motion(s, pred_y, s->f_code);
3277
            
3278
                if (my >= 0xffff)
3279
                    return -1;
3280
                s->mv[0][0][0] = mx;
3281
                s->mv[0][0][1] = my;
3282

    
3283
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3284
                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3285
            }
3286
        } else {
3287
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3288
            s->mv_type = MV_TYPE_8X8;
3289
            for(i=0;i<4;i++) {
3290
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3291
                if (s->umvplus)
3292
                  mx = h263p_decode_umotion(s, pred_x);
3293
                else
3294
                  mx = h263_decode_motion(s, pred_x, s->f_code);
3295
                if (mx >= 0xffff)
3296
                    return -1;
3297
                
3298
                if (s->umvplus)
3299
                  my = h263p_decode_umotion(s, pred_y);
3300
                else    
3301
                  my = h263_decode_motion(s, pred_y, s->f_code);
3302
                if (my >= 0xffff)
3303
                    return -1;
3304
                s->mv[0][i][0] = mx;
3305
                s->mv[0][i][1] = my;
3306
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3307
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3308
                mot_val[0] = mx;
3309
                mot_val[1] = my;
3310
            }
3311
        }
3312
    } else if(s->pict_type==B_TYPE) {
3313
        int modb1; // first bit of modb
3314
        int modb2; // second bit of modb
3315
        int mb_type;
3316

    
3317
        s->mb_intra = 0; //B-frames never contain intra blocks
3318
        s->mcsel=0;      //     ...               true gmc blocks
3319

    
3320
        if(s->mb_x==0){
3321
            for(i=0; i<2; i++){
3322
                s->last_mv[i][0][0]= 
3323
                s->last_mv[i][0][1]= 
3324
                s->last_mv[i][1][0]= 
3325
                s->last_mv[i][1][1]= 0;
3326
            }
3327
        }
3328

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

    
3332
        if(s->mb_skiped){
3333
                /* skip mb */
3334
            for(i=0;i<6;i++)
3335
                s->block_last_index[i] = -1;
3336

    
3337
            s->mv_dir = MV_DIR_FORWARD;
3338
            s->mv_type = MV_TYPE_16X16;
3339
            s->mv[0][0][0] = 0;
3340
            s->mv[0][0][1] = 0;
3341
            s->mv[1][0][0] = 0;
3342
            s->mv[1][0][1] = 0;
3343
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 
3344
            goto end;
3345
        }
3346

    
3347
        modb1= get_bits1(&s->gb); 
3348
        if(modb1){
3349
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
3350
            cbp=0;
3351
        }else{
3352
            modb2= get_bits1(&s->gb);
3353
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3354
            if(mb_type<0){
3355
                printf("illegal MB_type\n");
3356
                return -1;
3357
            }
3358
            mb_type= mb_type_b_map[ mb_type ];
3359
            if(modb2) cbp= 0;
3360
            else      cbp= get_bits(&s->gb, 6);
3361

    
3362
            if ((!IS_DIRECT(mb_type)) && cbp) {
3363
                if(get_bits1(&s->gb)){
3364
                    change_qscale(s, get_bits1(&s->gb)*4 - 2);
3365
                }
3366
            }
3367

    
3368
            if(!s->progressive_sequence){
3369
                if(cbp)
3370
                    s->interlaced_dct= get_bits1(&s->gb);
3371

    
3372
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
3373
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
3374
                    mb_type &= ~MB_TYPE_16x16;
3375

    
3376
                    if(USES_LIST(mb_type, 0)){
3377
                        s->field_select[0][0]= get_bits1(&s->gb);
3378
                        s->field_select[0][1]= get_bits1(&s->gb);
3379
                    }
3380
                    if(USES_LIST(mb_type, 1)){
3381
                        s->field_select[1][0]= get_bits1(&s->gb);
3382
                        s->field_select[1][1]= get_bits1(&s->gb);
3383
                    }
3384
                }
3385
            }
3386

    
3387
            s->mv_dir = 0;
3388
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
3389
                s->mv_type= MV_TYPE_16X16;
3390

    
3391
                if(USES_LIST(mb_type, 0)){
3392
                    s->mv_dir = MV_DIR_FORWARD;
3393

    
3394
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3395
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3396
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3397
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3398
                }
3399
    
3400
                if(USES_LIST(mb_type, 1)){
3401
                    s->mv_dir |= MV_DIR_BACKWARD;
3402

    
3403
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3404
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3405
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3406
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3407
                }
3408
            }else if(!IS_DIRECT(mb_type)){
3409
                s->mv_type= MV_TYPE_FIELD;
3410

    
3411
                if(USES_LIST(mb_type, 0)){
3412
                    s->mv_dir = MV_DIR_FORWARD;
3413
                
3414
                    for(i=0; i<2; i++){
3415
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3416
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3417
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3418
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3419
                    }
3420
                }
3421
    
3422
                if(USES_LIST(mb_type, 1)){
3423
                    s->mv_dir |= MV_DIR_BACKWARD;
3424

    
3425
                    for(i=0; i<2; i++){
3426
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
3427
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3428
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
3429
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3430
                    }
3431
                }
3432
            }
3433
        }
3434
          
3435
        if(IS_DIRECT(mb_type)){
3436
            if(IS_SKIP(mb_type))
3437
                mx=my=0;
3438
            else{
3439
                mx = h263_decode_motion(s, 0, 1);
3440
                my = h263_decode_motion(s, 0, 1);
3441
            }
3442
 
3443
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3444
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
3445
        }
3446
        s->current_picture.mb_type[xy]= mb_type;
3447
    } else { /* I-Frame */
3448
        cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
3449
        if (cbpc < 0)
3450
            return -1;
3451
        dquant = cbpc & 4;
3452
        s->mb_intra = 1;
3453
intra:
3454
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3455
        if (s->h263_pred || s->h263_aic) {
3456
            s->ac_pred = get_bits1(&s->gb);
3457
            if(s->ac_pred){
3458
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3459
            
3460
                if (s->h263_aic)
3461
                    s->h263_aic_dir = get_bits1(&s->gb);
3462
            }
3463
        }else
3464
            s->ac_pred = 0;
3465
        
3466
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3467
        if(cbpy<0) return -1;
3468
        cbp = (cbpc & 3) | (cbpy << 2);
3469
        if (dquant) {
3470
            change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3471
        }
3472
        
3473
        if(!s->progressive_sequence)
3474
            s->interlaced_dct= get_bits1(&s->gb);
3475

    
3476
        /* decode each block */
3477
        if (s->h263_pred) {
3478
            for (i = 0; i < 6; i++) {
3479
                if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
3480
                    return -1;
3481
                cbp+=cbp;
3482
            }
3483
        } else {
3484
            for (i = 0; i < 6; i++) {
3485
                if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3486
                    return -1;
3487
                cbp+=cbp;
3488
            }
3489
        }
3490
        goto end;
3491
    }
3492

    
3493
    /* decode each block */
3494
    if (s->h263_pred) {
3495
        for (i = 0; i < 6; i++) {
3496
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
3497
                return -1;
3498
            cbp+=cbp;
3499
        }
3500
    } else {
3501
        for (i = 0; i < 6; i++) {
3502
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3503
                return -1;
3504
            cbp+=cbp;
3505
        }
3506
    }
3507
end:
3508

    
3509
        /* per-MB end of slice check */
3510
    if(s->codec_id==CODEC_ID_MPEG4){
3511
        if(mpeg4_is_resync(s)){
3512
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3513
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
3514
                return SLICE_OK;
3515
            return SLICE_END;
3516
        }
3517
    }else{
3518
        int v= show_bits(&s->gb, 16);
3519
    
3520
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3521
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3522
        }
3523

    
3524
        if(v==0)
3525
            return SLICE_END;
3526
    }
3527

    
3528
    return SLICE_OK;     
3529
}
3530

    
3531
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3532
{
3533
    int code, val, sign, shift, l;
3534
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3535

    
3536
    if (code == 0)
3537
        return pred;
3538
    if (code < 0)
3539
        return 0xffff;
3540

    
3541
    sign = get_bits1(&s->gb);
3542
    shift = f_code - 1;
3543
    val = code;
3544
    if (shift) {
3545
        val = (val - 1) << shift;
3546
        val |= get_bits(&s->gb, shift);
3547
        val++;
3548
    }
3549
    if (sign)
3550
        val = -val;
3551
    val += pred;
3552

    
3553
    /* modulo decoding */
3554
    if (!s->h263_long_vectors) {
3555
        l = 1 << (f_code + 4);
3556
        val = ((val + l)&(l*2-1)) - l;
3557
    } else {
3558
        /* horrible h263 long vector mode */
3559
        if (pred < -31 && val < -63)
3560
            val += 64;
3561
        if (pred > 32 && val > 63)
3562
            val -= 64;
3563
        
3564
    }
3565
    return val;
3566
}
3567

    
3568
/* Decodes RVLC of H.263+ UMV */
3569
static int h263p_decode_umotion(MpegEncContext * s, int pred)
3570
{
3571
   int code = 0, sign;
3572
   
3573
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
3574
      return pred;
3575
   
3576
   code = 2 + get_bits1(&s->gb);
3577
   
3578
   while (get_bits1(&s->gb))
3579
   {
3580
      code <<= 1;
3581
      code += get_bits1(&s->gb);
3582
   }
3583
   sign = code & 1;
3584
   code >>= 1;
3585
   
3586
   code = (sign) ? (pred - code) : (pred + code);
3587
#ifdef DEBUG
3588
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3589
#endif
3590
   return code;   
3591

    
3592
}
3593

    
3594
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3595
                             int n, int coded)
3596
{
3597
    int code, level, i, j, last, run;
3598
    RLTable *rl = &rl_inter;
3599
    const uint8_t *scan_table;
3600

    
3601
    scan_table = s->intra_scantable.permutated;
3602
    if (s->h263_aic && s->mb_intra) {
3603
        rl = &rl_intra_aic;
3604
        i = 0;
3605
        if (s->ac_pred) {
3606
            if (s->h263_aic_dir) 
3607
                scan_table = s->intra_v_scantable.permutated; /* left */
3608
            else
3609
                scan_table = s->intra_h_scantable.permutated; /* top */
3610
        }
3611
    } else if (s->mb_intra) {
3612
        /* DC coef */
3613
        if(s->h263_rv10){
3614
          if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
3615
            int component, diff;
3616
            component = (n <= 3 ? 0 : n - 4 + 1);
3617
            level = s->last_dc[component];
3618
            if (s->rv10_first_dc_coded[component]) {
3619
                diff = rv_decode_dc(s, n);
3620
                if (diff == 0xffff)
3621
                    return -1;
3622
                level += diff;
3623
                level = level & 0xff; /* handle wrap round */
3624
                s->last_dc[component] = level;
3625
            } else {
3626
                s->rv10_first_dc_coded[component] = 1;
3627
            }
3628
          } else {
3629
                level = get_bits(&s->gb, 8);
3630
          }
3631
        }else{
3632
            level = get_bits(&s->gb, 8);
3633
            if((level&0x7F) == 0){
3634
                fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
3635
                return -1;
3636
            }
3637
            if (level == 255)
3638
                level = 128;
3639
        }
3640
        block[0] = level;
3641
        i = 1;
3642
    } else {
3643
        i = 0;
3644
    }
3645
    if (!coded) {
3646
        if (s->mb_intra && s->h263_aic)
3647
            goto not_coded;
3648
        s->block_last_index[n] = i - 1;
3649
        return 0;
3650
    }
3651

    
3652
    for(;;) {
3653
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3654
        if (code < 0){
3655
            fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3656
            return -1;
3657
        }
3658
        if (code == rl->n) {
3659
            /* escape */
3660
            if (s->h263_flv > 1) {
3661
                int is11 = get_bits1(&s->gb);
3662
                last = get_bits1(&s->gb);
3663
                run = get_bits(&s->gb, 6);
3664
                if(is11){
3665
                    level = get_sbits(&s->gb, 11);
3666
                } else {
3667
                    level = get_sbits(&s->gb, 7);
3668
                }
3669
            } else {
3670
                last = get_bits1(&s->gb);
3671
                run = get_bits(&s->gb, 6);
3672
                level = (int8_t)get_bits(&s->gb, 8);
3673
                if(level == -128){
3674
                    if (s->h263_rv10) {
3675
                        /* XXX: should patch encoder too */
3676
                        level = get_sbits(&s->gb, 12);
3677
                    }else{
3678
                        level = get_bits(&s->gb, 5);
3679
                        level |= get_sbits(&s->gb, 6)<<5;
3680
                    }
3681
                }
3682
            }
3683
        } else {
3684
            run = rl->table_run[code];
3685
            level = rl->table_level[code];
3686
            last = code >= rl->last;
3687
            if (get_bits1(&s->gb))
3688
                level = -level;
3689
        }
3690
        i += run;
3691
        if (i >= 64){
3692
            fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3693
            return -1;
3694
        }
3695
        j = scan_table[i];
3696
        block[j] = level;
3697
        if (last)
3698
            break;
3699
        i++;
3700
    }
3701
not_coded:    
3702
    if (s->mb_intra && s->h263_aic) {
3703
        h263_pred_acdc(s, block, n);
3704
        i = 63;
3705
    }
3706
    s->block_last_index[n] = i;
3707
    return 0;
3708
}
3709

    
3710
/**
3711
 * decodes the dc value.
3712
 * @param n block index (0-3 are luma, 4-5 are chroma)
3713
 * @param dir_ptr the prediction direction will be stored here
3714
 * @return the quantized dc
3715
 */
3716
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3717
{
3718
    int level, pred, code;
3719
    uint16_t *dc_val;
3720

    
3721
    if (n < 4) 
3722
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3723
    else 
3724
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3725
    if (code < 0 || code > 9 /* && s->nbit<9 */){
3726
        fprintf(stderr, "illegal dc vlc\n");
3727
        return -1;
3728
    }
3729
    if (code == 0) {
3730
        level = 0;
3731
    } else {
3732
        if(IS_3IV1){
3733
            if(code==1)
3734
                level= 2*get_bits1(&s->gb)-1;
3735
            else{
3736
                if(get_bits1(&s->gb))
3737
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
3738
                else
3739
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
3740
            }
3741
        }else{
3742
            level = get_xbits(&s->gb, code);
3743
        }
3744

    
3745
        if (code > 8){
3746
            if(get_bits1(&s->gb)==0){ /* marker */
3747
                if(s->error_resilience>=2){
3748
                    fprintf(stderr, "dc marker bit missing\n");
3749
                    return -1;
3750
                }
3751
            }
3752
        }
3753
    }
3754
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3755
    level += pred;
3756
    if (level < 0){
3757
        if(s->error_resilience>=3){
3758
            fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3759
            return -1;
3760
        }
3761
        level = 0;
3762
    }
3763
    if (n < 4) {
3764
        *dc_val = level * s->y_dc_scale;
3765
    } else {
3766
        *dc_val = level * s->c_dc_scale;
3767
    }
3768
    if(IS_3IV1)
3769
        *dc_val = level * 8;
3770
    
3771
    if(s->error_resilience>=3){
3772
        if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3773
            fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3774
            return -1;
3775
        }
3776
    }
3777
    return level;
3778
}
3779

    
3780
/**
3781
 * decodes a block.
3782
 * @return <0 if an error occured
3783
 */
3784
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3785
                              int n, int coded, int intra, int rvlc)
3786
{
3787
    int level, i, last, run;
3788
    int dc_pred_dir;
3789
    RLTable * rl;
3790
    RL_VLC_ELEM * rl_vlc;
3791
    const uint8_t * scan_table;
3792
    int qmul, qadd;
3793

    
3794
    //Note intra & rvlc should be optimized away if this is inlined
3795
    
3796
    if(intra) {
3797
        /* DC coef */
3798
        if(s->partitioned_frame){
3799
            level = s->dc_val[0][ s->block_index[n] ];
3800
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
3801
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
3802
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
3803
        }else{
3804
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3805
            if (level < 0)
3806
                return -1;
3807
        }
3808
        block[0] = level;
3809
        i = 0;
3810
        if (!coded) 
3811
            goto not_coded;
3812
        
3813
        if(rvlc){        
3814
            rl = &rvlc_rl_intra;
3815
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
3816
        }else{
3817
            rl = &rl_intra;
3818
            rl_vlc = rl_intra.rl_vlc[0];
3819
        }
3820
        if (s->ac_pred) {
3821
            if (dc_pred_dir == 0) 
3822
                scan_table = s->intra_v_scantable.permutated; /* left */
3823
            else
3824
                scan_table = s->intra_h_scantable.permutated; /* top */
3825
        } else {
3826
            scan_table = s->intra_scantable.permutated;
3827
        }
3828
        qmul=1;
3829
        qadd=0;
3830
    } else {
3831
        i = -1;
3832
        if (!coded) {
3833
            s->block_last_index[n] = i;
3834
            return 0;
3835
        }
3836
        if(rvlc) rl = &rvlc_rl_inter;
3837
        else     rl = &rl_inter;
3838
   
3839
        scan_table = s->intra_scantable.permutated;
3840

    
3841
        if(s->mpeg_quant){
3842
            qmul=1;
3843
            qadd=0;
3844
            if(rvlc){        
3845
                rl_vlc = rvlc_rl_inter.rl_vlc[0];        
3846
            }else{
3847
                rl_vlc = rl_inter.rl_vlc[0];        
3848
            }
3849
        }else{
3850
            qmul = s->qscale << 1;
3851
            qadd = (s->qscale - 1) | 1;
3852
            if(rvlc){        
3853
                rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];        
3854
            }else{
3855
                rl_vlc = rl_inter.rl_vlc[s->qscale];        
3856
            }
3857
        }
3858
    }
3859
  {
3860
    OPEN_READER(re, &s->gb);
3861
    for(;;) {
3862
        UPDATE_CACHE(re, &s->gb);
3863
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3864
        if (level==0) {
3865
          /* escape */                
3866
          if(rvlc){
3867
                if(SHOW_UBITS(re, &s->gb, 1)==0){
3868
                    fprintf(stderr, "1. marker bit missing in rvlc esc\n");
3869
                    return -1;
3870
                }; SKIP_CACHE(re, &s->gb, 1);
3871
 
3872
                last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3873
                run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3874
                SKIP_COUNTER(re, &s->gb, 1+1+6);
3875
                UPDATE_CACHE(re, &s->gb);
3876
              
3877
                if(SHOW_UBITS(re, &s->gb, 1)==0){
3878
                    fprintf(stderr, "2. marker bit missing in rvlc esc\n");
3879
                    return -1;
3880
                }; SKIP_CACHE(re, &s->gb, 1);
3881
 
3882
                level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
3883
 
3884
                if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
3885
                    fprintf(stderr, "reverse esc missing\n");
3886
                    return -1;
3887
                }; SKIP_CACHE(re, &s->gb, 5);
3888

    
3889
                level=  level * qmul + qadd;
3890
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
3891
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
3892

    
3893
                i+= run + 1;
3894
                if(last) i+=192;
3895
          }else{
3896
            int cache;
3897
            cache= GET_CACHE(re, &s->gb);
3898

    
3899
            if(IS_3IV1) 
3900
                cache ^= 0xC0000000;
3901

    
3902
            if (cache&0x80000000) {
3903
                if (cache&0x40000000) {
3904
                    /* third escape */
3905
                    SKIP_CACHE(re, &s->gb, 2);
3906
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3907
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3908
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
3909
                    UPDATE_CACHE(re, &s->gb);
3910

    
3911
                    if(IS_3IV1){
3912
                        level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
3913
                    }else{
3914
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
3915
                            fprintf(stderr, "1. marker bit missing in 3. esc\n");
3916
                            return -1;
3917
                        }; SKIP_CACHE(re, &s->gb, 1);
3918

    
3919
                        level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3920

    
3921
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
3922
                            fprintf(stderr, "2. marker bit missing in 3. esc\n");
3923
                            return -1;
3924
                        }; LAST_SKIP_CACHE(re, &s->gb, 1);
3925

    
3926
                        SKIP_COUNTER(re, &s->gb, 1+12+1);
3927
                    }
3928
 
3929
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
3930
                        fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3931
                        return -1;
3932
                    }
3933
#if 1 
3934
                    {
3935
                        const int abs_level= ABS(level);
3936
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
3937
                            const int run1= run - rl->max_run[last][abs_level] - 1;
3938
                            if(abs_level <= rl->max_level[last][run]){
3939
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3940
                                return -1;
3941
                            }
3942
                            if(s->error_resilience > FF_ER_COMPLIANT){
3943
                                if(abs_level <= rl->max_level[last][run]*2){
3944
                                    fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3945
                                    return -1;
3946
                                }
3947
                                if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3948
                                    fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3949
                                    return -1;
3950
                                }
3951
                            }
3952
                        }
3953
                    }
3954
#endif
3955
                    if (level>0) level= level * qmul + qadd;
3956
                    else         level= level * qmul - qadd;
3957

    
3958
                    i+= run + 1;
3959
                    if(last) i+=192;
3960
                } else {
3961
                    /* second escape */
3962
#if MIN_CACHE_BITS < 20
3963
                    LAST_SKIP_BITS(re, &s->gb, 2);
3964
                    UPDATE_CACHE(re, &s->gb);
3965
#else
3966
                    SKIP_BITS(re, &s->gb, 2);
3967
#endif
3968
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3969
                    i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3970
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3971
                    LAST_SKIP_BITS(re, &s->gb, 1);
3972
                }
3973
            } else {
3974
                /* first escape */
3975
#if MIN_CACHE_BITS < 19
3976
                LAST_SKIP_BITS(re, &s->gb, 1);
3977
                UPDATE_CACHE(re, &s->gb);
3978
#else
3979
                SKIP_BITS(re, &s->gb, 1);
3980
#endif
3981
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3982
                i+= run;
3983
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3984
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3985
                LAST_SKIP_BITS(re, &s->gb, 1);
3986
            }
3987
          }
3988
        } else {
3989
            i+= run;
3990
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3991
            LAST_SKIP_BITS(re, &s->gb, 1);
3992
        }
3993
        if (i > 62){
3994
            i-= 192;
3995
            if(i&(~63)){
3996
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3997
                return -1;
3998
            }
3999

    
4000
            block[scan_table[i]] = level;
4001
            break;
4002
        }
4003

    
4004
        block[scan_table[i]] = level;
4005
    }
4006
    CLOSE_READER(re, &s->gb);
4007
  }
4008
 not_coded:
4009
    if (s->mb_intra) {
4010
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
4011
        if (s->ac_pred) {
4012
            i = 63; /* XXX: not optimal */
4013
        }
4014
    }
4015
    s->block_last_index[n] = i;
4016
    return 0;
4017
}
4018

    
4019
/* most is hardcoded. should extend to handle all h263 streams */
4020
int h263_decode_picture_header(MpegEncContext *s)
4021
{
4022
    int format, width, height, i;
4023
    uint32_t startcode;
4024
    
4025
    align_get_bits(&s->gb);
4026

    
4027
    startcode= get_bits(&s->gb, 22-8);
4028

    
4029
    for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>0; i--) {
4030
        startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4031
        
4032
        if(startcode == 0x20)
4033
            break;
4034
    }
4035
        
4036
    if (startcode != 0x20) {
4037
        fprintf(stderr, "Bad picture start code\n");
4038
        return -1;
4039
    }
4040
    /* temporal reference */
4041
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4042

    
4043
    /* PTYPE starts here */    
4044
    if (get_bits1(&s->gb) != 1) {
4045
        /* marker */
4046
        fprintf(stderr, "Bad marker\n");
4047
        return -1;
4048
    }
4049
    if (get_bits1(&s->gb) != 0) {
4050
        fprintf(stderr, "Bad H263 id\n");
4051
        return -1;        /* h263 id */
4052
    }
4053
    skip_bits1(&s->gb);        /* split screen off */
4054
    skip_bits1(&s->gb);        /* camera  off */
4055
    skip_bits1(&s->gb);        /* freeze picture release off */
4056

    
4057
    /* Reset GOB number */
4058
    s->gob_number = 0;
4059
        
4060
    format = get_bits(&s->gb, 3);
4061
    /*
4062
        0    forbidden
4063
        1    sub-QCIF
4064
        10   QCIF
4065
        7        extended PTYPE (PLUSPTYPE)
4066
    */
4067

    
4068
    if (format != 7 && format != 6) {
4069
        s->h263_plus = 0;
4070
        /* H.263v1 */
4071
        width = h263_format[format][0];
4072
        height = h263_format[format][1];
4073
        if (!width)
4074
            return -1;
4075
        
4076
        s->width = width;
4077
        s->height = height;
4078
        s->pict_type = I_TYPE + get_bits1(&s->gb);
4079

    
4080
        s->unrestricted_mv = get_bits1(&s->gb); 
4081
        s->h263_long_vectors = s->unrestricted_mv;
4082

    
4083
        if (get_bits1(&s->gb) != 0) {
4084
            fprintf(stderr, "H263 SAC not supported\n");
4085
            return -1;        /* SAC: off */
4086
        }
4087
        if (get_bits1(&s->gb) != 0) {
4088
            s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
4089
        }   
4090
        
4091
        if (get_bits1(&s->gb) != 0) {
4092
            fprintf(stderr, "H263 PB frame not supported\n");
4093
            return -1;        /* not PB frame */
4094
        }
4095
        s->qscale = get_bits(&s->gb, 5);
4096
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
4097
    } else {
4098
        int ufep;
4099
        
4100
        /* H.263v2 */
4101
        s->h263_plus = 1;
4102
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
4103

    
4104
        /* ufep other than 0 and 1 are reserved */        
4105
        if (ufep == 1) {
4106
            /* OPPTYPE */       
4107
            format = get_bits(&s->gb, 3);
4108
            dprintf("ufep=1, format: %d\n", format);
4109
            skip_bits(&s->gb,1); /* Custom PCF */
4110
            s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
4111
            skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
4112
            if (get_bits1(&s->gb) != 0) {
4113
                s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
4114
            }
4115
            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
4116
                s->h263_aic = 1;
4117
            }
4118
            
4119
            if (get_bits1(&s->gb) != 0) {
4120
                fprintf(stderr, "Deblocking Filter not supported\n");
4121
            }
4122
            if (get_bits1(&s->gb) != 0) {
4123
                fprintf(stderr, "Slice Structured not supported\n");
4124
            }
4125
            if (get_bits1(&s->gb) != 0) {
4126
                fprintf(stderr, "Reference Picture Selection not supported\n");
4127
            }
4128
            if (get_bits1(&s->gb) != 0) {
4129
                fprintf(stderr, "Independent Segment Decoding not supported\n");
4130
            }
4131
            if (get_bits1(&s->gb) != 0) {
4132
                fprintf(stderr, "Alternative Inter VLC not supported\n");
4133
            }
4134
            if (get_bits1(&s->gb) != 0) {
4135
                fprintf(stderr, "Modified Quantization not supported\n");
4136
            }
4137
            
4138
            skip_bits(&s->gb, 1); /* Prevent start code emulation */
4139

    
4140
            skip_bits(&s->gb, 3); /* Reserved */
4141
        } else if (ufep != 0) {
4142
            fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
4143
            return -1;
4144
        }
4145
            
4146
        /* MPPTYPE */
4147
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
4148
        dprintf("pict_type: %d\n", s->pict_type);
4149
        if (s->pict_type != I_TYPE &&
4150
            s->pict_type != P_TYPE)
4151
            return -1;
4152
        skip_bits(&s->gb, 2);
4153
        s->no_rounding = get_bits1(&s->gb);
4154
        dprintf("RTYPE: %d\n", s->no_rounding);
4155
        skip_bits(&s->gb, 4);
4156
        
4157
        /* Get the picture dimensions */
4158
        if (ufep) {
4159
            if (format == 6) {
4160
                /* Custom Picture Format (CPFMT) */
4161
                s->aspect_ratio_info = get_bits(&s->gb, 4);
4162
                dprintf("aspect: %d\n", s->aspect_ratio_info);
4163
                /* aspect ratios:
4164
                0 - forbidden
4165
                1 - 1:1
4166
                2 - 12:11 (CIF 4:3)
4167
                3 - 10:11 (525-type 4:3)
4168
                4 - 16:11 (CIF 16:9)
4169
                5 - 40:33 (525-type 16:9)
4170
                6-14 - reserved
4171
                */
4172
                width = (get_bits(&s->gb, 9) + 1) * 4;
4173
                skip_bits1(&s->gb);
4174
                height = get_bits(&s->gb, 9) * 4;
4175
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
4176
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
4177
                    /* aspected dimensions */
4178
                    s->aspected_width = get_bits(&s->gb, 8);
4179
                    s->aspected_height = get_bits(&s->gb, 8);
4180
                }else{
4181
                    s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4182
                    s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4183
                }
4184
            } else {
4185
                width = h263_format[format][0];
4186
                height = h263_format[format][1];
4187
            }
4188
            if ((width == 0) || (height == 0))
4189
                return -1;
4190
            s->width = width;
4191
            s->height = height;
4192
            if (s->umvplus) {
4193
                if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4194
                    skip_bits1(&s->gb); 
4195
            }
4196
        }
4197
            
4198
        s->qscale = get_bits(&s->gb, 5);
4199
    }
4200
    /* PEI */
4201
    while (get_bits1(&s->gb) != 0) {
4202
        skip_bits(&s->gb, 8);
4203
    }
4204
    s->f_code = 1;
4205
    
4206
    if(s->h263_aic){
4207
         s->y_dc_scale_table= 
4208
         s->c_dc_scale_table= h263_aic_dc_scale_table;
4209
    }else{
4210
        s->y_dc_scale_table=
4211
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4212
    }
4213

    
4214
     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4215
         printf("qp:%d %c size:%d rnd:%d %s %s %s %s\n", 
4216
         s->qscale, av_get_pict_type_char(s->pict_type),
4217
         s->gb.size_in_bits, 1-s->no_rounding,
4218
         s->mv_type == MV_TYPE_8X8 ? "ADV" : "",
4219
         s->umvplus ? "UMV" : "",
4220
         s->h263_long_vectors ? "LONG" : "",
4221
         s->h263_plus ? "+" : ""
4222
         ); 
4223
     }
4224

    
4225
    
4226
    return 0;
4227
}
4228

    
4229
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4230
{
4231
    int i;
4232
    int a= 2<<s->sprite_warping_accuracy;
4233
    int rho= 3-s->sprite_warping_accuracy;
4234
    int r=16/a;
4235
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4236
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4237
    int sprite_ref[4][2];
4238
    int virtual_ref[2][2];
4239
    int w2, h2, w3, h3;
4240
    int alpha=0, beta=0;
4241
    int w= s->width;
4242
    int h= s->height;
4243
    int min_ab;
4244

    
4245
    for(i=0; i<s->num_sprite_warping_points; i++){
4246
        int length;
4247
        int x=0, y=0;
4248

    
4249
        length= get_vlc(&s->gb, &sprite_trajectory);
4250
        if(length){
4251
            x= get_xbits(&s->gb, length);
4252
        }
4253
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4254
        
4255
        length= get_vlc(&s->gb, &sprite_trajectory);
4256
        if(length){
4257
            y=get_xbits(&s->gb, length);
4258
        }
4259
        skip_bits1(&s->gb); /* marker bit */
4260
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4261
        d[i][0]= x;
4262
        d[i][1]= y;
4263
    }
4264

    
4265
    while((1<<alpha)<w) alpha++;
4266
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4267
    w2= 1<<alpha;
4268
    h2= 1<<beta;
4269

    
4270
// Note, the 4th point isnt used for GMC
4271
    if(s->divx_version==500 && s->divx_build==413){
4272
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
4273
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
4274
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
4275
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
4276
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
4277
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
4278
    } else {
4279
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
4280
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
4281
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
4282
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
4283
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
4284
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
4285
    }
4286
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
4287
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
4288
    
4289
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
4290
// perhaps it should be reordered to be more readable ...
4291
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
4292
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
4293
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
4294
        + 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);
4295
    virtual_ref[0][1]= 16*vop_ref[0][1] 
4296
        + 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);
4297
    virtual_ref[1][0]= 16*vop_ref[0][0] 
4298
        + 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);
4299
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
4300
        + 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);
4301
        
4302
    switch(s->num_sprite_warping_points)
4303
    {
4304
        case 0:
4305
            s->sprite_offset[0][0]= 0;
4306
            s->sprite_offset[0][1]= 0;
4307
            s->sprite_offset[1][0]= 0;
4308
            s->sprite_offset[1][1]= 0;
4309
            s->sprite_delta[0][0]= a;
4310
            s->sprite_delta[0][1]= 0;
4311
            s->sprite_delta[1][0]= 0;
4312
            s->sprite_delta[1][1]= a;
4313
            s->sprite_shift[0]= 0;
4314
            s->sprite_shift[1]= 0;
4315
            break;
4316
        case 1: //GMC only
4317
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
4318
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
4319
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
4320
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
4321
            s->sprite_delta[0][0]= a;
4322
            s->sprite_delta[0][1]= 0;
4323
            s->sprite_delta[1][0]= 0;
4324
            s->sprite_delta[1][1]= a;
4325
            s->sprite_shift[0]= 0;
4326
            s->sprite_shift[1]= 0;
4327
            break;
4328
        case 2:
4329
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
4330
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
4331
                                                  + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
4332
                                                  + (1<<(alpha+rho-1));
4333
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
4334
                                                  + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
4335
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
4336
                                                  + (1<<(alpha+rho-1));
4337
            s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4338
                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4339
                                     +2*w2*r*sprite_ref[0][0] 
4340
                                     - 16*w2 
4341
                                     + (1<<(alpha+rho+1)));
4342
            s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
4343
                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4344
                                     +2*w2*r*sprite_ref[0][1] 
4345
                                     - 16*w2
4346
                                     + (1<<(alpha+rho+1)));
4347
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4348
            s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4349
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4350
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4351
            
4352
            s->sprite_shift[0]= alpha+rho;
4353
            s->sprite_shift[1]= alpha+rho+2;
4354
            break;
4355
        case 3:
4356
            min_ab= FFMIN(alpha, beta);
4357
            w3= w2>>min_ab;
4358
            h3= h2>>min_ab;
4359
            s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
4360
                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
4361
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
4362
                                   + (1<<(alpha+beta+rho-min_ab-1));
4363
            s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
4364
                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
4365
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
4366
                                   + (1<<(alpha+beta+rho-min_ab-1));
4367
            s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
4368
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
4369
                                   + 2*w2*h3*r*sprite_ref[0][0]
4370
                                   - 16*w2*h3
4371
                                   + (1<<(alpha+beta+rho-min_ab+1));
4372
            s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4373
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4374
                                   + 2*w2*h3*r*sprite_ref[0][1]
4375
                                   - 16*w2*h3
4376
                                   + (1<<(alpha+beta+rho-min_ab+1));
4377
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4378
            s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4379
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4380
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4381
                                   
4382
            s->sprite_shift[0]= alpha + beta + rho - min_ab;
4383
            s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4384
            break;
4385
    }
4386
    /* try to simplify the situation */ 
4387
    if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4388
       && s->sprite_delta[0][1] == 0
4389
       && s->sprite_delta[1][0] == 0
4390
       && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4391
    {
4392
        s->sprite_offset[0][0]>>=s->sprite_shift[0];
4393
        s->sprite_offset[0][1]>>=s->sprite_shift[0];
4394
        s->sprite_offset[1][0]>>=s->sprite_shift[1];
4395
        s->sprite_offset[1][1]>>=s->sprite_shift[1];
4396
        s->sprite_delta[0][0]= a;
4397
        s->sprite_delta[0][1]= 0;
4398
        s->sprite_delta[1][0]= 0;
4399
        s->sprite_delta[1][1]= a;
4400
        s->sprite_shift[0]= 0;
4401
        s->sprite_shift[1]= 0;
4402
        s->real_sprite_warping_points=1;
4403
    }
4404
    else{
4405
        int shift_y= 16 - s->sprite_shift[0];
4406
        int shift_c= 16 - s->sprite_shift[1];
4407
//printf("shifts %d %d\n", shift_y, shift_c);
4408
        for(i=0; i<2; i++){
4409
            s->sprite_offset[0][i]<<= shift_y;
4410
            s->sprite_offset[1][i]<<= shift_c;
4411
            s->sprite_delta[0][i]<<= shift_y;
4412
            s->sprite_delta[1][i]<<= shift_y;
4413
            s->sprite_shift[i]= 16;
4414
        }
4415
        s->real_sprite_warping_points= s->num_sprite_warping_points;
4416
    }
4417
#if 0
4418
printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4419
    vop_ref[0][0], vop_ref[0][1],
4420
    vop_ref[1][0], vop_ref[1][1],
4421
    vop_ref[2][0], vop_ref[2][1],
4422
    sprite_ref[0][0], sprite_ref[0][1], 
4423
    sprite_ref[1][0], sprite_ref[1][1], 
4424
    sprite_ref[2][0], sprite_ref[2][1], 
4425
    virtual_ref[0][0], virtual_ref[0][1], 
4426
    virtual_ref[1][0], virtual_ref[1][1]
4427
    );
4428
    
4429
printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4430
    s->sprite_offset[0][0], s->sprite_offset[0][1],
4431
    s->sprite_delta[0][0], s->sprite_delta[0][1],
4432
    s->sprite_delta[1][0], s->sprite_delta[1][1],
4433
    s->sprite_shift[0]
4434
    );
4435
#endif
4436
}
4437

    
4438
static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
4439
    int hours, minutes, seconds;
4440

    
4441
    hours= get_bits(gb, 5);
4442
    minutes= get_bits(gb, 6);
4443
    skip_bits1(gb);
4444
    seconds= get_bits(gb, 6);
4445

    
4446
    s->time_base= seconds + 60*(minutes + 60*hours);
4447

    
4448
    skip_bits1(gb);
4449
    skip_bits1(gb);
4450
    
4451
    return 0;
4452
}
4453

    
4454
static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4455
    int width, height, vo_ver_id;
4456

    
4457
    /* vol header */
4458
    skip_bits(gb, 1); /* random access */
4459
    s->vo_type= get_bits(gb, 8);
4460
    if (get_bits1(gb) != 0) { /* is_ol_id */
4461
        vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4462
        skip_bits(gb, 3); /* vo_priority */
4463
    } else {
4464
        vo_ver_id = 1;
4465
    }
4466
//printf("vo type:%d\n",s->vo_type);
4467
    s->aspect_ratio_info= get_bits(gb, 4);
4468
    if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){            
4469
        s->aspected_width = get_bits(gb, 8); // par_width
4470
        s->aspected_height = get_bits(gb, 8); // par_height
4471
    }else{
4472
        s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4473
        s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4474
    }
4475

    
4476
    if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4477
        int chroma_format= get_bits(gb, 2);
4478
        if(chroma_format!=1){
4479
            printf("illegal chroma format\n");
4480
        }
4481
        s->low_delay= get_bits1(gb);
4482
        if(get_bits1(gb)){ /* vbv parameters */
4483
            get_bits(gb, 15);        /* first_half_bitrate */
4484
            skip_bits1(gb);        /* marker */
4485
            get_bits(gb, 15);        /* latter_half_bitrate */
4486
            skip_bits1(gb);        /* marker */
4487
            get_bits(gb, 15);        /* first_half_vbv_buffer_size */
4488
            skip_bits1(gb);        /* marker */
4489
            get_bits(gb, 3);        /* latter_half_vbv_buffer_size */
4490
            get_bits(gb, 11);        /* first_half_vbv_occupancy */
4491
            skip_bits1(gb);        /* marker */
4492
            get_bits(gb, 15);        /* latter_half_vbv_occupancy */
4493
            skip_bits1(gb);        /* marker */               
4494
        }
4495
    }else{
4496
        // set low delay flag only once so the smart? low delay detection wont be overriden
4497
        if(s->picture_number==0)
4498
            s->low_delay=0;
4499
    }
4500

    
4501
    s->shape = get_bits(gb, 2); /* vol shape */
4502
    if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4503
    if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4504
        printf("Gray shape not supported\n");
4505
        skip_bits(gb, 4);  //video_object_layer_shape_extension
4506
    }
4507

    
4508
    skip_bits1(gb);   /* marker */
4509
    
4510
    s->time_increment_resolution = get_bits(gb, 16);
4511
    
4512
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4513
    if (s->time_increment_bits < 1)
4514
        s->time_increment_bits = 1;
4515
    skip_bits1(gb);   /* marker */
4516

    
4517
    if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
4518
        skip_bits(gb, s->time_increment_bits);
4519
    }
4520

    
4521
    if (s->shape != BIN_ONLY_SHAPE) {
4522
        if (s->shape == RECT_SHAPE) {
4523
            skip_bits1(gb);   /* marker */
4524
            width = get_bits(gb, 13);
4525
            skip_bits1(gb);   /* marker */
4526
            height = get_bits(gb, 13);
4527
            skip_bits1(gb);   /* marker */
4528
            if(width && height){ /* they should be non zero but who knows ... */
4529
                s->width = width;
4530
                s->height = height;
4531
//                printf("width/height: %d %d\n", width, height);
4532
            }
4533
        }
4534
        
4535
        s->progressive_sequence= get_bits1(gb)^1;
4536
        if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) 
4537
            printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
4538
        if (vo_ver_id == 1) {
4539
            s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4540
        } else {
4541
            s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4542
        }
4543
        if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4544
        if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4545
            if(s->vol_sprite_usage==STATIC_SPRITE){
4546
                s->sprite_width = get_bits(gb, 13);
4547
                skip_bits1(gb); /* marker */
4548
                s->sprite_height= get_bits(gb, 13);
4549
                skip_bits1(gb); /* marker */
4550
                s->sprite_left  = get_bits(gb, 13);
4551
                skip_bits1(gb); /* marker */
4552
                s->sprite_top   = get_bits(gb, 13);
4553
                skip_bits1(gb); /* marker */
4554
            }
4555
            s->num_sprite_warping_points= get_bits(gb, 6);
4556
            s->sprite_warping_accuracy = get_bits(gb, 2);
4557
            s->sprite_brightness_change= get_bits1(gb);
4558
            if(s->vol_sprite_usage==STATIC_SPRITE)
4559
                s->low_latency_sprite= get_bits1(gb);            
4560
        }
4561
        // FIXME sadct disable bit if verid!=1 && shape not rect
4562
        
4563
        if (get_bits1(gb) == 1) {   /* not_8_bit */
4564
            s->quant_precision = get_bits(gb, 4); /* quant_precision */
4565
            if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4566
            if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4567
        } else {
4568
            s->quant_precision = 5;
4569
        }
4570
        
4571
        // FIXME a bunch of grayscale shape things
4572

    
4573
        if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4574
            int i, v;
4575
            
4576
            /* load default matrixes */
4577
            for(i=0; i<64; i++){
4578
                int j= s->dsp.idct_permutation[i];
4579
                v= ff_mpeg4_default_intra_matrix[i];
4580
                s->intra_matrix[j]= v;
4581
                s->chroma_intra_matrix[j]= v;
4582
                
4583
                v= ff_mpeg4_default_non_intra_matrix[i];
4584
                s->inter_matrix[j]= v;
4585
                s->chroma_inter_matrix[j]= v;
4586
            }
4587

    
4588
            /* load custom intra matrix */
4589
            if(get_bits1(gb)){
4590
                int last=0;
4591
                for(i=0; i<64; i++){
4592
                    int j;
4593
                    v= get_bits(gb, 8);
4594
                    if(v==0) break;
4595
                    
4596
                    last= v;
4597
                    j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4598
                    s->intra_matrix[j]= v;
4599
                    s->chroma_intra_matrix[j]= v;
4600
                }
4601

    
4602
                /* replicate last value */
4603
                for(; i<64; i++){
4604
                    int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4605
                    s->intra_matrix[j]= v;
4606
                    s->chroma_intra_matrix[j]= v;
4607
                }
4608
            }
4609

    
4610
            /* load custom non intra matrix */
4611
            if(get_bits1(gb)){
4612
                int last=0;
4613
                for(i=0; i<64; i++){
4614
                    int j;
4615
                    v= get_bits(gb, 8);
4616
                    if(v==0) break;
4617

    
4618
                    last= v;
4619
                    j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4620
                    s->inter_matrix[j]= v;
4621
                    s->chroma_inter_matrix[j]= v;
4622
                }
4623

    
4624
                /* replicate last value */
4625
                for(; i<64; i++){
4626
                    int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4627
                    s->inter_matrix[j]= last;
4628
                    s->chroma_inter_matrix[j]= last;
4629
                }
4630
            }
4631

    
4632
            // FIXME a bunch of grayscale shape things
4633
        }
4634

    
4635
        if(vo_ver_id != 1)
4636
             s->quarter_sample= get_bits1(gb);
4637
        else s->quarter_sample=0;
4638

    
4639
        if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4640

    
4641
        s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4642

    
4643
        s->data_partitioning= get_bits1(gb);
4644
        if(s->data_partitioning){
4645
            s->rvlc= get_bits1(gb);
4646
        }
4647
        
4648
        if(vo_ver_id != 1) {
4649
            s->new_pred= get_bits1(gb);
4650
            if(s->new_pred){
4651
                printf("new pred not supported\n");
4652
                skip_bits(gb, 2); /* requested upstream message type */
4653
                skip_bits1(gb); /* newpred segment type */
4654
            }
4655
            s->reduced_res_vop= get_bits1(gb);
4656
            if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4657
        }
4658
        else{
4659
            s->new_pred=0;
4660
            s->reduced_res_vop= 0;
4661
        }
4662

    
4663
        s->scalability= get_bits1(gb);
4664

    
4665
        if (s->scalability) {
4666
            GetBitContext bak= *gb;
4667
            int ref_layer_id;
4668
            int ref_layer_sampling_dir;
4669
            int h_sampling_factor_n;
4670
            int h_sampling_factor_m;
4671
            int v_sampling_factor_n;
4672
            int v_sampling_factor_m;
4673
            
4674
            s->hierachy_type= get_bits1(gb);
4675
            ref_layer_id= get_bits(gb, 4);
4676
            ref_layer_sampling_dir= get_bits1(gb);
4677
            h_sampling_factor_n= get_bits(gb, 5);
4678
            h_sampling_factor_m= get_bits(gb, 5);
4679
            v_sampling_factor_n= get_bits(gb, 5);
4680
            v_sampling_factor_m= get_bits(gb, 5);
4681
            s->enhancement_type= get_bits1(gb);
4682
            
4683
            if(   h_sampling_factor_n==0 || h_sampling_factor_m==0 
4684
               || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4685
               
4686
//                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4687
                s->scalability=0;
4688
               
4689
                *gb= bak;
4690
            }else
4691
                printf("scalability not supported\n");
4692
            
4693
            // bin shape stuff FIXME
4694
        }
4695
    }
4696
    return 0;
4697
}
4698

    
4699
/**
4700
 * decodes the user data stuff in the header.
4701
 * allso inits divx/xvid/lavc_version/build
4702
 */
4703
static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4704
    char buf[256];
4705
    int i;
4706
    int e;
4707