Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ e91f4bf1

History | View | Annotate | Download (211 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
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7
 *
8
 * This library is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2 of the License, or (at your option) any later version.
12
 *
13
 * This library is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with this library; if not, write to the Free Software
20
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21
 *
22
 * ac prediction encoding, b-frame support, error resilience, optimizations,
23
 * qpel decoding, gmc decoding, interlaced decoding, 
24
 * by Michael Niedermayer <michaelni@gmx.at>
25
 */
26

    
27
/**
28
 * @file h263.c
29
 * h263/mpeg4 codec.
30
 */
31
 
32
//#define DEBUG
33
#include <limits.h>
34

    
35
#include "common.h"
36
#include "dsputil.h"
37
#include "avcodec.h"
38
#include "mpegvideo.h"
39
#include "h263data.h"
40
#include "mpeg4data.h"
41

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

    
45
#define INTRA_MCBPC_VLC_BITS 6
46
#define INTER_MCBPC_VLC_BITS 7
47
#define CBPY_VLC_BITS 6
48
#define MV_VLC_BITS 9
49
#define DC_VLC_BITS 9
50
#define SPRITE_TRAJ_VLC_BITS 6
51
#define MB_TYPE_B_VLC_BITS 4
52
#define TEX_VLC_BITS 9
53
#define H263_MBTYPE_B_VLC_BITS 6
54
#define CBPC_B_VLC_BITS 3
55

    
56
#ifdef CONFIG_ENCODERS
57
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
58
                              int n);
59
static void h263p_encode_umotion(MpegEncContext * s, int val);
60
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
61
                               int n, int dc, uint8_t *scan_table, 
62
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
63
#endif
64

    
65
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
66
static int h263p_decode_umotion(MpegEncContext * s, int pred);
67
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
68
                             int n, int coded);
69
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
70
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
71
                              int n, int coded, int intra, int rvlc);
72
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
73
                               uint8_t *scan_table);
74
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
75
#ifdef CONFIG_ENCODERS
76
static void mpeg4_encode_visual_object_header(MpegEncContext * s);
77
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
78
#endif //CONFIG_ENCODERS
79
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
80
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
81

    
82
#ifdef CONFIG_ENCODERS
83
static uint8_t uni_DCtab_lum_len[512];
84
static uint8_t uni_DCtab_chrom_len[512];
85
static uint16_t uni_DCtab_lum_bits[512];
86
static uint16_t uni_DCtab_chrom_bits[512];
87

    
88
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
89
static uint8_t fcode_tab[MAX_MV*2+1];
90
static uint8_t umv_fcode_tab[MAX_MV*2+1];
91

    
92
static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
93
static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
94
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
95
static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
96
static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
97
static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
98
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
99
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
100
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
101

    
102
/* mpeg4
103
inter
104
max level: 24/6
105
max run: 53/63
106

107
intra
108
max level: 53/16
109
max run: 29/41
110
*/
111
#endif
112

    
113
#if 0 //3IV1 is quite rare and tis slows things down a tiny bit
114
#define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
115
#else 
116
#define IS_3IV1 0
117
#endif
118

    
119
int h263_get_picture_format(int width, int height)
120
{
121
    int format;
122

    
123
    if (width == 128 && height == 96)
124
        format = 1;
125
    else if (width == 176 && height == 144)
126
        format = 2;
127
    else if (width == 352 && height == 288)
128
        format = 3;
129
    else if (width == 704 && height == 576)
130
        format = 4;
131
    else if (width == 1408 && height == 1152)
132
        format = 5;
133
    else
134
        format = 7;
135
    return format;
136
}
137

    
138
#ifdef CONFIG_ENCODERS
139

    
140
static void aspect_to_info(MpegEncContext * s, AVRational aspect){
141
    int i;
142

    
143
    if(aspect.num==0) aspect= (AVRational){1,1};
144

    
145
    for(i=1; i<6; i++){
146
        if(av_cmp_q(pixel_aspect[i], aspect) == 0){
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, 1); /* DeblockingFlag: on */
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= ff_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, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
204
    int best_clock_code=1;
205
    int best_divisor=60;
206
    int best_error= INT_MAX;
207
   
208
    if(s->h263_plus){
209
        for(i=0; i<2; i++){
210
            int div, error;
211
            div= (s->avctx->frame_rate_base*1800000LL + 500LL*s->avctx->frame_rate) / ((1000LL+i)*s->avctx->frame_rate);
212
            div= clip(1, div, 127);
213
            error= ABS(s->avctx->frame_rate_base*1800000LL - (1000LL+i)*s->avctx->frame_rate*div);
214
            if(error < best_error){
215
                best_error= error;
216
                best_divisor= div;
217
                best_clock_code= i;
218
            }
219
        }
220
    }
221
    s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
222
    coded_frame_rate= 1800000;
223
    coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
224

    
225
    align_put_bits(&s->pb);
226

    
227
    /* Update the pointer to last GOB */
228
    s->ptr_lastgob = pbBufPtr(&s->pb);
229
    put_bits(&s->pb, 22, 0x20); /* PSC */
230
    temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->frame_rate_base / 
231
                         (coded_frame_rate_base * (int64_t)s->avctx->frame_rate);
232
    put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
233

    
234
    put_bits(&s->pb, 1, 1);        /* marker */
235
    put_bits(&s->pb, 1, 0);        /* h263 id */
236
    put_bits(&s->pb, 1, 0);        /* split screen off */
237
    put_bits(&s->pb, 1, 0);        /* camera  off */
238
    put_bits(&s->pb, 1, 0);        /* freeze picture release off */
239
    
240
    format = h263_get_picture_format(s->width, s->height);
241
    if (!s->h263_plus) {
242
        /* H.263v1 */
243
        put_bits(&s->pb, 3, format);
244
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
245
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
246
        of H.263v1 UMV implies to check the predicted MV after
247
        calculation of the current MB to see if we're on the limits */
248
        put_bits(&s->pb, 1, 0);        /* unrestricted motion vector: off */
249
        put_bits(&s->pb, 1, 0);        /* SAC: off */
250
        put_bits(&s->pb, 1, s->obmc);        /* advanced prediction mode */
251
        put_bits(&s->pb, 1, 0);        /* not PB frame */
252
        put_bits(&s->pb, 5, s->qscale);
253
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
254
    } else {
255
        int ufep=1;
256
        /* H.263v2 */
257
        /* H.263 Plus PTYPE */
258
        
259
        put_bits(&s->pb, 3, 7);
260
        put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
261
        if (format == 7)
262
            put_bits(&s->pb,3,6); /* Custom Source Format */
263
        else
264
            put_bits(&s->pb, 3, format);
265
            
266
        put_bits(&s->pb,1, s->custom_pcf);
267
        put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
268
        put_bits(&s->pb,1,0); /* SAC: off */
269
        put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
270
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
271
        put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
272
        put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
273
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
274
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
275
        put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
276
        put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
277
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
278
        put_bits(&s->pb,3,0); /* Reserved */
279
                
280
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
281
                
282
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
283
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
284
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
285
        put_bits(&s->pb,2,0); /* Reserved */
286
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
287
                
288
        /* This should be here if PLUSPTYPE */
289
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
290
                
291
                if (format == 7) {
292
            /* Custom Picture Format (CPFMT) */
293
            aspect_to_info(s, s->avctx->sample_aspect_ratio);
294

    
295
            put_bits(&s->pb,4,s->aspect_ratio_info);
296
            put_bits(&s->pb,9,(s->width >> 2) - 1);
297
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
298
            put_bits(&s->pb,9,(s->height >> 2));
299
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
300
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
301
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
302
            }
303
        }
304
        if(s->custom_pcf){
305
            if(ufep){
306
                put_bits(&s->pb, 1, best_clock_code);
307
                put_bits(&s->pb, 7, best_divisor);
308
            }
309
            put_bits(&s->pb, 2, (temp_ref>>8)&3);
310
        }
311
        
312
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
313
        if (s->umvplus)
314
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
315
//FIXME check actual requested range
316
            put_bits(&s->pb,2,1); /* unlimited */
317
        if(s->h263_slice_structured)
318
            put_bits(&s->pb,2,0); /* no weird submodes */
319

    
320
        put_bits(&s->pb, 5, s->qscale);
321
    }
322

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

    
325
    if(s->h263_slice_structured){
326
        put_bits(&s->pb, 1, 1);
327
        
328
        assert(s->mb_x == 0 && s->mb_y == 0);
329
        ff_h263_encode_mba(s);
330

    
331
        put_bits(&s->pb, 1, 1);
332
    }
333

    
334
    if(s->h263_aic){
335
         s->y_dc_scale_table= 
336
         s->c_dc_scale_table= ff_aic_dc_scale_table;
337
    }else{
338
        s->y_dc_scale_table=
339
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
340
    }
341
}
342

    
343
/**
344
 * Encodes a group of blocks header.
345
 */
346
void h263_encode_gob_header(MpegEncContext * s, int mb_line)
347
{
348
    put_bits(&s->pb, 17, 1); /* GBSC */
349

    
350
    if(s->h263_slice_structured){
351
        put_bits(&s->pb, 1, 1);
352

    
353
        ff_h263_encode_mba(s);
354

    
355
        if(s->mb_num > 1583)
356
            put_bits(&s->pb, 1, 1);
357
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
358
        put_bits(&s->pb, 1, 1);
359
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
360
    }else{
361
        int gob_number= mb_line / s->gob_index;
362

    
363
        put_bits(&s->pb, 5, gob_number); /* GN */
364
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
365
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
366
    }
367
}
368

    
369
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
370
    int last=0;
371
    int j;
372
    int rate=0;
373

    
374
    for(j=1; j<=block_last_index; j++){
375
        const int index= scantable[j];
376
        int level= block[index];
377
        if(level){
378
            level+= 64;
379
            if((level&(~127)) == 0){
380
                if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
381
                else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
382
            }else
383
                rate += s->ac_esc_length;
384
            level-= 64;
385

    
386
            last= j;
387
        }
388
    }
389
    
390
    return rate;
391
}
392

    
393
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
394
{
395
    int score= 0;
396
    int i, n;
397
    int8_t * const qscale_table= s->current_picture.qscale_table;
398

    
399
    memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
400
    
401
    for(n=0; n<6; n++){
402
        int16_t *ac_val, *ac_val1;
403
        
404
        score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
405

    
406
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
407
        ac_val1= ac_val;
408
        if(dir[n]){
409
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
410
            /* top prediction */
411
            ac_val-= s->block_wrap[n]*16;
412
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
413
                /* same qscale */
414
                for(i=1; i<8; i++){
415
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
416
                    block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
417
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
418
                    ac_val1[i+8]= level;
419
                }
420
            }else{
421
                /* different qscale, we must rescale */
422
                for(i=1; i<8; i++){
423
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
424
                    block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
425
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
426
                    ac_val1[i+8]= level;
427
                }
428
            }
429
            st[n]= s->intra_h_scantable.permutated;
430
        }else{
431
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
432
            /* left prediction */
433
            ac_val-= 16;
434
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
435
                /* same qscale */
436
                for(i=1; i<8; i++){
437
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
438
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
439
                    ac_val1[i  ]= level;
440
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
441
                }
442
            }else{
443
                /* different qscale, we must rescale */
444
                for(i=1; i<8; i++){
445
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
446
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
447
                    ac_val1[i  ]= level;
448
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
449
                }
450
            }
451
            st[n]= s->intra_v_scantable.permutated;
452
        }
453

    
454
        for(i=63; i>0; i--) //FIXME optimize
455
            if(block[n][ st[n][i] ]) break;
456
        s->block_last_index[n]= i;
457

    
458
        score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
459
    }
460

    
461
    return score < 0;
462
}
463

    
464
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
465
{
466
    int i, n;
467
    memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
468

    
469
    for(n=0; n<6; n++){
470
        int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
471

    
472
        st[n]= s->intra_scantable.permutated;
473
        if(dir[n]){
474
            /* top prediction */
475
            for(i=1; i<8; i++){
476
                block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
477
            }
478
        }else{
479
            /* left prediction */
480
            for(i=1; i<8; i++){
481
                block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
482
            }
483
        }
484
    }
485
}
486

    
487
/**
488
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
489
 */
490
void ff_clean_h263_qscales(MpegEncContext *s){
491
    int i;
492
    int8_t * const qscale_table= s->current_picture.qscale_table;
493
    
494
    for(i=1; i<s->mb_num; i++){
495
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
496
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
497
    }
498
    for(i=s->mb_num-2; i>=0; i--){
499
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
500
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
501
    }
502

    
503
    if(s->codec_id != CODEC_ID_H263P){
504
        for(i=1; i<s->mb_num; i++){
505
            int mb_xy= s->mb_index2xy[i];
506
        
507
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
508
                s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
509
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
510
            }
511
        }
512
    }
513
}
514

    
515
/**
516
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
517
 */
518
void ff_clean_mpeg4_qscales(MpegEncContext *s){
519
    int i;
520
    int8_t * const qscale_table= s->current_picture.qscale_table;
521

    
522
    ff_clean_h263_qscales(s);
523
    
524
    if(s->pict_type== B_TYPE){
525
        int odd=0;
526
        /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
527
           for the actual adaptive quantization */
528
        
529
        for(i=0; i<s->mb_num; i++){
530
            int mb_xy= s->mb_index2xy[i];
531
            odd += qscale_table[mb_xy]&1;
532
        }
533
        
534
        if(2*odd > s->mb_num) odd=1;
535
        else                  odd=0;
536
        
537
        for(i=0; i<s->mb_num; i++){
538
            int mb_xy= s->mb_index2xy[i];
539
            if((qscale_table[mb_xy]&1) != odd)
540
                qscale_table[mb_xy]++;
541
            if(qscale_table[mb_xy] > 31)
542
                qscale_table[mb_xy]= 31;
543
        }            
544
    
545
        for(i=1; i<s->mb_num; i++){
546
            int mb_xy= s->mb_index2xy[i];
547
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
548
                s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
549
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
550
            }
551
        }
552
    }
553
}
554

    
555
#endif //CONFIG_ENCODERS
556
/**
557
 *
558
 * @return the mb_type
559
 */
560
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
561
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
562
    const int colocated_mb_type= s->next_picture.mb_type[mb_index];
563
    int xy= s->block_index[0];
564
    uint16_t time_pp= s->pp_time;
565
    uint16_t time_pb= s->pb_time;
566
    int i;
567
    
568
    //FIXME avoid divides
569
    
570
    if(IS_8X8(colocated_mb_type)){
571
        s->mv_type = MV_TYPE_8X8;
572
        for(i=0; i<4; i++){
573
            xy= s->block_index[i];
574
            s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
575
            s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
576
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
577
                                : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
578
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1] 
579
                                : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
580
        }
581
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
582
    } else if(IS_INTERLACED(colocated_mb_type)){
583
        s->mv_type = MV_TYPE_FIELD;
584
        for(i=0; i<2; i++){
585
            int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
586
            if(s->top_field_first){
587
                time_pp= s->pp_field_time - field_select + i;
588
                time_pb= s->pb_field_time - field_select + i;
589
            }else{
590
                time_pp= s->pp_field_time + field_select - i;
591
                time_pb= s->pb_field_time + field_select - i;
592
            }
593
            s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
594
            s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
595
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
596
                                : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
597
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] 
598
                                : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
599
        }
600
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
601
    }else{
602
        s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
603
        s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
604
        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->next_picture.motion_val[0][xy][0]
605
                            : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
606
        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->next_picture.motion_val[0][xy][1] 
607
                            : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
608
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
609
            s->mv_type= MV_TYPE_16X16;
610
        else
611
            s->mv_type= MV_TYPE_8X8;
612
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
613
    }
614
}
615

    
616
void ff_h263_update_motion_val(MpegEncContext * s){
617
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
618
               //FIXME a lot of thet is only needed for !low_delay
619
    const int wrap = s->b8_stride;
620
    const int xy = s->block_index[0];
621
    
622
    s->current_picture.mbskip_table[mb_xy]= s->mb_skiped; 
623

    
624
    if(s->mv_type != MV_TYPE_8X8){
625
        int motion_x, motion_y;
626
        if (s->mb_intra) {
627
            motion_x = 0;
628
            motion_y = 0;
629
        } else if (s->mv_type == MV_TYPE_16X16) {
630
            motion_x = s->mv[0][0][0];
631
            motion_y = s->mv[0][0][1];
632
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
633
            int i;
634
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
635
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
636
            motion_x = (motion_x>>1) | (motion_x&1);
637
            for(i=0; i<2; i++){
638
                s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
639
                s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
640
            }
641
            s->current_picture.ref_index[0][xy           ]=
642
            s->current_picture.ref_index[0][xy        + 1]= s->field_select[0][0];
643
            s->current_picture.ref_index[0][xy + wrap    ]=
644
            s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
645
        }
646

    
647
        /* no update if 8X8 because it has been done during parsing */
648
        s->current_picture.motion_val[0][xy][0] = motion_x;
649
        s->current_picture.motion_val[0][xy][1] = motion_y;
650
        s->current_picture.motion_val[0][xy + 1][0] = motion_x;
651
        s->current_picture.motion_val[0][xy + 1][1] = motion_y;
652
        s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
653
        s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
654
        s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
655
        s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
656
    }
657

    
658
    if(s->encoding){ //FIXME encoding MUST be cleaned up
659
        if (s->mv_type == MV_TYPE_8X8) 
660
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
661
        else if(s->mb_intra)
662
            s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
663
        else
664
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
665
    }
666
}
667

    
668
#ifdef CONFIG_ENCODERS
669

    
670
static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
671
    int l, bit_size, code;
672

    
673
    if (val == 0) {
674
        return mvtab[0][1];
675
    } else {
676
        bit_size = f_code - 1;
677
        /* modulo encoding */
678
        l= INT_BIT - 6 - bit_size;
679
        val = (val<<l)>>l;
680
        val--;
681
        code = (val >> bit_size) + 1;
682

    
683
        return mvtab[code][1] + 1 + bit_size;
684
    }
685
}
686

    
687
static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
688
    if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
689
        skip_put_bits(&s->pb, 
690
            h263_get_motion_length(s, x, f_code)
691
           +h263_get_motion_length(s, y, f_code));
692
    }else{
693
        ff_h263_encode_motion(s, x, f_code);
694
        ff_h263_encode_motion(s, y, f_code);
695
    }
696
}
697

    
698
static inline int get_p_cbp(MpegEncContext * s,
699
                      DCTELEM block[6][64],
700
                      int motion_x, int motion_y){
701
    int cbp, i;
702

    
703
    if(s->flags & CODEC_FLAG_CBP_RD){
704
        int best_cbpy_score= INT_MAX;
705
        int best_cbpc_score= INT_MAX;
706
        int cbpc = (-1), cbpy= (-1);
707
        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
708
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
709

    
710
        for(i=0; i<4; i++){
711
            int score= inter_MCBPC_bits[i + offset] * lambda;
712
            if(i&1) score += s->coded_score[5];
713
            if(i&2) score += s->coded_score[4];
714

    
715
            if(score < best_cbpc_score){
716
                best_cbpc_score= score;
717
                cbpc= i;
718
            }
719
        }
720

    
721
        for(i=0; i<16; i++){
722
            int score= cbpy_tab[i ^ 0xF][1] * lambda;
723
            if(i&1) score += s->coded_score[3];
724
            if(i&2) score += s->coded_score[2];
725
            if(i&4) score += s->coded_score[1];
726
            if(i&8) score += s->coded_score[0];
727

    
728
            if(score < best_cbpy_score){
729
                best_cbpy_score= score;
730
                cbpy= i;
731
            }
732
        }
733
        cbp= cbpc + 4*cbpy;
734
        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
735
            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
736
                cbp= 0;
737
        }
738

    
739
        for (i = 0; i < 6; i++) {
740
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
741
                s->block_last_index[i]= -1;
742
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
743
            }
744
        }
745
    }else{
746
        cbp= 0;
747
        for (i = 0; i < 6; i++) {
748
            if (s->block_last_index[i] >= 0)
749
                cbp |= 1 << (5 - i);
750
        }
751
    }
752
    return cbp;
753
}
754

    
755
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
756
                            int motion_x, int motion_y, int mb_type){
757
    int cbp=0, i;
758

    
759
    if(s->flags & CODEC_FLAG_CBP_RD){
760
        int score=0;
761
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
762
        
763
        for(i=0; i<6; i++){
764
            if(s->coded_score[i] < 0){
765
                score += s->coded_score[i];
766
                cbp |= 1 << (5 - i);
767
            }
768
        }
769
        
770
        if(cbp){
771
            int zero_score= -6;
772
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
773
                zero_score-= 4; //2*MV + mb_type + cbp bit
774
            }
775

    
776
            zero_score*= lambda;
777
            if(zero_score <= score){
778
                cbp=0;
779
            }
780
        }
781

    
782
        for (i = 0; i < 6; i++) {
783
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
784
                s->block_last_index[i]= -1;
785
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
786
            }
787
        }
788
    }else{
789
        for (i = 0; i < 6; i++) {
790
            if (s->block_last_index[i] >= 0)
791
                cbp |= 1 << (5 - i);
792
        }
793
    }
794
    return cbp;
795
}
796

    
797
static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6], 
798
                               uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
799
    int i;
800
    
801
    if(scan_table){
802
        if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
803
            for (i = 0; i < 6; i++) {
804
                skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
805
            }
806
        }else{
807
            /* encode each block */
808
            for (i = 0; i < 6; i++) {
809
                mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
810
            }
811
        }
812
    }else{
813
        if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
814
            for (i = 0; i < 6; i++) {
815
                skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
816
            }
817
        }else{
818
            /* encode each block */
819
            for (i = 0; i < 6; i++) {
820
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
821
            }
822
        }
823
    }
824
}
825

    
826
void mpeg4_encode_mb(MpegEncContext * s,
827
                    DCTELEM block[6][64],
828
                    int motion_x, int motion_y)
829
{
830
    int cbpc, cbpy, pred_x, pred_y;
831
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
832
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
833
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
834
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
835
    const int dquant_code[5]= {1,0,9,2,3};
836
    
837
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
838
    if (!s->mb_intra) {
839
        int i, cbp;
840
        
841
        if(s->pict_type==B_TYPE){
842
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
843
            int mb_type=  mb_type_table[s->mv_dir];
844

    
845
            if(s->mb_x==0){
846
                for(i=0; i<2; i++){
847
                    s->last_mv[i][0][0]= 
848
                    s->last_mv[i][0][1]= 
849
                    s->last_mv[i][1][0]= 
850
                    s->last_mv[i][1][1]= 0;
851
                }
852
            }
853
            
854
            assert(s->dquant>=-2 && s->dquant<=2);
855
            assert((s->dquant&1)==0);
856
            assert(mb_type>=0);
857

    
858
            /* nothing to do if this MB was skiped in the next P Frame */
859
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
860
                s->skip_count++;
861
                s->mv[0][0][0]= 
862
                s->mv[0][0][1]= 
863
                s->mv[1][0][0]= 
864
                s->mv[1][0][1]= 0;
865
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
866
                s->qscale -= s->dquant;
867
//                s->mb_skiped=1;
868

    
869
                return;
870
            }
871
            
872
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
873
            
874
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
875
                /* direct MB with MV={0,0} */
876
                assert(s->dquant==0);
877
                
878
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
879

    
880
                if(interleaved_stats){
881
                    s->misc_bits++;
882
                    s->last_bits++;
883
                }
884
                s->skip_count++;
885
                return;
886
            }
887
            
888
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
889
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
890
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
891
            if(cbp) put_bits(&s->pb, 6, cbp);
892
            
893
            if(cbp && mb_type){
894
                if(s->dquant)
895
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
896
                else
897
                    put_bits(&s->pb, 1, 0);
898
            }else
899
                s->qscale -= s->dquant;
900
            
901
            if(!s->progressive_sequence){
902
                if(cbp)
903
                    put_bits(&s->pb, 1, s->interlaced_dct);
904
                if(mb_type) // not diect mode
905
                    put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
906
            }
907

    
908
            if(interleaved_stats){
909
                s->misc_bits+= get_bits_diff(s);
910
            }
911

    
912
            if(mb_type == 0){
913
                assert(s->mv_dir & MV_DIRECT);
914
                ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
915
                s->b_count++;
916
                s->f_count++;
917
            }else{
918
                assert(mb_type > 0 && mb_type < 4);
919
                if(s->mv_type != MV_TYPE_FIELD){
920
                    if(s->mv_dir & MV_DIR_FORWARD){
921
                        ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
922
                                                        s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
923
                        s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
924
                        s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
925
                        s->f_count++;
926
                    }
927
                    if(s->mv_dir & MV_DIR_BACKWARD){
928
                        ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
929
                                                        s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
930
                        s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
931
                        s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
932
                        s->b_count++;
933
                    }
934
                }else{
935
                    if(s->mv_dir & MV_DIR_FORWARD){
936
                        put_bits(&s->pb, 1, s->field_select[0][0]);
937
                        put_bits(&s->pb, 1, s->field_select[0][1]);
938
                    }
939
                    if(s->mv_dir & MV_DIR_BACKWARD){
940
                        put_bits(&s->pb, 1, s->field_select[1][0]);
941
                        put_bits(&s->pb, 1, s->field_select[1][1]);
942
                    }
943
                    if(s->mv_dir & MV_DIR_FORWARD){
944
                        for(i=0; i<2; i++){
945
                            ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
946
                                                            s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
947
                            s->last_mv[0][i][0]= s->mv[0][i][0];
948
                            s->last_mv[0][i][1]= s->mv[0][i][1]*2;
949
                        }
950
                        s->f_count++;
951
                    }
952
                    if(s->mv_dir & MV_DIR_BACKWARD){
953
                        for(i=0; i<2; i++){
954
                            ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
955
                                                            s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
956
                            s->last_mv[1][i][0]= s->mv[1][i][0];
957
                            s->last_mv[1][i][1]= s->mv[1][i][1]*2;
958
                        }
959
                        s->b_count++;
960
                    }
961
                }
962
            }
963

    
964
            if(interleaved_stats){
965
                s->mv_bits+= get_bits_diff(s);
966
            }
967

    
968
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
969

    
970
            if(interleaved_stats){
971
                s->p_tex_bits+= get_bits_diff(s);
972
            }
973

    
974
        }else{ /* s->pict_type==B_TYPE */
975
            cbp= get_p_cbp(s, block, motion_x, motion_y);
976
        
977
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
978
                /* check if the B frames can skip it too, as we must skip it if we skip here 
979
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
980
                if(s->max_b_frames>0){
981
                    int i;
982
                    int x,y, offset;
983
                    uint8_t *p_pic;
984

    
985
                    x= s->mb_x*16;
986
                    y= s->mb_y*16;
987
                    if(x+16 > s->width)  x= s->width-16;
988
                    if(y+16 > s->height) y= s->height-16;
989

    
990
                    offset= x + y*s->linesize;
991
                    p_pic= s->new_picture.data[0] + offset;
992
                    
993
                    s->mb_skiped=1;
994
                    for(i=0; i<s->max_b_frames; i++){
995
                        uint8_t *b_pic;
996
                        int diff;
997
                        Picture *pic= s->reordered_input_picture[i+1];
998

    
999
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
1000

    
1001
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
1002
                        diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1003
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1004
                            s->mb_skiped=0;
1005
                            break;
1006
                        }
1007
                    }
1008
                }else
1009
                    s->mb_skiped=1; 
1010

    
1011
                if(s->mb_skiped==1){
1012
                    /* skip macroblock */
1013
                    put_bits(&s->pb, 1, 1);
1014

    
1015
                    if(interleaved_stats){
1016
                        s->misc_bits++;
1017
                        s->last_bits++;
1018
                    }
1019
                    s->skip_count++;
1020
                    
1021
                    return;
1022
                }
1023
            }
1024

    
1025
            put_bits(&s->pb, 1, 0);        /* mb coded */
1026
            cbpc = cbp & 3;
1027
            cbpy = cbp >> 2;
1028
            cbpy ^= 0xf;
1029
            if(s->mv_type==MV_TYPE_16X16){
1030
                if(s->dquant) cbpc+= 8;
1031
                put_bits(&s->pb,
1032
                        inter_MCBPC_bits[cbpc],
1033
                        inter_MCBPC_code[cbpc]);
1034

    
1035
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1036
                if(s->dquant)
1037
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1038

    
1039
                if(!s->progressive_sequence){
1040
                    if(cbp)
1041
                        put_bits(pb2, 1, s->interlaced_dct);
1042
                    put_bits(pb2, 1, 0);
1043
                }
1044
                    
1045
                if(interleaved_stats){
1046
                    s->misc_bits+= get_bits_diff(s);
1047
                }
1048

    
1049
                /* motion vectors: 16x16 mode */
1050
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1051
            
1052
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
1053
                                                motion_y - pred_y, s->f_code);
1054
            }else if(s->mv_type==MV_TYPE_FIELD){
1055
                if(s->dquant) cbpc+= 8;
1056
                put_bits(&s->pb,
1057
                        inter_MCBPC_bits[cbpc],
1058
                        inter_MCBPC_code[cbpc]);
1059

    
1060
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1061
                if(s->dquant)
1062
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1063

    
1064
                assert(!s->progressive_sequence);
1065
                if(cbp)
1066
                    put_bits(pb2, 1, s->interlaced_dct);
1067
                put_bits(pb2, 1, 1);
1068
                    
1069
                if(interleaved_stats){
1070
                    s->misc_bits+= get_bits_diff(s);
1071
                }
1072

    
1073
                /* motion vectors: 16x8 interlaced mode */
1074
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1075
                pred_y /=2;
1076
                
1077
                put_bits(&s->pb, 1, s->field_select[0][0]);
1078
                put_bits(&s->pb, 1, s->field_select[0][1]);
1079
            
1080
                ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1081
                                                s->mv[0][0][1] - pred_y, s->f_code);
1082
                ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1083
                                                s->mv[0][1][1] - pred_y, s->f_code);
1084
            }else{
1085
                assert(s->mv_type==MV_TYPE_8X8);
1086
                put_bits(&s->pb,
1087
                        inter_MCBPC_bits[cbpc+16],
1088
                        inter_MCBPC_code[cbpc+16]);
1089
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1090

    
1091
                if(!s->progressive_sequence){
1092
                    if(cbp)
1093
                        put_bits(pb2, 1, s->interlaced_dct);
1094
                }
1095
    
1096
                if(interleaved_stats){
1097
                    s->misc_bits+= get_bits_diff(s);
1098
                }
1099

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

    
1104
                    ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1105
                                                    s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1106
                }
1107
            }
1108

    
1109
            if(interleaved_stats){ 
1110
                s->mv_bits+= get_bits_diff(s);
1111
            }
1112

    
1113
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1114

    
1115
            if(interleaved_stats){
1116
                s->p_tex_bits+= get_bits_diff(s);
1117
            }
1118
            s->f_count++;
1119
        }
1120
    } else {
1121
        int cbp;
1122
        int dc_diff[6];   //dc values with the dc prediction subtracted 
1123
        int dir[6];  //prediction direction
1124
        int zigzag_last_index[6];
1125
        uint8_t *scan_table[6];
1126
        int i;
1127

    
1128
        for(i=0; i<6; i++){
1129
            dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1130
        }
1131

    
1132
        if(s->flags & CODEC_FLAG_AC_PRED){
1133
            s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1134
            if(!s->ac_pred)
1135
                restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1136
        }else{
1137
            for(i=0; i<6; i++)
1138
                scan_table[i]= s->intra_scantable.permutated;
1139
        }
1140

    
1141
        /* compute cbp */
1142
        cbp = 0;
1143
        for (i = 0; i < 6; i++) {
1144
            if (s->block_last_index[i] >= 1)
1145
                cbp |= 1 << (5 - i);
1146
        }
1147

    
1148
        cbpc = cbp & 3;
1149
        if (s->pict_type == I_TYPE) {
1150
            if(s->dquant) cbpc+=4;
1151
            put_bits(&s->pb,
1152
                intra_MCBPC_bits[cbpc],
1153
                intra_MCBPC_code[cbpc]);
1154
        } else {
1155
            if(s->dquant) cbpc+=8;
1156
            put_bits(&s->pb, 1, 0);        /* mb coded */
1157
            put_bits(&s->pb,
1158
                inter_MCBPC_bits[cbpc + 4],
1159
                inter_MCBPC_code[cbpc + 4]);
1160
        }
1161
        put_bits(pb2, 1, s->ac_pred);
1162
        cbpy = cbp >> 2;
1163
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1164
        if(s->dquant)
1165
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1166

    
1167
        if(!s->progressive_sequence){
1168
            put_bits(dc_pb, 1, s->interlaced_dct);
1169
        }
1170

    
1171
        if(interleaved_stats){
1172
            s->misc_bits+= get_bits_diff(s);
1173
        }
1174

    
1175
        mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1176

    
1177
        if(interleaved_stats){
1178
            s->i_tex_bits+= get_bits_diff(s);
1179
        }
1180
        s->i_count++;
1181

    
1182
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1183
        if(s->ac_pred)
1184
            restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1185
    }
1186
}
1187

    
1188
void h263_encode_mb(MpegEncContext * s,
1189
                    DCTELEM block[6][64],
1190
                    int motion_x, int motion_y)
1191
{
1192
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
1193
    int16_t pred_dc;
1194
    int16_t rec_intradc[6];
1195
    uint16_t *dc_ptr[6];
1196
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1197
    const int dquant_code[5]= {1,0,9,2,3};
1198
           
1199
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1200
    if (!s->mb_intra) {
1201
        /* compute cbp */
1202
        cbp= get_p_cbp(s, block, motion_x, motion_y);
1203

    
1204
        if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1205
            /* skip macroblock */
1206
            put_bits(&s->pb, 1, 1);
1207
            if(interleaved_stats){
1208
                s->misc_bits++;
1209
                s->last_bits++;
1210
            }
1211
            s->skip_count++;
1212

    
1213
            return;
1214
        }
1215
        put_bits(&s->pb, 1, 0);        /* mb coded */
1216
        
1217
        cbpc = cbp & 3;
1218
        cbpy = cbp >> 2;
1219
        if(s->alt_inter_vlc==0 || cbpc!=3)
1220
            cbpy ^= 0xF;
1221
        if(s->dquant) cbpc+= 8;
1222
        if(s->mv_type==MV_TYPE_16X16){
1223
            put_bits(&s->pb,
1224
                    inter_MCBPC_bits[cbpc],
1225
                    inter_MCBPC_code[cbpc]);
1226

    
1227
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1228
            if(s->dquant)
1229
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1230
                
1231
            if(interleaved_stats){
1232
                s->misc_bits+= get_bits_diff(s);
1233
            }
1234

    
1235
            /* motion vectors: 16x16 mode */
1236
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1237
            
1238
            if (!s->umvplus) {  
1239
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
1240
                                                motion_y - pred_y, 1);
1241
            }
1242
            else {
1243
                h263p_encode_umotion(s, motion_x - pred_x);
1244
                h263p_encode_umotion(s, motion_y - pred_y);
1245
                if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1246
                    /* To prevent Start Code emulation */
1247
                    put_bits(&s->pb,1,1);
1248
            }
1249
        }else{
1250
            put_bits(&s->pb,
1251
                    inter_MCBPC_bits[cbpc+16],
1252
                    inter_MCBPC_code[cbpc+16]);
1253
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1254
            if(s->dquant)
1255
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1256

    
1257
            if(interleaved_stats){
1258
                s->misc_bits+= get_bits_diff(s);
1259
            }
1260

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

    
1265
                motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1266
                motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1267
                if (!s->umvplus) {  
1268
                    ff_h263_encode_motion_vector(s, motion_x - pred_x,
1269
                                                    motion_y - pred_y, 1);
1270
                }
1271
                else {
1272
                    h263p_encode_umotion(s, motion_x - pred_x);
1273
                    h263p_encode_umotion(s, motion_y - pred_y);
1274
                    if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1275
                        /* To prevent Start Code emulation */
1276
                        put_bits(&s->pb,1,1);
1277
                }
1278
            }
1279
        }
1280

    
1281
        if(interleaved_stats){
1282
            s->mv_bits+= get_bits_diff(s);
1283
        }
1284
    } else {
1285
        assert(s->mb_intra);
1286
        
1287
        cbp = 0;
1288
        if (s->h263_aic) {
1289
            /* Predict DC */
1290
            for(i=0; i<6; i++) {
1291
                int16_t level = block[i][0];
1292
                int scale;
1293
                
1294
                if(i<4) scale= s->y_dc_scale;
1295
                else    scale= s->c_dc_scale;
1296

    
1297
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1298
                level -= pred_dc;
1299
                /* Quant */
1300
                if (level >= 0)
1301
                    level = (level + (scale>>1))/scale;
1302
                else
1303
                    level = (level - (scale>>1))/scale;
1304
                    
1305
                /* AIC can change CBP */
1306
                if (level == 0 && s->block_last_index[i] == 0)
1307
                    s->block_last_index[i] = -1;
1308

    
1309
                if(!s->modified_quant){
1310
                    if (level < -127)
1311
                        level = -127;
1312
                    else if (level > 127)
1313
                        level = 127;
1314
                }
1315

    
1316
                block[i][0] = level;
1317
                /* Reconstruction */ 
1318
                rec_intradc[i] = scale*level + pred_dc;
1319
                /* Oddify */
1320
                rec_intradc[i] |= 1;
1321
                //if ((rec_intradc[i] % 2) == 0)
1322
                //    rec_intradc[i]++;
1323
                /* Clipping */
1324
                if (rec_intradc[i] < 0)
1325
                    rec_intradc[i] = 0;
1326
                else if (rec_intradc[i] > 2047)
1327
                    rec_intradc[i] = 2047;
1328
                                
1329
                /* Update AC/DC tables */
1330
                *dc_ptr[i] = rec_intradc[i];
1331
                if (s->block_last_index[i] >= 0)
1332
                    cbp |= 1 << (5 - i);
1333
            }
1334
        }else{
1335
            for(i=0; i<6; i++) {
1336
                /* compute cbp */
1337
                if (s->block_last_index[i] >= 1)
1338
                    cbp |= 1 << (5 - i);
1339
            }
1340
        }
1341

    
1342
        cbpc = cbp & 3;
1343
        if (s->pict_type == I_TYPE) {
1344
            if(s->dquant) cbpc+=4;
1345
            put_bits(&s->pb,
1346
                intra_MCBPC_bits[cbpc],
1347
                intra_MCBPC_code[cbpc]);
1348
        } else {
1349
            if(s->dquant) cbpc+=8;
1350
            put_bits(&s->pb, 1, 0);        /* mb coded */
1351
            put_bits(&s->pb,
1352
                inter_MCBPC_bits[cbpc + 4],
1353
                inter_MCBPC_code[cbpc + 4]);
1354
        }
1355
        if (s->h263_aic) {
1356
            /* XXX: currently, we do not try to use ac prediction */
1357
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
1358
        }
1359
        cbpy = cbp >> 2;
1360
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1361
        if(s->dquant)
1362
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1363

    
1364
        if(interleaved_stats){
1365
            s->misc_bits+= get_bits_diff(s);
1366
        }
1367
    }
1368

    
1369
    for(i=0; i<6; i++) {
1370
        /* encode each block */
1371
        h263_encode_block(s, block[i], i);
1372
    
1373
        /* Update INTRADC for decoding */
1374
        if (s->h263_aic && s->mb_intra) {
1375
            block[i][0] = rec_intradc[i];
1376
            
1377
        }
1378
    }
1379

    
1380
    if(interleaved_stats){
1381
        if (!s->mb_intra) {
1382
            s->p_tex_bits+= get_bits_diff(s);
1383
            s->f_count++;
1384
        }else{
1385
            s->i_tex_bits+= get_bits_diff(s);
1386
            s->i_count++;
1387
        }
1388
    }
1389
}
1390
#endif
1391

    
1392
void ff_h263_loop_filter(MpegEncContext * s){
1393
    int qp_c;
1394
    const int linesize  = s->linesize;
1395
    const int uvlinesize= s->uvlinesize;
1396
    const int xy = s->mb_y * s->mb_stride + s->mb_x;
1397
    uint8_t *dest_y = s->dest[0];
1398
    uint8_t *dest_cb= s->dest[1];
1399
    uint8_t *dest_cr= s->dest[2];
1400
    
1401
//    if(s->pict_type==B_TYPE && !s->readable) return;
1402

    
1403
    /*
1404
       Diag Top
1405
       Left Center
1406
    */
1407
    if(!IS_SKIP(s->current_picture.mb_type[xy])){
1408
        qp_c= s->qscale;
1409
        s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1410
        s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1411
    }else
1412
        qp_c= 0;
1413

    
1414
    if(s->mb_y){
1415
        int qp_dt, qp_t, qp_tc;
1416

    
1417
        if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1418
            qp_t=0;
1419
        else 
1420
            qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1421

    
1422
        if(qp_c) 
1423
            qp_tc= qp_c;
1424
        else
1425
            qp_tc= qp_t;
1426
            
1427
        if(qp_tc){
1428
            const int chroma_qp= s->chroma_qscale_table[qp_tc];
1429
            s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
1430
            s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
1431
        
1432
            s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1433
            s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1434
        }
1435
        
1436
        if(qp_t)
1437
            s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_t);
1438
        
1439
        if(s->mb_x){
1440
            if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1441
                qp_dt= qp_t;
1442
            else
1443
                qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1444
            
1445
            if(qp_dt){
1446
                const int chroma_qp= s->chroma_qscale_table[qp_dt];
1447
                s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
1448
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1449
                s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1450
            }
1451
        }
1452
    }
1453

    
1454
    if(qp_c){
1455
        s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1456
        if(s->mb_y + 1 == s->mb_height)
1457
            s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1458
    }
1459
    
1460
    if(s->mb_x){
1461
        int qp_lc;
1462
        if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1463
            qp_lc= qp_c;
1464
        else
1465
            qp_lc= s->current_picture.qscale_table[xy-1];
1466
        
1467
        if(qp_lc){
1468
            s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1469
            if(s->mb_y + 1 == s->mb_height){
1470
                const int chroma_qp= s->chroma_qscale_table[qp_lc];
1471
                s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1472
                s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1473
                s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1474
            }
1475
        }
1476
    }
1477
}
1478

    
1479
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1480
{
1481
    int x, y, wrap, a, c, pred_dc, scale;
1482
    int16_t *dc_val, *ac_val;
1483

    
1484
    /* find prediction */
1485
    if (n < 4) {
1486
        x = 2 * s->mb_x + (n & 1);
1487
        y = 2 * s->mb_y + ((n & 2) >> 1);
1488
        wrap = s->b8_stride;
1489
        dc_val = s->dc_val[0];
1490
        ac_val = s->ac_val[0][0];
1491
        scale = s->y_dc_scale;
1492
    } else {
1493
        x = s->mb_x;
1494
        y = s->mb_y;
1495
        wrap = s->mb_stride;
1496
        dc_val = s->dc_val[n - 4 + 1];
1497
        ac_val = s->ac_val[n - 4 + 1][0];
1498
        scale = s->c_dc_scale;
1499
    }
1500
    /* B C
1501
     * A X 
1502
     */
1503
    a = dc_val[(x - 1) + (y) * wrap];
1504
    c = dc_val[(x) + (y - 1) * wrap];
1505
    
1506
    /* No prediction outside GOB boundary */
1507
    if(s->first_slice_line && n!=3){
1508
        if(n!=2) c= 1024;
1509
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1510
    }
1511
    pred_dc = 1024;
1512
    /* just DC prediction */
1513
    if (a != 1024 && c != 1024)
1514
        pred_dc = (a + c) >> 1;
1515
    else if (a != 1024)
1516
        pred_dc = a;
1517
    else
1518
        pred_dc = c;
1519
    
1520
    /* we assume pred is positive */
1521
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1522
    *dc_val_ptr = &dc_val[x + y * wrap];
1523
    return pred_dc;
1524
}
1525

    
1526
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1527
{
1528
    int x, y, wrap, a, c, pred_dc, scale, i;
1529
    int16_t *dc_val, *ac_val, *ac_val1;
1530

    
1531
    /* find prediction */
1532
    if (n < 4) {
1533
        x = 2 * s->mb_x + (n & 1);
1534
        y = 2 * s->mb_y + (n>> 1);
1535
        wrap = s->b8_stride;
1536
        dc_val = s->dc_val[0];
1537
        ac_val = s->ac_val[0][0];
1538
        scale = s->y_dc_scale;
1539
    } else {
1540
        x = s->mb_x;
1541
        y = s->mb_y;
1542
        wrap = s->mb_stride;
1543
        dc_val = s->dc_val[n - 4 + 1];
1544
        ac_val = s->ac_val[n - 4 + 1][0];
1545
        scale = s->c_dc_scale;
1546
    }
1547
    
1548
    ac_val += ((y) * wrap + (x)) * 16;
1549
    ac_val1 = ac_val;
1550
    
1551
    /* B C
1552
     * A X 
1553
     */
1554
    a = dc_val[(x - 1) + (y) * wrap];
1555
    c = dc_val[(x) + (y - 1) * wrap];
1556
    
1557
    /* No prediction outside GOB boundary */
1558
    if(s->first_slice_line && n!=3){
1559
        if(n!=2) c= 1024;
1560
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1561
    }
1562
    
1563
    if (s->ac_pred) {
1564
        pred_dc = 1024;
1565
        if (s->h263_aic_dir) {
1566
            /* left prediction */
1567
            if (a != 1024) {
1568
                ac_val -= 16;
1569
                for(i=1;i<8;i++) {
1570
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1571
                }
1572
                pred_dc = a;
1573
            }
1574
        } else {
1575
            /* top prediction */
1576
            if (c != 1024) {
1577
                ac_val -= 16 * wrap;
1578
                for(i=1;i<8;i++) {
1579
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1580
                }
1581
                pred_dc = c;
1582
            }
1583
        }
1584
    } else {
1585
        /* just DC prediction */
1586
        if (a != 1024 && c != 1024)
1587
            pred_dc = (a + c) >> 1;
1588
        else if (a != 1024)
1589
            pred_dc = a;
1590
        else
1591
            pred_dc = c;
1592
    }
1593
    
1594
    /* we assume pred is positive */
1595
    block[0]=block[0]*scale + pred_dc;
1596
    
1597
    if (block[0] < 0)
1598
        block[0] = 0;
1599
    else 
1600
        block[0] |= 1;
1601
    
1602
    /* Update AC/DC tables */
1603
    dc_val[(x) + (y) * wrap] = block[0];
1604
    
1605
    /* left copy */
1606
    for(i=1;i<8;i++)
1607
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1608
    /* top copy */
1609
    for(i=1;i<8;i++)
1610
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1611
}
1612

    
1613
int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1614
                        int *px, int *py)
1615
{
1616
    int wrap;
1617
    int16_t *A, *B, *C, (*mot_val)[2];
1618
    static const int off[4]= {2, 1, 1, -1};
1619

    
1620
    wrap = s->b8_stride;
1621
    mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1622

    
1623
    A = mot_val[ - 1];
1624
    /* special case for first (slice) line */
1625
    if (s->first_slice_line && block<3) {
1626
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1627
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1628
        if(block==0){ //most common case
1629
            if(s->mb_x  == s->resync_mb_x){ //rare
1630
                *px= *py = 0;
1631
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1632
                C = mot_val[off[block] - wrap];
1633
                if(s->mb_x==0){
1634
                    *px = C[0];
1635
                    *py = C[1];
1636
                }else{
1637
                    *px = mid_pred(A[0], 0, C[0]);
1638
                    *py = mid_pred(A[1], 0, C[1]);
1639
                }
1640
            }else{
1641
                *px = A[0];
1642
                *py = A[1];
1643
            }
1644
        }else if(block==1){
1645
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1646
                C = mot_val[off[block] - wrap];
1647
                *px = mid_pred(A[0], 0, C[0]);
1648
                *py = mid_pred(A[1], 0, C[1]);
1649
            }else{
1650
                *px = A[0];
1651
                *py = A[1];
1652
            }
1653
        }else{ /* block==2*/
1654
            B = mot_val[ - wrap];
1655
            C = mot_val[off[block] - wrap];
1656
            if(s->mb_x == s->resync_mb_x) //rare
1657
                A[0]=A[1]=0;
1658
    
1659
            *px = mid_pred(A[0], B[0], C[0]);
1660
            *py = mid_pred(A[1], B[1], C[1]);
1661
        }
1662
    } else {
1663
        B = mot_val[ - wrap];
1664
        C = mot_val[off[block] - wrap];
1665
        *px = mid_pred(A[0], B[0], C[0]);
1666
        *py = mid_pred(A[1], B[1], C[1]);
1667
    }
1668
    return *mot_val;
1669
}
1670

    
1671
#ifdef CONFIG_ENCODERS
1672
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1673
{
1674
    int range, l, bit_size, sign, code, bits;
1675

    
1676
    if (val == 0) {
1677
        /* zero vector */
1678
        code = 0;
1679
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1680
    } else {
1681
        bit_size = f_code - 1;
1682
        range = 1 << bit_size;
1683
        /* modulo encoding */
1684
        l= INT_BIT - 6 - bit_size;
1685
        val = (val<<l)>>l;
1686
        sign = val>>31;
1687
        val= (val^sign)-sign;
1688
        sign&=1;
1689

    
1690
        val--;
1691
        code = (val >> bit_size) + 1;
1692
        bits = val & (range - 1);
1693

    
1694
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1695
        if (bit_size > 0) {
1696
            put_bits(&s->pb, bit_size, bits);
1697
        }
1698
    }
1699
}
1700

    
1701
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1702
static void h263p_encode_umotion(MpegEncContext * s, int val)
1703
{
1704
    short sval = 0; 
1705
    short i = 0;
1706
    short n_bits = 0;
1707
    short temp_val;
1708
    int code = 0;
1709
    int tcode;
1710
    
1711
    if ( val == 0)
1712
        put_bits(&s->pb, 1, 1);
1713
    else if (val == 1)
1714
        put_bits(&s->pb, 3, 0);
1715
    else if (val == -1)
1716
        put_bits(&s->pb, 3, 2);
1717
    else {
1718
        
1719
        sval = ((val < 0) ? (short)(-val):(short)val);
1720
        temp_val = sval;
1721
        
1722
        while (temp_val != 0) {
1723
            temp_val = temp_val >> 1;
1724
            n_bits++;
1725
        }
1726
        
1727
        i = n_bits - 1;
1728
        while (i > 0) {
1729
            tcode = (sval & (1 << (i-1))) >> (i-1);
1730
            tcode = (tcode << 1) | 1;
1731
            code = (code << 2) | tcode;
1732
            i--;
1733
        }
1734
        code = ((code << 1) | (val < 0)) << 1;
1735
        put_bits(&s->pb, (2*n_bits)+1, code);
1736
        //printf("\nVal = %d\tCode = %d", sval, code);
1737
    }
1738
}
1739

    
1740
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1741
{
1742
    int f_code;
1743
    int mv;
1744
    
1745
    if(mv_penalty==NULL)
1746
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1747
    
1748
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1749
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1750
            int len;
1751

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

    
1756
                bit_size = f_code - 1;
1757
                range = 1 << bit_size;
1758

    
1759
                val=mv;
1760
                if (val < 0) 
1761
                    val = -val;
1762
                val--;
1763
                code = (val >> bit_size) + 1;
1764
                if(code<33){
1765
                    len= mvtab[code][1] + 1 + bit_size;
1766
                }else{
1767
                    len= mvtab[32][1] + 2 + bit_size;
1768
                }
1769
            }
1770

    
1771
            mv_penalty[f_code][mv+MAX_MV]= len;
1772
        }
1773
    }
1774

    
1775
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1776
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1777
            fcode_tab[mv+MAX_MV]= f_code;
1778
        }
1779
    }
1780

    
1781
    for(mv=0; mv<MAX_MV*2+1; mv++){
1782
        umv_fcode_tab[mv]= 1;
1783
    }
1784
}
1785
#endif
1786

    
1787
#ifdef CONFIG_ENCODERS
1788

    
1789
static void init_uni_dc_tab(void)
1790
{
1791
    int level, uni_code, uni_len;
1792

    
1793
    for(level=-256; level<256; level++){
1794
        int size, v, l;
1795
        /* find number of bits */
1796
        size = 0;
1797
        v = abs(level);
1798
        while (v) {
1799
            v >>= 1;
1800
            size++;
1801
        }
1802

    
1803
        if (level < 0)
1804
            l= (-level) ^ ((1 << size) - 1);
1805
        else
1806
            l= level;
1807

    
1808
        /* luminance */
1809
        uni_code= DCtab_lum[size][0];
1810
        uni_len = DCtab_lum[size][1];
1811

    
1812
        if (size > 0) {
1813
            uni_code<<=size; uni_code|=l;
1814
            uni_len+=size;
1815
            if (size > 8){
1816
                uni_code<<=1; uni_code|=1;
1817
                uni_len++;
1818
            }
1819
        }
1820
        uni_DCtab_lum_bits[level+256]= uni_code;
1821
        uni_DCtab_lum_len [level+256]= uni_len;
1822

    
1823
        /* chrominance */
1824
        uni_code= DCtab_chrom[size][0];
1825
        uni_len = DCtab_chrom[size][1];
1826
        
1827
        if (size > 0) {
1828
            uni_code<<=size; uni_code|=l;
1829
            uni_len+=size;
1830
            if (size > 8){
1831
                uni_code<<=1; uni_code|=1;
1832
                uni_len++;
1833
            }
1834
        }
1835
        uni_DCtab_chrom_bits[level+256]= uni_code;
1836
        uni_DCtab_chrom_len [level+256]= uni_len;
1837

    
1838
    }
1839
}
1840

    
1841
#endif //CONFIG_ENCODERS
1842

    
1843
#ifdef CONFIG_ENCODERS
1844
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1845
    int slevel, run, last;
1846
    
1847
    assert(MAX_LEVEL >= 64);
1848
    assert(MAX_RUN   >= 63);
1849

    
1850
    for(slevel=-64; slevel<64; slevel++){
1851
        if(slevel==0) continue;
1852
        for(run=0; run<64; run++){
1853
            for(last=0; last<=1; last++){
1854
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1855
                int level= slevel < 0 ? -slevel : slevel;
1856
                int sign= slevel < 0 ? 1 : 0;
1857
                int bits, len, code;
1858
                int level1, run1;
1859
                
1860
                len_tab[index]= 100;
1861
                     
1862
                /* ESC0 */
1863
                code= get_rl_index(rl, last, run, level);
1864
                bits= rl->table_vlc[code][0];
1865
                len=  rl->table_vlc[code][1];
1866
                bits=bits*2+sign; len++;
1867
                
1868
                if(code!=rl->n && len < len_tab[index]){
1869
                    bits_tab[index]= bits;
1870
                    len_tab [index]= len;
1871
                }
1872
#if 1
1873
                /* ESC1 */
1874
                bits= rl->table_vlc[rl->n][0];
1875
                len=  rl->table_vlc[rl->n][1];
1876
                bits=bits*2;    len++; //esc1
1877
                level1= level - rl->max_level[last][run];
1878
                if(level1>0){
1879
                    code= get_rl_index(rl, last, run, level1);
1880
                    bits<<= rl->table_vlc[code][1];
1881
                    len  += rl->table_vlc[code][1];
1882
                    bits += rl->table_vlc[code][0];
1883
                    bits=bits*2+sign; len++;
1884
                
1885
                    if(code!=rl->n && len < len_tab[index]){
1886
                        bits_tab[index]= bits;
1887
                        len_tab [index]= len;
1888
                    }
1889
                }
1890
#endif 
1891
#if 1
1892
                /* ESC2 */
1893
                bits= rl->table_vlc[rl->n][0];
1894
                len=  rl->table_vlc[rl->n][1];
1895
                bits=bits*4+2;    len+=2; //esc2
1896
                run1 = run - rl->max_run[last][level] - 1;
1897
                if(run1>=0){
1898
                    code= get_rl_index(rl, last, run1, level);
1899
                    bits<<= rl->table_vlc[code][1];
1900
                    len  += rl->table_vlc[code][1];
1901
                    bits += rl->table_vlc[code][0];
1902
                    bits=bits*2+sign; len++;
1903
                
1904
                    if(code!=rl->n && len < len_tab[index]){
1905
                        bits_tab[index]= bits;
1906
                        len_tab [index]= len;
1907
                    }
1908
                }
1909
#endif           
1910
                /* ESC3 */        
1911
                bits= rl->table_vlc[rl->n][0];
1912
                len = rl->table_vlc[rl->n][1];
1913
                bits=bits*4+3;    len+=2; //esc3
1914
                bits=bits*2+last; len++;
1915
                bits=bits*64+run; len+=6;
1916
                bits=bits*2+1;    len++;  //marker
1917
                bits=bits*4096+(slevel&0xfff); len+=12;
1918
                bits=bits*2+1;    len++;  //marker
1919
                
1920
                if(len < len_tab[index]){
1921
                    bits_tab[index]= bits;
1922
                    len_tab [index]= len;
1923
                }
1924
            }
1925
        }
1926
    }
1927
}
1928

    
1929
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1930
    int slevel, run, last;
1931
    
1932
    assert(MAX_LEVEL >= 64);
1933
    assert(MAX_RUN   >= 63);
1934

    
1935
    for(slevel=-64; slevel<64; slevel++){
1936
        if(slevel==0) continue;
1937
        for(run=0; run<64; run++){
1938
            for(last=0; last<=1; last++){
1939
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1940
                int level= slevel < 0 ? -slevel : slevel;
1941
                int sign= slevel < 0 ? 1 : 0;
1942
                int bits, len, code;
1943
                
1944
                len_tab[index]= 100;
1945
                     
1946
                /* ESC0 */
1947
                code= get_rl_index(rl, last, run, level);
1948
                bits= rl->table_vlc[code][0];
1949
                len=  rl->table_vlc[code][1];
1950
                bits=bits*2+sign; len++;
1951
                
1952
                if(code!=rl->n && len < len_tab[index]){
1953
                    if(bits_tab) bits_tab[index]= bits;
1954
                    len_tab [index]= len;
1955
                }
1956
                /* ESC */
1957
                bits= rl->table_vlc[rl->n][0];
1958
                len = rl->table_vlc[rl->n][1];
1959
                bits=bits*2+last; len++;
1960
                bits=bits*64+run; len+=6;
1961
                bits=bits*256+(level&0xff); len+=8;
1962
                
1963
                if(len < len_tab[index]){
1964
                    if(bits_tab) bits_tab[index]= bits;
1965
                    len_tab [index]= len;
1966
                }
1967
            }
1968
        }
1969
    }
1970
}
1971

    
1972
void h263_encode_init(MpegEncContext *s)
1973
{
1974
    static int done = 0;
1975

    
1976
    if (!done) {
1977
        done = 1;
1978

    
1979
        init_uni_dc_tab();
1980

    
1981
        init_rl(&rl_inter, 1);
1982
        init_rl(&rl_intra, 1);
1983
        init_rl(&rl_intra_aic, 1);
1984
        
1985
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1986
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1987

    
1988
        init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
1989
        init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
1990

    
1991
        init_mv_penalty_and_fcode(s);
1992
    }
1993
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1994
    
1995
    s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
1996
    s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
1997
    if(s->h263_aic){
1998
        s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
1999
        s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2000
    }
2001
    s->ac_esc_length= 7+1+6+8;
2002

    
2003
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2004
    switch(s->codec_id){
2005
    case CODEC_ID_MPEG4:
2006
        s->fcode_tab= fcode_tab;
2007
        s->min_qcoeff= -2048;
2008
        s->max_qcoeff=  2047;
2009
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
2010
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2011
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
2012
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2013
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
2014
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2015
        s->ac_esc_length= 7+2+1+6+1+12+1;
2016
        s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2017
        s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2018

    
2019
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2020

    
2021
            s->avctx->extradata= av_malloc(1024);
2022
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
2023
            
2024
            if(!(s->workaround_bugs & FF_BUG_MS))
2025
                mpeg4_encode_visual_object_header(s);
2026
            mpeg4_encode_vol_header(s, 0, 0);
2027

    
2028
//            ff_mpeg4_stuffing(&s->pb); ?
2029
            flush_put_bits(&s->pb);
2030
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2031
        }
2032
        
2033
        break;
2034
    case CODEC_ID_H263P:
2035
        if(s->umvplus)
2036
            s->fcode_tab= umv_fcode_tab;
2037
        if(s->modified_quant){
2038
            s->min_qcoeff= -2047;
2039
            s->max_qcoeff=  2047;
2040
        }else{
2041
            s->min_qcoeff= -127;
2042
            s->max_qcoeff=  127;
2043
        }
2044
        break;
2045
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
2046
    case CODEC_ID_FLV1:
2047
        if (s->h263_flv > 1) {
2048
            s->min_qcoeff= -1023;
2049
            s->max_qcoeff=  1023;
2050
        } else {
2051
            s->min_qcoeff= -127;
2052
            s->max_qcoeff=  127;
2053
        }
2054
        s->y_dc_scale_table=
2055
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2056
        break;
2057
    default: //nothing needed default table allready set in mpegvideo.c
2058
        s->min_qcoeff= -127;
2059
        s->max_qcoeff=  127;
2060
        s->y_dc_scale_table=
2061
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2062
    }
2063
}
2064

    
2065
/**
2066
 * encodes a 8x8 block.
2067
 * @param block the 8x8 block
2068
 * @param n block index (0-3 are luma, 4-5 are chroma)
2069
 */
2070
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2071
{
2072
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2073
    RLTable *rl;
2074

    
2075
    rl = &rl_inter;
2076
    if (s->mb_intra && !s->h263_aic) {
2077
        /* DC coef */
2078
        level = block[0];
2079
        /* 255 cannot be represented, so we clamp */
2080
        if (level > 254) {
2081
            level = 254;
2082
            block[0] = 254;
2083
        }
2084
        /* 0 cannot be represented also */
2085
        else if (level < 1) {
2086
            level = 1;
2087
            block[0] = 1;
2088
        }
2089
        if (level == 128) //FIXME check rv10
2090
            put_bits(&s->pb, 8, 0xff);
2091
        else
2092
            put_bits(&s->pb, 8, level);
2093
        i = 1;
2094
    } else {
2095
        i = 0;
2096
        if (s->h263_aic && s->mb_intra)
2097
            rl = &rl_intra_aic;
2098
            
2099
        if(s->alt_inter_vlc && !s->mb_intra){
2100
            int aic_vlc_bits=0;
2101
            int inter_vlc_bits=0;
2102
            int wrong_pos=-1;
2103
            int aic_code;
2104
            
2105
            last_index = s->block_last_index[n];
2106
            last_non_zero = i - 1;
2107
            for (; i <= last_index; i++) {
2108
                j = s->intra_scantable.permutated[i];
2109
                level = block[j];
2110
                if (level) {
2111
                    run = i - last_non_zero - 1;
2112
                    last = (i == last_index);
2113
                    
2114
                    if(level<0) level= -level;
2115
                
2116
                    code = get_rl_index(rl, last, run, level);
2117
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2118
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2119
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2120

    
2121
                    if (code == rl->n) {
2122
                        inter_vlc_bits += 1+6+8-1;
2123
                    }                
2124
                    if (aic_code == rl_intra_aic.n) {
2125
                        aic_vlc_bits += 1+6+8-1;
2126
                        wrong_pos += run + 1;
2127
                    }else
2128
                        wrong_pos += wrong_run[aic_code];
2129
                    last_non_zero = i;
2130
                }    
2131
            }
2132
            i = 0;
2133
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2134
                rl = &rl_intra_aic;
2135
        }
2136
    }
2137
   
2138
    /* AC coefs */
2139
    last_index = s->block_last_index[n];
2140
    last_non_zero = i - 1;
2141
    for (; i <= last_index; i++) {
2142
        j = s->intra_scantable.permutated[i];
2143
        level = block[j];
2144
        if (level) {
2145
            run = i - last_non_zero - 1;
2146
            last = (i == last_index);
2147
            sign = 0;
2148
            slevel = level;
2149
            if (level < 0) {
2150
                sign = 1;
2151
                level = -level;
2152
            }
2153
            code = get_rl_index(rl, last, run, level);
2154
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2155
            if (code == rl->n) {
2156
              if(s->h263_flv <= 1){
2157
                put_bits(&s->pb, 1, last);
2158
                put_bits(&s->pb, 6, run);
2159
                
2160
                assert(slevel != 0);
2161

    
2162
                if(level < 128) 
2163
                    put_bits(&s->pb, 8, slevel & 0xff);
2164
                else{
2165
                    put_bits(&s->pb, 8, 128);
2166
                    put_bits(&s->pb, 5, slevel & 0x1f);
2167
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2168
                }
2169
              }else{
2170
                if(level < 64) { // 7-bit level
2171
                        put_bits(&s->pb, 1, 0);
2172
                        put_bits(&s->pb, 1, last);
2173
                        put_bits(&s->pb, 6, run);
2174

    
2175
                        put_bits(&s->pb, 7, slevel & 0x7f);
2176
                    } else {
2177
                        /* 11-bit level */
2178
                        put_bits(&s->pb, 1, 1);
2179
                        put_bits(&s->pb, 1, last);
2180
                        put_bits(&s->pb, 6, run);
2181

    
2182
                        put_bits(&s->pb, 11, slevel & 0x7ff);
2183
                    }
2184
              }
2185
            } else {
2186
                put_bits(&s->pb, 1, sign);
2187
            }
2188
            last_non_zero = i;
2189
        }
2190
    }
2191
}
2192
#endif
2193

    
2194
#ifdef CONFIG_ENCODERS
2195

    
2196
/***************************************************/
2197
/**
2198
 * add mpeg4 stuffing bits (01...1)
2199
 */
2200
void ff_mpeg4_stuffing(PutBitContext * pbc)
2201
{
2202
    int length;
2203
    put_bits(pbc, 1, 0);
2204
    length= (-put_bits_count(pbc))&7;
2205
    if(length) put_bits(pbc, length, (1<<length)-1);
2206
}
2207

    
2208
/* must be called before writing the header */
2209
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2210
    int time_div, time_mod;
2211

    
2212
    assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2213
    s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2214

    
2215
    time_div= s->time/s->time_increment_resolution;
2216
    time_mod= s->time%s->time_increment_resolution;
2217

    
2218
    if(s->pict_type==B_TYPE){
2219
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2220
        assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2221
    }else{
2222
        s->last_time_base= s->time_base;
2223
        s->time_base= time_div;
2224
        s->pp_time= s->time - s->last_non_b_time;
2225
        s->last_non_b_time= s->time;
2226
        assert(picture_number==0 || s->pp_time > 0);
2227
    }
2228
}
2229

    
2230
static void mpeg4_encode_gop_header(MpegEncContext * s){
2231
    int hours, minutes, seconds;
2232
    int64_t time;
2233
    
2234
    put_bits(&s->pb, 16, 0);
2235
    put_bits(&s->pb, 16, GOP_STARTCODE);
2236
    
2237
    time= s->current_picture_ptr->pts;
2238
    if(s->reordered_input_picture[1])
2239
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2240
    time= (time*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2241

    
2242
    seconds= time/s->time_increment_resolution;
2243
    minutes= seconds/60; seconds %= 60;
2244
    hours= minutes/60; minutes %= 60;
2245
    hours%=24;
2246

    
2247
    put_bits(&s->pb, 5, hours);
2248
    put_bits(&s->pb, 6, minutes);
2249
    put_bits(&s->pb, 1, 1);
2250
    put_bits(&s->pb, 6, seconds);
2251
    
2252
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); 
2253
    put_bits(&s->pb, 1, 0); //broken link == NO
2254
    
2255
    s->last_time_base= time / s->time_increment_resolution; 
2256

    
2257
    ff_mpeg4_stuffing(&s->pb);
2258
}
2259

    
2260
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2261
    int profile_and_level_indication;
2262
    int vo_ver_id;
2263
    
2264
    if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2265
        profile_and_level_indication = s->avctx->profile << 4;
2266
    }else if(s->max_b_frames || s->quarter_sample){
2267
        profile_and_level_indication= 0xF0; // adv simple
2268
    }else{
2269
        profile_and_level_indication= 0x00; // simple
2270
    }
2271

    
2272
    if(s->avctx->level != FF_LEVEL_UNKNOWN){
2273
        profile_and_level_indication |= s->avctx->level;
2274
    }else{
2275
        profile_and_level_indication |= 1; //level 1
2276
    }
2277

    
2278
    if(profile_and_level_indication>>4 == 0xF){
2279
        vo_ver_id= 5;
2280
    }else{
2281
        vo_ver_id= 1;
2282
    }
2283

    
2284
    //FIXME levels
2285

    
2286
    put_bits(&s->pb, 16, 0);
2287
    put_bits(&s->pb, 16, VOS_STARTCODE);
2288

    
2289
    put_bits(&s->pb, 8, profile_and_level_indication);
2290

    
2291
    put_bits(&s->pb, 16, 0);
2292
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2293
    
2294
    put_bits(&s->pb, 1, 1);
2295
        put_bits(&s->pb, 4, vo_ver_id);
2296
        put_bits(&s->pb, 3, 1); //priority
2297
 
2298
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
2299
    
2300
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2301

    
2302
    ff_mpeg4_stuffing(&s->pb);
2303
}
2304

    
2305
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2306
{
2307
    int vo_ver_id;
2308

    
2309
    if(s->max_b_frames || s->quarter_sample){
2310
        vo_ver_id= 5;
2311
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2312
    }else{
2313
        vo_ver_id= 1;
2314
        s->vo_type= SIMPLE_VO_TYPE;
2315
    }
2316

    
2317
    put_bits(&s->pb, 16, 0);
2318
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2319
    put_bits(&s->pb, 16, 0);
2320
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2321

    
2322
    put_bits(&s->pb, 1, 0);                /* random access vol */
2323
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
2324
    if(s->workaround_bugs & FF_BUG_MS) {
2325
        put_bits(&s->pb, 1, 0);        /* is obj layer id= no */
2326
    } else {
2327
        put_bits(&s->pb, 1, 1);        /* is obj layer id= yes */
2328
        put_bits(&s->pb, 4, vo_ver_id);    /* is obj layer ver id */
2329
        put_bits(&s->pb, 3, 1);        /* is obj layer priority */
2330
    }
2331
    
2332
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2333

    
2334
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2335
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2336
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2337
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2338
    }
2339

    
2340
    if(s->workaround_bugs & FF_BUG_MS) { //
2341
        put_bits(&s->pb, 1, 0);        /* vol control parameters= no @@@ */
2342
    } else {
2343
        put_bits(&s->pb, 1, 1);        /* vol control parameters= yes */
2344
        put_bits(&s->pb, 2, 1);        /* chroma format YUV 420/YV12 */
2345
        put_bits(&s->pb, 1, s->low_delay);
2346
        put_bits(&s->pb, 1, 0);        /* vbv parameters= no */
2347
    }
2348

    
2349
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
2350
    put_bits(&s->pb, 1, 1);                /* marker bit */
2351
    
2352
    put_bits(&s->pb, 16, s->time_increment_resolution);
2353
    if (s->time_increment_bits < 1)
2354
        s->time_increment_bits = 1;
2355
    put_bits(&s->pb, 1, 1);                /* marker bit */
2356
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
2357
    put_bits(&s->pb, 1, 1);                /* marker bit */
2358
    put_bits(&s->pb, 13, s->width);        /* vol width */
2359
    put_bits(&s->pb, 1, 1);                /* marker bit */
2360
    put_bits(&s->pb, 13, s->height);        /* vol height */
2361
    put_bits(&s->pb, 1, 1);                /* marker bit */
2362
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2363
    put_bits(&s->pb, 1, 1);                /* obmc disable */
2364
    if (vo_ver_id == 1) {
2365
        put_bits(&s->pb, 1, s->vol_sprite_usage);                /* sprite enable */
2366
    }else{
2367
        put_bits(&s->pb, 2, s->vol_sprite_usage);                /* sprite enable */
2368
    }
2369
    
2370
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
2371
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
2372

    
2373
    if(s->mpeg_quant){
2374
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2375
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2376
    }
2377

    
2378
    if (vo_ver_id != 1)
2379
        put_bits(&s->pb, 1, s->quarter_sample);
2380
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
2381
    s->resync_marker= s->rtp_mode;
2382
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2383
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2384
    if(s->data_partitioning){
2385
        put_bits(&s->pb, 1, 0);                /* no rvlc */
2386
    }
2387

    
2388
    if (vo_ver_id != 1){
2389
        put_bits(&s->pb, 1, 0);                /* newpred */
2390
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
2391
    }
2392
    put_bits(&s->pb, 1, 0);                /* scalability */
2393
    
2394
    ff_mpeg4_stuffing(&s->pb);
2395

    
2396
    /* user data */
2397
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2398
        put_bits(&s->pb, 16, 0);
2399
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
2400
        put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2401
    }
2402
}
2403

    
2404
/* write mpeg4 VOP header */
2405
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2406
{
2407
    int time_incr;
2408
    int time_div, time_mod;
2409
    
2410
    if(s->pict_type==I_TYPE){
2411
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2412
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2413
                mpeg4_encode_visual_object_header(s);
2414
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2415
                mpeg4_encode_vol_header(s, 0, 0);
2416
        }
2417
        if(!(s->workaround_bugs & FF_BUG_MS))
2418
            mpeg4_encode_gop_header(s);
2419
    }
2420
    
2421
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2422

    
2423
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2424
    
2425
    put_bits(&s->pb, 16, 0);                /* vop header */
2426
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2427
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
2428

    
2429
    time_div= s->time/s->time_increment_resolution;
2430
    time_mod= s->time%s->time_increment_resolution;
2431
    time_incr= time_div - s->last_time_base;
2432
    assert(time_incr >= 0);
2433
    while(time_incr--)
2434
        put_bits(&s->pb, 1, 1);
2435
        
2436
    put_bits(&s->pb, 1, 0);
2437

    
2438
    put_bits(&s->pb, 1, 1);        /* marker */
2439
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
2440
    put_bits(&s->pb, 1, 1);        /* marker */
2441
    put_bits(&s->pb, 1, 1);        /* vop coded */
2442
    if (    s->pict_type == P_TYPE 
2443
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2444
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
2445
    }
2446
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
2447
    if(!s->progressive_sequence){
2448
         put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2449
         put_bits(&s->pb, 1, s->alternate_scan);
2450
    }
2451
    //FIXME sprite stuff
2452

    
2453
    put_bits(&s->pb, 5, s->qscale);
2454

    
2455
    if (s->pict_type != I_TYPE)
2456
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
2457
    if (s->pict_type == B_TYPE)
2458
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
2459
    //    printf("****frame %d\n", picture_number);
2460
}
2461

    
2462
#endif //CONFIG_ENCODERS
2463

    
2464
/**
2465
 * set qscale and update qscale dependant variables.
2466
 */
2467
void ff_set_qscale(MpegEncContext * s, int qscale)
2468
{
2469
    if (qscale < 1)
2470
        qscale = 1;
2471
    else if (qscale > 31)
2472
        qscale = 31;
2473
        
2474
    s->qscale = qscale;
2475
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2476

    
2477
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2478
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2479
}
2480

    
2481
/**
2482
 * predicts the dc.
2483
 * encoding quantized level -> quantized diff
2484
 * decoding quantized diff -> quantized level  
2485
 * @param n block index (0-3 are luma, 4-5 are chroma)
2486
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2487
 */
2488
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2489
{
2490
    int a, b, c, wrap, pred, scale, ret;
2491
    uint16_t *dc_val;
2492

    
2493
    /* find prediction */
2494
    if (n < 4) {
2495
        scale = s->y_dc_scale;
2496
    } else {
2497
        scale = s->c_dc_scale;
2498
    }
2499
    if(IS_3IV1)
2500
        scale= 8;
2501

    
2502
    wrap= s->block_wrap[n];
2503
    dc_val = s->dc_val[0] + s->block_index[n];
2504

    
2505
    /* B C
2506
     * A X 
2507
     */
2508
    a = dc_val[ - 1];
2509
    b = dc_val[ - 1 - wrap];
2510
    c = dc_val[ - wrap];
2511

    
2512
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2513
    if(s->first_slice_line && n!=3){
2514
        if(n!=2) b=c= 1024;
2515
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2516
    }
2517
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2518
        if(n==0 || n==4 || n==5)
2519
            b=1024;
2520
    }
2521

    
2522
    if (abs(a - b) < abs(b - c)) {
2523
        pred = c;
2524
        *dir_ptr = 1; /* top */
2525
    } else {
2526
        pred = a;
2527
        *dir_ptr = 0; /* left */
2528
    }
2529
    /* we assume pred is positive */
2530
    pred = FASTDIV((pred + (scale >> 1)), scale);
2531

    
2532
    if(encoding){
2533
        ret = level - pred;
2534
    }else{
2535
        level += pred;
2536
        ret= level;
2537
        if(s->error_resilience>=3){
2538
            if(level<0){
2539
                av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2540
                return -1;
2541
            }
2542
            if(level*scale > 2048 + scale){
2543
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2544
                return -1;
2545
            }
2546
        }
2547
    }
2548
    level *=scale;
2549
    if(level&(~2047)){
2550
        if(level<0) 
2551
            level=0;
2552
        else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2553
            level=2047;
2554
    }
2555
    dc_val[0]= level;
2556

    
2557
    return ret;
2558
}
2559

    
2560
/**
2561
 * predicts the ac.
2562
 * @param n block index (0-3 are luma, 4-5 are chroma)
2563
 * @param dir the ac prediction direction
2564
 */
2565
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2566
                   int dir)
2567
{
2568
    int i;
2569
    int16_t *ac_val, *ac_val1;
2570
    int8_t * const qscale_table= s->current_picture.qscale_table;
2571

    
2572
    /* find prediction */
2573
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2574
    ac_val1 = ac_val;
2575
    if (s->ac_pred) {
2576
        if (dir == 0) {
2577
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2578
            /* left prediction */
2579
            ac_val -= 16;
2580
            
2581
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2582
                /* same qscale */
2583
                for(i=1;i<8;i++) {
2584
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2585
                }
2586
            }else{
2587
                /* different qscale, we must rescale */
2588
                for(i=1;i<8;i++) {
2589
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2590
                }
2591
            }
2592
        } else {
2593
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2594
            /* top prediction */
2595
            ac_val -= 16 * s->block_wrap[n];
2596

    
2597
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2598
                /* same qscale */
2599
                for(i=1;i<8;i++) {
2600
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2601
                }
2602
            }else{
2603
                /* different qscale, we must rescale */
2604
                for(i=1;i<8;i++) {
2605
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2606
                }
2607
            }
2608
        }
2609
    }
2610
    /* left copy */
2611
    for(i=1;i<8;i++)
2612
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2613

    
2614
    /* top copy */
2615
    for(i=1;i<8;i++)
2616
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2617

    
2618
}
2619

    
2620
#ifdef CONFIG_ENCODERS
2621

    
2622
/**
2623
 * encodes the dc value.
2624
 * @param n block index (0-3 are luma, 4-5 are chroma)
2625
 */
2626
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2627
{
2628
#if 1
2629
//    if(level<-255 || level>255) printf("dc overflow\n");
2630
    level+=256;
2631
    if (n < 4) {
2632
        /* luminance */
2633
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2634
    } else {
2635
        /* chrominance */
2636
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2637
    }
2638
#else
2639
    int size, v;
2640
    /* find number of bits */
2641
    size = 0;
2642
    v = abs(level);
2643
    while (v) {
2644
        v >>= 1;
2645
        size++;
2646
    }
2647

    
2648
    if (n < 4) {
2649
        /* luminance */
2650
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2651
    } else {
2652
        /* chrominance */
2653
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2654
    }
2655

    
2656
    /* encode remaining bits */
2657
    if (size > 0) {
2658
        if (level < 0)
2659
            level = (-level) ^ ((1 << size) - 1);
2660
        put_bits(&s->pb, size, level);
2661
        if (size > 8)
2662
            put_bits(&s->pb, 1, 1);
2663
    }
2664
#endif
2665
}
2666

    
2667
static inline int mpeg4_get_dc_length(int level, int n){
2668
    if (n < 4) {
2669
        return uni_DCtab_lum_len[level + 256];
2670
    } else {
2671
        return uni_DCtab_chrom_len[level + 256];
2672
    }
2673
}
2674

    
2675
/**
2676
 * encodes a 8x8 block
2677
 * @param n block index (0-3 are luma, 4-5 are chroma)
2678
 */
2679
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2680
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2681
{
2682
    int i, last_non_zero;
2683
#if 0 //variables for the outcommented version
2684
    int code, sign, last;
2685
#endif
2686
    const RLTable *rl;
2687
    uint32_t *bits_tab;
2688
    uint8_t *len_tab;
2689
    const int last_index = s->block_last_index[n];
2690

    
2691
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2692
        /* mpeg4 based DC predictor */
2693
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2694
        if(last_index<1) return;
2695
        i = 1;
2696
        rl = &rl_intra;
2697
        bits_tab= uni_mpeg4_intra_rl_bits;
2698
        len_tab = uni_mpeg4_intra_rl_len;
2699
    } else {
2700
        if(last_index<0) return;
2701
        i = 0;
2702
        rl = &rl_inter;
2703
        bits_tab= uni_mpeg4_inter_rl_bits;
2704
        len_tab = uni_mpeg4_inter_rl_len;
2705
    }
2706

    
2707
    /* AC coefs */
2708
    last_non_zero = i - 1;
2709
#if 1
2710
    for (; i < last_index; i++) {
2711
        int level = block[ scan_table[i] ];
2712
        if (level) {
2713
            int run = i - last_non_zero - 1;
2714
            level+=64;
2715
            if((level&(~127)) == 0){
2716
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2717
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2718
            }else{ //ESC3
2719
                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);
2720
            }
2721
            last_non_zero = i;
2722
        }
2723
    }
2724
    /*if(i<=last_index)*/{
2725
        int level = block[ scan_table[i] ];
2726
        int run = i - last_non_zero - 1;
2727
        level+=64;
2728
        if((level&(~127)) == 0){
2729
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2730
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2731
        }else{ //ESC3
2732
            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);
2733
        }
2734
    }
2735
#else
2736
    for (; i <= last_index; i++) {
2737
        const int slevel = block[ scan_table[i] ];
2738
        if (slevel) {
2739
            int level;
2740
            int run = i - last_non_zero - 1;
2741
            last = (i == last_index);
2742
            sign = 0;
2743
            level = slevel;
2744
            if (level < 0) {
2745
                sign = 1;
2746
                level = -level;
2747
            }
2748
            code = get_rl_index(rl, last, run, level);
2749
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2750
            if (code == rl->n) {
2751
                int level1, run1;
2752
                level1 = level - rl->max_level[last][run];
2753
                if (level1 < 1) 
2754
                    goto esc2;
2755
                code = get_rl_index(rl, last, run, level1);
2756
                if (code == rl->n) {
2757
                esc2:
2758
                    put_bits(ac_pb, 1, 1);
2759
                    if (level > MAX_LEVEL)
2760
                        goto esc3;
2761
                    run1 = run - rl->max_run[last][level] - 1;
2762
                    if (run1 < 0)
2763
                        goto esc3;
2764
                    code = get_rl_index(rl, last, run1, level);
2765
                    if (code == rl->n) {
2766
                    esc3:
2767
                        /* third escape */
2768
                        put_bits(ac_pb, 1, 1);
2769
                        put_bits(ac_pb, 1, last);
2770
                        put_bits(ac_pb, 6, run);
2771
                        put_bits(ac_pb, 1, 1);
2772
                        put_bits(ac_pb, 12, slevel & 0xfff);
2773
                        put_bits(ac_pb, 1, 1);
2774
                    } else {
2775
                        /* second escape */
2776
                        put_bits(ac_pb, 1, 0);
2777
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2778
                        put_bits(ac_pb, 1, sign);
2779
                    }
2780
                } else {
2781
                    /* first escape */
2782
                    put_bits(ac_pb, 1, 0);
2783
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2784
                    put_bits(ac_pb, 1, sign);
2785
                }
2786
            } else {
2787
                put_bits(ac_pb, 1, sign);
2788
            }
2789
            last_non_zero = i;
2790
        }
2791
    }
2792
#endif
2793
}
2794

    
2795
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2796
                               uint8_t *scan_table)
2797
{
2798
    int i, last_non_zero;
2799
    const RLTable *rl;
2800
    uint8_t *len_tab;
2801
    const int last_index = s->block_last_index[n];
2802
    int len=0;
2803

    
2804
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2805
        /* mpeg4 based DC predictor */
2806
        len += mpeg4_get_dc_length(intra_dc, n);
2807
        if(last_index<1) return len;
2808
        i = 1;
2809
        rl = &rl_intra;
2810
        len_tab = uni_mpeg4_intra_rl_len;
2811
    } else {
2812
        if(last_index<0) return 0;
2813
        i = 0;
2814
        rl = &rl_inter;
2815
        len_tab = uni_mpeg4_inter_rl_len;
2816
    }
2817

    
2818
    /* AC coefs */
2819
    last_non_zero = i - 1;
2820
    for (; i < last_index; i++) {
2821
        int level = block[ scan_table[i] ];
2822
        if (level) {
2823
            int run = i - last_non_zero - 1;
2824
            level+=64;
2825
            if((level&(~127)) == 0){
2826
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2827
                len += len_tab[index];
2828
            }else{ //ESC3
2829
                len += 7+2+1+6+1+12+1;
2830
            }
2831
            last_non_zero = i;
2832
        }
2833
    }
2834
    /*if(i<=last_index)*/{
2835
        int level = block[ scan_table[i] ];
2836
        int run = i - last_non_zero - 1;
2837
        level+=64;
2838
        if((level&(~127)) == 0){
2839
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2840
            len += len_tab[index];
2841
        }else{ //ESC3
2842
            len += 7+2+1+6+1+12+1;
2843
        }
2844
    }
2845
    
2846
    return len;
2847
}
2848

    
2849
#endif
2850

    
2851

    
2852
/***********************************************/
2853
/* decoding */
2854

    
2855
static VLC intra_MCBPC_vlc;
2856
static VLC inter_MCBPC_vlc;
2857
static VLC cbpy_vlc;
2858
static VLC mv_vlc;
2859
static VLC dc_lum, dc_chrom;
2860
static VLC sprite_trajectory;
2861
static VLC mb_type_b_vlc;
2862
static VLC h263_mbtype_b_vlc;
2863
static VLC cbpc_b_vlc;
2864

    
2865
void init_vlc_rl(RLTable *rl, int use_static)
2866
{
2867
    int i, q;
2868
 
2869
    /* Return if static table is already initialized */
2870
    if(use_static && rl->rl_vlc[0])
2871
        return;    
2872

    
2873
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2874
             &rl->table_vlc[0][1], 4, 2,
2875
             &rl->table_vlc[0][0], 4, 2, use_static);
2876

    
2877
    
2878
    for(q=0; q<32; q++){
2879
        int qmul= q*2;
2880
        int qadd= (q-1)|1;
2881
        
2882
        if(q==0){
2883
            qmul=1;
2884
            qadd=0;
2885
        }
2886
        if(use_static)        
2887
            rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2888
        else
2889
            rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2890
        for(i=0; i<rl->vlc.table_size; i++){
2891
            int code= rl->vlc.table[i][0];
2892
            int len = rl->vlc.table[i][1];
2893
            int level, run;
2894
        
2895
            if(len==0){ // illegal code
2896
                run= 66;
2897
                level= MAX_LEVEL;
2898
            }else if(len<0){ //more bits needed
2899
                run= 0;
2900
                level= code;
2901
            }else{
2902
                if(code==rl->n){ //esc
2903
                    run= 66;
2904
                    level= 0;
2905
                }else{
2906
                    run=   rl->table_run  [code] + 1;
2907
                    level= rl->table_level[code] * qmul + qadd;
2908
                    if(code >= rl->last) run+=192;
2909
                }
2910
            }
2911
            rl->rl_vlc[q][i].len= len;
2912
            rl->rl_vlc[q][i].level= level;
2913
            rl->rl_vlc[q][i].run= run;
2914
        }
2915
    }
2916
}
2917

    
2918
/* init vlcs */
2919

    
2920
/* XXX: find a better solution to handle static init */
2921
void h263_decode_init_vlc(MpegEncContext *s)
2922
{
2923
    static int done = 0;
2924

    
2925
    if (!done) {
2926
        done = 1;
2927

    
2928
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, 
2929
                 intra_MCBPC_bits, 1, 1,
2930
                 intra_MCBPC_code, 1, 1, 1);
2931
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, 
2932
                 inter_MCBPC_bits, 1, 1,
2933
                 inter_MCBPC_code, 1, 1, 1);
2934
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2935
                 &cbpy_tab[0][1], 2, 1,
2936
                 &cbpy_tab[0][0], 2, 1, 1);
2937
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2938
                 &mvtab[0][1], 2, 1,
2939
                 &mvtab[0][0], 2, 1, 1);
2940
        init_rl(&rl_inter, 1);
2941
        init_rl(&rl_intra, 1);
2942
        init_rl(&rvlc_rl_inter, 1);
2943
        init_rl(&rvlc_rl_intra, 1);
2944
        init_rl(&rl_intra_aic, 1);
2945
        init_vlc_rl(&rl_inter, 1);
2946
        init_vlc_rl(&rl_intra, 1);
2947
        init_vlc_rl(&rvlc_rl_inter, 1);
2948
        init_vlc_rl(&rvlc_rl_intra, 1);
2949
        init_vlc_rl(&rl_intra_aic, 1);
2950
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2951
                 &DCtab_lum[0][1], 2, 1,
2952
                 &DCtab_lum[0][0], 2, 1, 1);
2953
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2954
                 &DCtab_chrom[0][1], 2, 1,
2955
                 &DCtab_chrom[0][0], 2, 1, 1);
2956
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2957
                 &sprite_trajectory_tab[0][1], 4, 2,
2958
                 &sprite_trajectory_tab[0][0], 4, 2, 1);
2959
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2960
                 &mb_type_b_tab[0][1], 2, 1,
2961
                 &mb_type_b_tab[0][0], 2, 1, 1);
2962
        init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2963
                 &h263_mbtype_b_tab[0][1], 2, 1,
2964
                 &h263_mbtype_b_tab[0][0], 2, 1, 1);
2965
        init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2966
                 &cbpc_b_tab[0][1], 2, 1,
2967
                 &cbpc_b_tab[0][0], 2, 1, 1);
2968
    }
2969
}
2970

    
2971
/**
2972
 * Get the GOB height based on picture height.
2973
 */
2974
int ff_h263_get_gob_height(MpegEncContext *s){
2975
    if (s->height <= 400)
2976
        return 1;
2977
    else if (s->height <= 800)
2978
        return  2;
2979
    else
2980
        return 4;
2981
}
2982

    
2983
int ff_h263_decode_mba(MpegEncContext *s)
2984
{
2985
    int i, mb_pos;
2986

    
2987
    for(i=0; i<6; i++){
2988
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2989
    }
2990
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2991
    s->mb_x= mb_pos % s->mb_width;
2992
    s->mb_y= mb_pos / s->mb_width;
2993

    
2994
    return mb_pos;
2995
}
2996

    
2997
void ff_h263_encode_mba(MpegEncContext *s)
2998
{
2999
    int i, mb_pos;
3000

    
3001
    for(i=0; i<6; i++){
3002
        if(s->mb_num-1 <= ff_mba_max[i]) break;
3003
    }
3004
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
3005
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
3006
}
3007

    
3008
/**
3009
 * decodes the group of blocks header or slice header.
3010
 * @return <0 if an error occured
3011
 */
3012
static int h263_decode_gob_header(MpegEncContext *s)
3013
{
3014
    unsigned int val, gfid, gob_number;
3015
    int left;
3016
    
3017
    /* Check for GOB Start Code */
3018
    val = show_bits(&s->gb, 16);
3019
    if(val)
3020
        return -1;
3021

    
3022
        /* We have a GBSC probably with GSTUFF */
3023
    skip_bits(&s->gb, 16); /* Drop the zeros */
3024
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3025
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3026
    for(;left>13; left--){
3027
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3028
    }
3029
    if(left<=13) 
3030
        return -1;
3031

    
3032
    if(s->h263_slice_structured){
3033
        if(get_bits1(&s->gb)==0)
3034
            return -1;
3035

    
3036
        ff_h263_decode_mba(s);
3037

    
3038
        if(s->mb_num > 1583)
3039
            if(get_bits1(&s->gb)==0)
3040
                return -1;
3041
        
3042
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3043
        if(get_bits1(&s->gb)==0)
3044
            return -1;
3045
        gfid = get_bits(&s->gb, 2); /* GFID */
3046
    }else{
3047
        gob_number = get_bits(&s->gb, 5); /* GN */
3048
        s->mb_x= 0;
3049
        s->mb_y= s->gob_index* gob_number;
3050
        gfid = get_bits(&s->gb, 2); /* GFID */
3051
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3052
    }
3053
        
3054
    if(s->mb_y >= s->mb_height) 
3055
        return -1;
3056

    
3057
    if(s->qscale==0) 
3058
        return -1;
3059

    
3060
    return 0;
3061
}
3062

    
3063
static inline void memsetw(short *tab, int val, int n)
3064
{
3065
    int i;
3066
    for(i=0;i<n;i++)
3067
        tab[i] = val;
3068
}
3069

    
3070
#ifdef CONFIG_ENCODERS
3071

    
3072
void ff_mpeg4_init_partitions(MpegEncContext *s)
3073
{
3074
    uint8_t *start= pbBufPtr(&s->pb);
3075
    uint8_t *end= s->pb.buf_end;
3076
    int size= end - start;
3077
    int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3078
    int tex_size= (size - 2*pb_size)&(~3);
3079
    
3080
    set_put_bits_buffer_size(&s->pb, pb_size);
3081
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3082
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3083
}
3084

    
3085
void ff_mpeg4_merge_partitions(MpegEncContext *s)
3086
{
3087
    const int pb2_len   = put_bits_count(&s->pb2   );
3088
    const int tex_pb_len= put_bits_count(&s->tex_pb);
3089
    const int bits= put_bits_count(&s->pb);
3090

    
3091
    if(s->pict_type==I_TYPE){
3092
        put_bits(&s->pb, 19, DC_MARKER);
3093
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3094
        s->i_tex_bits+= tex_pb_len;
3095
    }else{
3096
        put_bits(&s->pb, 17, MOTION_MARKER);
3097
        s->misc_bits+=17 + pb2_len;
3098
        s->mv_bits+= bits - s->last_bits;
3099
        s->p_tex_bits+= tex_pb_len;
3100
    }
3101

    
3102
    flush_put_bits(&s->pb2);
3103
    flush_put_bits(&s->tex_pb);
3104

    
3105
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3106
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3107
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3108
    s->last_bits= put_bits_count(&s->pb);
3109
}
3110

    
3111
#endif //CONFIG_ENCODERS
3112

    
3113
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3114
    switch(s->pict_type){
3115
        case I_TYPE:
3116
            return 16;
3117
        case P_TYPE:
3118
        case S_TYPE:
3119
            return s->f_code+15;
3120
        case B_TYPE:
3121
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3122
        default:
3123
            return -1;
3124
    }
3125
}
3126

    
3127
#ifdef CONFIG_ENCODERS
3128

    
3129
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3130
{
3131
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3132

    
3133
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3134
    put_bits(&s->pb, 1, 1);
3135
    
3136
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3137
    put_bits(&s->pb, s->quant_precision, s->qscale);
3138
    put_bits(&s->pb, 1, 0); /* no HEC */
3139
}
3140

    
3141
#endif //CONFIG_ENCODERS
3142

    
3143
/**
3144
 * check if the next stuff is a resync marker or the end.
3145
 * @return 0 if not
3146
 */
3147
static inline int mpeg4_is_resync(MpegEncContext *s){
3148
    const int bits_count= get_bits_count(&s->gb);
3149
    
3150
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3151
        return 0;
3152
    }
3153

    
3154
    if(bits_count + 8 >= s->gb.size_in_bits){
3155
        int v= show_bits(&s->gb, 8);
3156
        v|= 0x7F >> (7-(bits_count&7));
3157
                
3158
        if(v==0x7F)
3159
            return 1;
3160
    }else{
3161
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3162
            int len;
3163
            GetBitContext gb= s->gb;
3164
        
3165
            skip_bits(&s->gb, 1);
3166
            align_get_bits(&s->gb);
3167
        
3168
            for(len=0; len<32; len++){
3169
                if(get_bits1(&s->gb)) break;
3170
            }
3171

    
3172
            s->gb= gb;
3173

    
3174
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3175
                return 1;
3176
        }
3177
    }
3178
    return 0;
3179
}
3180

    
3181
/**
3182
 * decodes the next video packet.
3183
 * @return <0 if something went wrong
3184
 */
3185
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3186
{
3187
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3188
    int header_extension=0, mb_num, len;
3189
    
3190
    /* is there enough space left for a video packet + header */
3191
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3192

    
3193
    for(len=0; len<32; len++){
3194
        if(get_bits1(&s->gb)) break;
3195
    }
3196

    
3197
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3198
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3199
        return -1;
3200
    }
3201
    
3202
    if(s->shape != RECT_SHAPE){
3203
        header_extension= get_bits1(&s->gb);
3204
        //FIXME more stuff here
3205
    }
3206

    
3207
    mb_num= get_bits(&s->gb, mb_num_bits);
3208
    if(mb_num>=s->mb_num){
3209
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3210
        return -1;
3211
    }
3212
    if(s->pict_type == B_TYPE){
3213
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3214
        if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
3215
    }
3216
    
3217
    s->mb_x= mb_num % s->mb_width;
3218
    s->mb_y= mb_num / s->mb_width;
3219

    
3220
    if(s->shape != BIN_ONLY_SHAPE){
3221
        int qscale= get_bits(&s->gb, s->quant_precision); 
3222
        if(qscale)
3223
            s->chroma_qscale=s->qscale= qscale;
3224
    }
3225

    
3226
    if(s->shape == RECT_SHAPE){
3227
        header_extension= get_bits1(&s->gb);
3228
    }
3229
    if(header_extension){
3230
        int time_increment;
3231
        int time_incr=0;
3232

    
3233
        while (get_bits1(&s->gb) != 0) 
3234
            time_incr++;
3235

    
3236
        check_marker(&s->gb, "before time_increment in video packed header");
3237
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3238
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3239
        
3240
        skip_bits(&s->gb, 2); /* vop coding type */
3241
        //FIXME not rect stuff here
3242

    
3243
        if(s->shape != BIN_ONLY_SHAPE){
3244
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3245
//FIXME dont just ignore everything
3246
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3247
                mpeg4_decode_sprite_trajectory(s, &s->gb);
3248
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3249
            }
3250

    
3251
            //FIXME reduced res stuff here
3252
            
3253
            if (s->pict_type != I_TYPE) {
3254
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
3255
                if(f_code==0){
3256
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3257
                }
3258
            }
3259
            if (s->pict_type == B_TYPE) {
3260
                int b_code = get_bits(&s->gb, 3);
3261
                if(b_code==0){
3262
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3263
                }
3264
            }       
3265
        }
3266
    }
3267
    //FIXME new-pred stuff
3268
    
3269
//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));
3270

    
3271
    return 0;
3272
}
3273

    
3274
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3275
{
3276
    int c_wrap, c_xy, l_wrap, l_xy;
3277

    
3278
    l_wrap= s->b8_stride;
3279
    l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3280
    c_wrap= s->mb_stride;
3281
    c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3282

    
3283
#if 0
3284
    /* clean DC */
3285
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3286
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3287
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3288
#endif
3289

    
3290
    /* clean AC */
3291
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3292
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3293
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3294

    
3295
    /* clean MV */
3296
    // we cant clear the MVs as they might be needed by a b frame
3297
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3298
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3299
    s->last_mv[0][0][0]=
3300
    s->last_mv[0][0][1]=
3301
    s->last_mv[1][0][0]=
3302
    s->last_mv[1][0][1]= 0;
3303
}
3304

    
3305
/**
3306
 * decodes the group of blocks / video packet header.
3307
 * @return <0 if no resync found
3308
 */
3309
int ff_h263_resync(MpegEncContext *s){
3310
    int left, ret;
3311
    
3312
    if(s->codec_id==CODEC_ID_MPEG4){
3313
        skip_bits1(&s->gb);
3314
        align_get_bits(&s->gb);
3315
    }
3316

    
3317
    if(show_bits(&s->gb, 16)==0){
3318
        if(s->codec_id==CODEC_ID_MPEG4)
3319
            ret= mpeg4_decode_video_packet_header(s);
3320
        else
3321
            ret= h263_decode_gob_header(s);
3322
        if(ret>=0)
3323
            return 0;
3324
    }
3325
    //ok, its not where its supposed to be ...
3326
    s->gb= s->last_resync_gb;
3327
    align_get_bits(&s->gb);
3328
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3329
    
3330
    for(;left>16+1+5+5; left-=8){ 
3331
        if(show_bits(&s->gb, 16)==0){
3332
            GetBitContext bak= s->gb;
3333

    
3334
            if(s->codec_id==CODEC_ID_MPEG4)
3335
                ret= mpeg4_decode_video_packet_header(s);
3336
            else
3337
                ret= h263_decode_gob_header(s);
3338
            if(ret>=0)
3339
                return 0;
3340

    
3341
            s->gb= bak;
3342
        }
3343
        skip_bits(&s->gb, 8);
3344
    }
3345
    
3346
    return -1;
3347
}
3348

    
3349
/**
3350
 * gets the average motion vector for a GMC MB.
3351
 * @param n either 0 for the x component or 1 for y
3352
 * @returns the average MV for a GMC MB
3353
 */
3354
static inline int get_amv(MpegEncContext *s, int n){
3355
    int x, y, mb_v, sum, dx, dy, shift;
3356
    int len = 1 << (s->f_code + 4);
3357
    const int a= s->sprite_warping_accuracy;
3358
    
3359
    if(s->workaround_bugs & FF_BUG_AMV)
3360
        len >>= s->quarter_sample;
3361

    
3362
    if(s->real_sprite_warping_points==1){
3363
        if(s->divx_version==500 && s->divx_build==413)
3364
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3365
        else
3366
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3367
    }else{
3368
        dx= s->sprite_delta[n][0];
3369
        dy= s->sprite_delta[n][1];
3370
        shift= s->sprite_shift[0];
3371
        if(n) dy -= 1<<(shift + a + 1);
3372
        else  dx -= 1<<(shift + a + 1);
3373
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3374

    
3375
        sum=0;
3376
        for(y=0; y<16; y++){
3377
            int v;
3378
        
3379
            v= mb_v + dy*y;
3380
            //XXX FIXME optimize
3381
            for(x=0; x<16; x++){
3382
                sum+= v>>shift;
3383
                v+= dx;
3384
            }
3385
        }
3386
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3387
    }
3388

    
3389
    if      (sum < -len) sum= -len;
3390
    else if (sum >= len) sum= len-1;
3391

    
3392
    return sum;
3393
}
3394

    
3395
/**
3396
 * decodes first partition.
3397
 * @return number of MBs decoded or <0 if an error occured
3398
 */
3399
static int mpeg4_decode_partition_a(MpegEncContext *s){
3400
    int mb_num;
3401
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3402
    
3403
    /* decode first partition */
3404
    mb_num=0;
3405
    s->first_slice_line=1;
3406
    for(; s->mb_y<s->mb_height; s->mb_y++){
3407
        ff_init_block_index(s);
3408
        for(; s->mb_x<s->mb_width; s->mb_x++){
3409
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3410
            int cbpc;
3411
            int dir=0;
3412
            
3413
            mb_num++;
3414
            ff_update_block_index(s);
3415
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3416
                s->first_slice_line=0;
3417
            
3418
            if(s->pict_type==I_TYPE){
3419
                int i;
3420

    
3421
                do{
3422
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3423
                        return mb_num-1;
3424
                    }
3425

    
3426
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3427
                    if (cbpc < 0){
3428
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3429
                        return -1;
3430
                    }
3431
                }while(cbpc == 8);
3432
                
3433
                s->cbp_table[xy]= cbpc & 3;
3434
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3435
                s->mb_intra = 1;
3436

    
3437
                if(cbpc & 4) {
3438
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3439
                }
3440
                s->current_picture.qscale_table[xy]= s->qscale;
3441

    
3442
                s->mbintra_table[xy]= 1;
3443
                for(i=0; i<6; i++){
3444
                    int dc_pred_dir;
3445
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3446
                    if(dc < 0){
3447
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3448
                        return -1;
3449
                    }
3450
                    dir<<=1;
3451
                    if(dc_pred_dir) dir|=1;
3452
                }
3453
                s->pred_dir_table[xy]= dir;
3454
            }else{ /* P/S_TYPE */
3455
                int mx, my, pred_x, pred_y, bits;
3456
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3457
                const int stride= s->b8_stride*2;
3458

    
3459
try_again:
3460
                bits= show_bits(&s->gb, 17);
3461
                if(bits==MOTION_MARKER){
3462
                    return mb_num-1;
3463
                }
3464
                skip_bits1(&s->gb);
3465
                if(bits&0x10000){
3466
                    /* skip mb */
3467
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3468
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3469
                        mx= get_amv(s, 0);
3470
                        my= get_amv(s, 1);
3471
                    }else{
3472
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3473
                        mx=my=0;
3474
                    }
3475
                    mot_val[0       ]= mot_val[2       ]=
3476
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3477
                    mot_val[1       ]= mot_val[3       ]=
3478
                    mot_val[1+stride]= mot_val[3+stride]= my;
3479

    
3480
                    if(s->mbintra_table[xy])
3481
                        ff_clean_intra_table_entries(s);
3482
                    continue;
3483
                }
3484

    
3485
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3486
                if (cbpc < 0){
3487
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3488
                    return -1;
3489
                }
3490
                if(cbpc == 20)
3491
                    goto try_again;
3492

    
3493
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3494
    
3495
                s->mb_intra = ((cbpc & 4) != 0);
3496
        
3497
                if(s->mb_intra){
3498
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3499
                    s->mbintra_table[xy]= 1;
3500
                    mot_val[0       ]= mot_val[2       ]= 
3501
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3502
                    mot_val[1       ]= mot_val[3       ]=
3503
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3504
                }else{
3505
                    if(s->mbintra_table[xy])
3506
                        ff_clean_intra_table_entries(s);
3507

    
3508
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3509
                        s->mcsel= get_bits1(&s->gb);
3510
                    else s->mcsel= 0;
3511
        
3512
                    if ((cbpc & 16) == 0) {
3513
                        /* 16x16 motion prediction */
3514

    
3515
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3516
                        if(!s->mcsel){
3517
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3518
                            if (mx >= 0xffff)
3519
                                return -1;
3520

    
3521
                            my = h263_decode_motion(s, pred_y, s->f_code);
3522
                            if (my >= 0xffff)
3523
                                return -1;
3524
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3525
                        } else {
3526
                            mx = get_amv(s, 0);
3527
                            my = get_amv(s, 1);
3528
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3529
                        }
3530

    
3531
                        mot_val[0       ]= mot_val[2       ] =
3532
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3533
                        mot_val[1       ]= mot_val[3       ]=
3534
                        mot_val[1+stride]= mot_val[3+stride]= my;
3535
                    } else {
3536
                        int i;
3537
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3538
                        for(i=0;i<4;i++) {
3539
                            int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3540
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3541
                            if (mx >= 0xffff)
3542
                                return -1;
3543
                
3544
                            my = h263_decode_motion(s, pred_y, s->f_code);
3545
                            if (my >= 0xffff)
3546
                                return -1;
3547
                            mot_val[0] = mx;
3548
                            mot_val[1] = my;
3549
                        }
3550
                    }
3551
                }
3552
            }
3553
        }
3554
        s->mb_x= 0;
3555
    }
3556

    
3557
    return mb_num;
3558
}
3559

    
3560
/**
3561
 * decode second partition.
3562
 * @return <0 if an error occured
3563
 */
3564
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3565
    int mb_num=0;
3566
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3567

    
3568
    s->mb_x= s->resync_mb_x;
3569
    s->first_slice_line=1;
3570
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3571
        ff_init_block_index(s);
3572
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3573
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3574

    
3575
            mb_num++;
3576
            ff_update_block_index(s);
3577
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3578
                s->first_slice_line=0;
3579
            
3580
            if(s->pict_type==I_TYPE){
3581
                int ac_pred= get_bits1(&s->gb);
3582
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3583
                if(cbpy<0){
3584
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3585
                    return -1;
3586
                }
3587
                
3588
                s->cbp_table[xy]|= cbpy<<2;
3589
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3590
            }else{ /* P || S_TYPE */
3591
                if(IS_INTRA(s->current_picture.mb_type[xy])){          
3592
                    int dir=0,i;
3593
                    int ac_pred = get_bits1(&s->gb);
3594
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3595

    
3596
                    if(cbpy<0){
3597
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3598
                        return -1;
3599
                    }
3600
                    
3601
                    if(s->cbp_table[xy] & 8) {
3602
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3603
                    }
3604
                    s->current_picture.qscale_table[xy]= s->qscale;
3605

    
3606
                    for(i=0; i<6; i++){
3607
                        int dc_pred_dir;
3608
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3609
                        if(dc < 0){
3610
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3611
                            return -1;
3612
                        }
3613
                        dir<<=1;
3614
                        if(dc_pred_dir) dir|=1;
3615
                    }
3616
                    s->cbp_table[xy]&= 3; //remove dquant
3617
                    s->cbp_table[xy]|= cbpy<<2;
3618
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3619
                    s->pred_dir_table[xy]= dir;
3620
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3621
                    s->current_picture.qscale_table[xy]= s->qscale;
3622
                    s->cbp_table[xy]= 0;
3623
                }else{
3624
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3625

    
3626
                    if(cbpy<0){
3627
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3628
                        return -1;
3629
                    }
3630
                    
3631
                    if(s->cbp_table[xy] & 8) {
3632
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3633
                    }
3634
                    s->current_picture.qscale_table[xy]= s->qscale;
3635

    
3636
                    s->cbp_table[xy]&= 3; //remove dquant
3637
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3638
                }
3639
            }
3640
        }
3641
        if(mb_num >= mb_count) return 0;
3642
        s->mb_x= 0;
3643
    }
3644
    return 0;
3645
}
3646

    
3647
/**
3648
 * decodes the first & second partition
3649
 * @return <0 if error (and sets error type in the error_status_table)
3650
 */
3651
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3652
{
3653
    int mb_num;
3654
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3655
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3656
    
3657
    mb_num= mpeg4_decode_partition_a(s);    
3658
    if(mb_num<0){
3659
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3660
        return -1;
3661
    }
3662
    
3663
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3664
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3665
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3666
        return -1;
3667
    }
3668

    
3669
    s->mb_num_left= mb_num;
3670
        
3671
    if(s->pict_type==I_TYPE){
3672
        while(show_bits(&s->gb, 9) == 1)
3673
            skip_bits(&s->gb, 9);
3674
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3675
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3676
            return -1;
3677
        }
3678
    }else{
3679
        while(show_bits(&s->gb, 10) == 1)
3680
            skip_bits(&s->gb, 10);
3681
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3682
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3683
            return -1;
3684
        }
3685
    }
3686
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3687
    
3688
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3689
        if(s->pict_type==P_TYPE)
3690
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3691
        return -1;
3692
    }else{
3693
        if(s->pict_type==P_TYPE)
3694
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3695
    }
3696

    
3697
    return 0;        
3698
}
3699

    
3700
/**
3701
 * decode partition C of one MB.
3702
 * @return <0 if an error occured
3703
 */
3704
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3705
{
3706
    int cbp, mb_type;
3707
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3708

    
3709
    mb_type= s->current_picture.mb_type[xy];
3710
    cbp = s->cbp_table[xy];
3711

    
3712
    if(s->current_picture.qscale_table[xy] != s->qscale){
3713
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3714
    }
3715
    
3716
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3717
        int i;
3718
        for(i=0; i<4; i++){
3719
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3720
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3721
        }
3722
        s->mb_intra = IS_INTRA(mb_type);
3723

    
3724
        if (IS_SKIP(mb_type)) {
3725
            /* skip mb */
3726
            for(i=0;i<6;i++)
3727
                s->block_last_index[i] = -1;
3728
            s->mv_dir = MV_DIR_FORWARD;
3729
            s->mv_type = MV_TYPE_16X16;
3730
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3731
                s->mcsel=1;
3732
                s->mb_skiped = 0;
3733
            }else{
3734
                s->mcsel=0;
3735
                s->mb_skiped = 1;
3736
            }
3737
        }else if(s->mb_intra){
3738
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3739
        }else if(!s->mb_intra){
3740
//            s->mcsel= 0; //FIXME do we need to init that
3741
            
3742
            s->mv_dir = MV_DIR_FORWARD;
3743
            if (IS_8X8(mb_type)) {
3744
                s->mv_type = MV_TYPE_8X8;
3745
            } else {
3746
                s->mv_type = MV_TYPE_16X16;
3747
            }
3748
        }
3749
    } else { /* I-Frame */
3750
        s->mb_intra = 1;
3751
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3752
    }
3753

    
3754
    if (!IS_SKIP(mb_type)) {
3755
        int i;
3756
        /* decode each block */
3757
        for (i = 0; i < 6; i++) {
3758
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3759
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3760
                return -1;
3761
            }
3762
            cbp+=cbp;
3763
        }
3764
    }
3765

    
3766
    /* per-MB end of slice check */
3767

    
3768
    if(--s->mb_num_left <= 0){
3769
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3770
        if(mpeg4_is_resync(s))
3771
            return SLICE_END;
3772
        else
3773
            return SLICE_NOEND;     
3774
    }else{
3775
        if(mpeg4_is_resync(s)){
3776
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3777
            if(s->cbp_table[xy+delta])
3778
                return SLICE_END;
3779
        }
3780
        return SLICE_OK;
3781
    }
3782
}
3783

    
3784
/**
3785
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3786
 */
3787
static void preview_obmc(MpegEncContext *s){
3788
    GetBitContext gb= s->gb;
3789
    
3790
    int cbpc, i, pred_x, pred_y, mx, my;
3791
    int16_t *mot_val;
3792
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3793
    const int stride= s->b8_stride*2;
3794
    
3795
    for(i=0; i<4; i++)
3796
        s->block_index[i]+= 2;
3797
    for(i=4; i<6; i++)
3798
        s->block_index[i]+= 1;
3799
    s->mb_x++;
3800
    
3801
    assert(s->pict_type == P_TYPE);
3802

    
3803
    do{
3804
        if (get_bits1(&s->gb)) {
3805
            /* skip mb */
3806
            mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3807
            mot_val[0       ]= mot_val[2       ]= 
3808
            mot_val[0+stride]= mot_val[2+stride]= 0;
3809
            mot_val[1       ]= mot_val[3       ]=
3810
            mot_val[1+stride]= mot_val[3+stride]= 0;
3811
            
3812
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3813
            goto end;
3814
        }
3815
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3816
    }while(cbpc == 20);
3817
    
3818
    if(cbpc & 4){
3819
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3820
    }else{
3821
        get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3822
        if (cbpc & 8) {
3823
            if(s->modified_quant){
3824
                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3825
                else                  skip_bits(&s->gb, 5);
3826
            }else
3827
                skip_bits(&s->gb, 2);
3828
        }
3829
        
3830
        if ((cbpc & 16) == 0) {
3831
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
3832
                /* 16x16 motion prediction */
3833
                mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3834
                if (s->umvplus)
3835
                   mx = h263p_decode_umotion(s, pred_x);
3836
                else
3837
                   mx = h263_decode_motion(s, pred_x, 1);
3838
            
3839
                if (s->umvplus)
3840
                   my = h263p_decode_umotion(s, pred_y);
3841
                else
3842
                   my = h263_decode_motion(s, pred_y, 1);
3843
            
3844
                mot_val[0       ]= mot_val[2       ]= 
3845
                mot_val[0+stride]= mot_val[2+stride]= mx;
3846
                mot_val[1       ]= mot_val[3       ]=
3847
                mot_val[1+stride]= mot_val[3+stride]= my;
3848
        } else {
3849
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3850
            for(i=0;i<4;i++) {
3851
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3852
                if (s->umvplus)
3853
                  mx = h263p_decode_umotion(s, pred_x);
3854
                else
3855
                  mx = h263_decode_motion(s, pred_x, 1);
3856
                
3857
                if (s->umvplus)
3858
                  my = h263p_decode_umotion(s, pred_y);
3859
                else    
3860
                  my = h263_decode_motion(s, pred_y, 1);
3861
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3862
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3863
                mot_val[0] = mx;
3864
                mot_val[1] = my;
3865
            }
3866
        }
3867
    }
3868
end:
3869
        
3870
    for(i=0; i<4; i++)
3871
        s->block_index[i]-= 2;
3872
    for(i=4; i<6; i++)
3873
        s->block_index[i]-= 1;
3874
    s->mb_x--;
3875

    
3876
    s->gb= gb;
3877
}
3878

    
3879
static void h263_decode_dquant(MpegEncContext *s){
3880
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3881

    
3882
    if(s->modified_quant){
3883
        if(get_bits1(&s->gb))
3884
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3885
        else
3886
            s->qscale= get_bits(&s->gb, 5);
3887
    }else
3888
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3889
    ff_set_qscale(s, s->qscale);
3890
}
3891

    
3892
int ff_h263_decode_mb(MpegEncContext *s,
3893
                      DCTELEM block[6][64])
3894
{
3895
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3896
    int16_t *mot_val;
3897
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3898
    
3899
    assert(!s->h263_pred);
3900
    
3901
    if (s->pict_type == P_TYPE) {
3902
        do{
3903
            if (get_bits1(&s->gb)) {
3904
                /* skip mb */
3905
                s->mb_intra = 0;
3906
                for(i=0;i<6;i++)
3907
                    s->block_last_index[i] = -1;
3908
                s->mv_dir = MV_DIR_FORWARD;
3909
                s->mv_type = MV_TYPE_16X16;
3910
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3911
                s->mv[0][0][0] = 0;
3912
                s->mv[0][0][1] = 0;
3913
                s->mb_skiped = !(s->obmc | s->loop_filter);
3914
                goto end;
3915
            }
3916
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3917
            //fprintf(stderr, "\tCBPC: %d", cbpc);
3918
            if (cbpc < 0){
3919
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3920
                return -1;
3921
            }
3922
        }while(cbpc == 20);
3923
        
3924
        dquant = cbpc & 8;
3925
        s->mb_intra = ((cbpc & 4) != 0);
3926
        if (s->mb_intra) goto intra;
3927
        
3928
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3929
        
3930
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3931
            cbpy ^= 0xF;
3932
        
3933
        cbp = (cbpc & 3) | (cbpy << 2);
3934
        if (dquant) {
3935
            h263_decode_dquant(s);
3936
        }
3937
        
3938
        s->mv_dir = MV_DIR_FORWARD;
3939
        if ((cbpc & 16) == 0) {
3940
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
3941
            /* 16x16 motion prediction */
3942
            s->mv_type = MV_TYPE_16X16;
3943
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3944
            if (s->umvplus)
3945
               mx = h263p_decode_umotion(s, pred_x);
3946
            else
3947
               mx = h263_decode_motion(s, pred_x, 1);
3948
            
3949
            if (mx >= 0xffff)
3950
                return -1;
3951
            
3952
            if (s->umvplus)
3953
               my = h263p_decode_umotion(s, pred_y);
3954
            else
3955
               my = h263_decode_motion(s, pred_y, 1);
3956
            
3957
            if (my >= 0xffff)
3958
                return -1;
3959
            s->mv[0][0][0] = mx;
3960
            s->mv[0][0][1] = my;
3961

    
3962
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3963
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3964
        } else {
3965
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3966
            s->mv_type = MV_TYPE_8X8;
3967
            for(i=0;i<4;i++) {
3968
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3969
                if (s->umvplus)
3970
                  mx = h263p_decode_umotion(s, pred_x);
3971
                else
3972
                  mx = h263_decode_motion(s, pred_x, 1);
3973
                if (mx >= 0xffff)
3974
                    return -1;
3975
                
3976
                if (s->umvplus)
3977
                  my = h263p_decode_umotion(s, pred_y);
3978
                else    
3979
                  my = h263_decode_motion(s, pred_y, 1);
3980
                if (my >= 0xffff)
3981
                    return -1;
3982
                s->mv[0][i][0] = mx;
3983
                s->mv[0][i][1] = my;
3984
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3985
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3986
                mot_val[0] = mx;
3987
                mot_val[1] = my;
3988
            }
3989
        }
3990

    
3991
        /* decode each block */
3992
        for (i = 0; i < 6; i++) {
3993
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3994
                return -1;
3995
            cbp+=cbp;
3996
        }
3997

    
3998
        if(s->obmc){
3999
            if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4000
                preview_obmc(s);
4001
        }
4002
    } else if(s->pict_type==B_TYPE) {
4003
        int mb_type;
4004
        const int stride= s->b8_stride;
4005
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4006
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4007
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4008

    
4009
        //FIXME ugly 
4010
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 
4011
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 
4012
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 
4013
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4014

    
4015
        do{
4016
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4017
            if (mb_type < 0){
4018
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4019
                return -1;
4020
            }
4021

    
4022
            mb_type= h263_mb_type_b_map[ mb_type ];
4023
        }while(!mb_type);
4024

    
4025
        s->mb_intra = IS_INTRA(mb_type);
4026
        if(HAS_CBP(mb_type)){
4027
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4028
            if(s->mb_intra){
4029
                dquant = IS_QUANT(mb_type);
4030
                goto intra;
4031
            }
4032

    
4033
            cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4034

    
4035
            if (cbpy < 0){
4036
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4037
                return -1;
4038
            }
4039
        
4040
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4041
                cbpy ^= 0xF;
4042
        
4043
            cbp = (cbpc & 3) | (cbpy << 2);
4044
        }else
4045
            cbp=0;
4046
            
4047
        assert(!s->mb_intra);
4048

    
4049
        if(IS_QUANT(mb_type)){
4050
            h263_decode_dquant(s);
4051
        }
4052

    
4053
        if(IS_DIRECT(mb_type)){
4054
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4055
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4056
        }else{
4057
            s->mv_dir = 0;
4058
            s->mv_type= MV_TYPE_16X16;
4059
//FIXME UMV
4060

    
4061
            if(USES_LIST(mb_type, 0)){
4062
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4063
                s->mv_dir = MV_DIR_FORWARD;
4064

    
4065
                mx = h263_decode_motion(s, mx, 1);
4066
                my = h263_decode_motion(s, my, 1);
4067
                
4068
                s->mv[0][0][0] = mx;
4069
                s->mv[0][0][1] = my;
4070
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4071
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4072
            }
4073
    
4074
            if(USES_LIST(mb_type, 1)){
4075
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4076
                s->mv_dir |= MV_DIR_BACKWARD;
4077
                
4078
                mx = h263_decode_motion(s, mx, 1);
4079
                my = h263_decode_motion(s, my, 1);
4080

    
4081
                s->mv[1][0][0] = mx;
4082
                s->mv[1][0][1] = my;
4083
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4084
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4085
            }
4086
        }
4087
          
4088
        s->current_picture.mb_type[xy]= mb_type;
4089

    
4090
        /* decode each block */
4091
        for (i = 0; i < 6; i++) {
4092
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4093
                return -1;
4094
            cbp+=cbp;
4095
        }
4096
    } else { /* I-Frame */
4097
        do{
4098
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4099
            if (cbpc < 0){
4100
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4101
                return -1;
4102
            }
4103
        }while(cbpc == 8);
4104

    
4105
        dquant = cbpc & 4;
4106
        s->mb_intra = 1;
4107
intra:
4108
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4109
        if (s->h263_aic) {
4110
            s->ac_pred = get_bits1(&s->gb);
4111
            if(s->ac_pred){
4112
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4113
            
4114
                s->h263_aic_dir = get_bits1(&s->gb);
4115
            }
4116
        }else
4117
            s->ac_pred = 0;
4118
        
4119
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4120
        if(cbpy<0){
4121
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4122
            return -1;
4123
        }
4124
        cbp = (cbpc & 3) | (cbpy << 2);
4125
        if (dquant) {
4126
            h263_decode_dquant(s);
4127
        }
4128

    
4129
        /* decode each block */
4130
        for (i = 0; i < 6; i++) {
4131
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4132
                return -1;
4133
            cbp+=cbp;
4134
        }
4135
    }
4136
end:
4137

    
4138
        /* per-MB end of slice check */
4139
    {
4140
        int v= show_bits(&s->gb, 16);
4141
    
4142
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4143
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4144
        }
4145

    
4146
        if(v==0)
4147
            return SLICE_END;
4148
    }
4149

    
4150
    return SLICE_OK;     
4151
}
4152

    
4153
int ff_mpeg4_decode_mb(MpegEncContext *s,
4154
                      DCTELEM block[6][64])
4155
{
4156
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4157
    int16_t *mot_val;
4158
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4159
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4160
    
4161
    assert(s->h263_pred);
4162
    
4163
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4164
        do{
4165
            if (get_bits1(&s->gb)) {
4166
                /* skip mb */
4167
                s->mb_intra = 0;
4168
                for(i=0;i<6;i++)
4169
                    s->block_last_index[i] = -1;
4170
                s->mv_dir = MV_DIR_FORWARD;
4171
                s->mv_type = MV_TYPE_16X16;
4172
                if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4173
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4174
                    s->mcsel=1;
4175
                    s->mv[0][0][0]= get_amv(s, 0);
4176
                    s->mv[0][0][1]= get_amv(s, 1);
4177

    
4178
                    s->mb_skiped = 0;
4179
                }else{
4180
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4181
                    s->mcsel=0;
4182
                    s->mv[0][0][0] = 0;
4183
                    s->mv[0][0][1] = 0;
4184
                    s->mb_skiped = 1;
4185
                }
4186
                goto end;
4187
            }
4188
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4189
            //fprintf(stderr, "\tCBPC: %d", cbpc);
4190
            if (cbpc < 0){
4191
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4192
                return -1;
4193
            }
4194
        }while(cbpc == 20);
4195
        
4196
        dquant = cbpc & 8;
4197
        s->mb_intra = ((cbpc & 4) != 0);
4198
        if (s->mb_intra) goto intra;
4199
        
4200
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4201
            s->mcsel= get_bits1(&s->gb);
4202
        else s->mcsel= 0;
4203
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4204
        
4205
        cbp = (cbpc & 3) | (cbpy << 2);
4206
        if (dquant) {
4207
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4208
        }
4209
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4210
            s->interlaced_dct= get_bits1(&s->gb);
4211
        
4212
        s->mv_dir = MV_DIR_FORWARD;
4213
        if ((cbpc & 16) == 0) {
4214
            if(s->mcsel){
4215
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4216
                /* 16x16 global motion prediction */
4217
                s->mv_type = MV_TYPE_16X16;
4218
                mx= get_amv(s, 0);
4219
                my= get_amv(s, 1);
4220
                s->mv[0][0][0] = mx;
4221
                s->mv[0][0][1] = my;
4222
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4223
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; 
4224
                /* 16x8 field motion prediction */
4225
                s->mv_type= MV_TYPE_FIELD;
4226

    
4227
                s->field_select[0][0]= get_bits1(&s->gb);
4228
                s->field_select[0][1]= get_bits1(&s->gb);
4229

    
4230
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4231
                
4232
                for(i=0; i<2; i++){
4233
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4234
                    if (mx >= 0xffff)
4235
                        return -1;
4236
            
4237
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4238
                    if (my >= 0xffff)
4239
                        return -1;
4240

    
4241
                    s->mv[0][i][0] = mx;
4242
                    s->mv[0][i][1] = my;
4243
                }
4244
            }else{
4245
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
4246
                /* 16x16 motion prediction */
4247
                s->mv_type = MV_TYPE_16X16;
4248
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4249
                mx = h263_decode_motion(s, pred_x, s->f_code);
4250
            
4251
                if (mx >= 0xffff)
4252
                    return -1;
4253
            
4254
                my = h263_decode_motion(s, pred_y, s->f_code);
4255
            
4256
                if (my >= 0xffff)
4257
                    return -1;
4258
                s->mv[0][0][0] = mx;
4259
                s->mv[0][0][1] = my;
4260
            }
4261
        } else {
4262
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
4263
            s->mv_type = MV_TYPE_8X8;
4264
            for(i=0;i<4;i++) {
4265
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4266
                mx = h263_decode_motion(s, pred_x, s->f_code);
4267
                if (mx >= 0xffff)
4268
                    return -1;
4269
                
4270
                my = h263_decode_motion(s, pred_y, s->f_code);
4271
                if (my >= 0xffff)
4272
                    return -1;
4273
                s->mv[0][i][0] = mx;
4274
                s->mv[0][i][1] = my;
4275
                mot_val[0] = mx;
4276
                mot_val[1] = my;
4277
            }
4278
        }
4279
    } else if(s->pict_type==B_TYPE) {
4280
        int modb1; // first bit of modb
4281
        int modb2; // second bit of modb
4282
        int mb_type;
4283

    
4284
        s->mb_intra = 0; //B-frames never contain intra blocks
4285
        s->mcsel=0;      //     ...               true gmc blocks
4286

    
4287
        if(s->mb_x==0){
4288
            for(i=0; i<2; i++){
4289
                s->last_mv[i][0][0]= 
4290
                s->last_mv[i][0][1]= 
4291
                s->last_mv[i][1][0]= 
4292
                s->last_mv[i][1][1]= 0;
4293
            }
4294
        }
4295

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

    
4299
        if(s->mb_skiped){
4300
                /* skip mb */
4301
            for(i=0;i<6;i++)
4302
                s->block_last_index[i] = -1;
4303

    
4304
            s->mv_dir = MV_DIR_FORWARD;
4305
            s->mv_type = MV_TYPE_16X16;
4306
            s->mv[0][0][0] = 0;
4307
            s->mv[0][0][1] = 0;
4308
            s->mv[1][0][0] = 0;
4309
            s->mv[1][0][1] = 0;
4310
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 
4311
            goto end;
4312
        }
4313

    
4314
        modb1= get_bits1(&s->gb); 
4315
        if(modb1){
4316
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4317
            cbp=0;
4318
        }else{
4319
            modb2= get_bits1(&s->gb);
4320
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4321
            if(mb_type<0){
4322
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4323
                return -1;
4324
            }
4325
            mb_type= mb_type_b_map[ mb_type ];
4326
            if(modb2) cbp= 0;
4327
            else      cbp= get_bits(&s->gb, 6);
4328

    
4329
            if ((!IS_DIRECT(mb_type)) && cbp) {
4330
                if(get_bits1(&s->gb)){
4331
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4332
                }
4333
            }
4334

    
4335
            if(!s->progressive_sequence){
4336
                if(cbp)
4337
                    s->interlaced_dct= get_bits1(&s->gb);
4338

    
4339
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4340
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4341
                    mb_type &= ~MB_TYPE_16x16;
4342

    
4343
                    if(USES_LIST(mb_type, 0)){
4344
                        s->field_select[0][0]= get_bits1(&s->gb);
4345
                        s->field_select[0][1]= get_bits1(&s->gb);
4346
                    }
4347
                    if(USES_LIST(mb_type, 1)){
4348
                        s->field_select[1][0]= get_bits1(&s->gb);
4349
                        s->field_select[1][1]= get_bits1(&s->gb);
4350
                    }
4351
                }
4352
            }
4353

    
4354
            s->mv_dir = 0;
4355
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4356
                s->mv_type= MV_TYPE_16X16;
4357

    
4358
                if(USES_LIST(mb_type, 0)){
4359
                    s->mv_dir = MV_DIR_FORWARD;
4360

    
4361
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4362
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4363
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4364
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4365
                }
4366
    
4367
                if(USES_LIST(mb_type, 1)){
4368
                    s->mv_dir |= MV_DIR_BACKWARD;
4369

    
4370
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4371
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4372
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4373
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4374
                }
4375
            }else if(!IS_DIRECT(mb_type)){
4376
                s->mv_type= MV_TYPE_FIELD;
4377

    
4378
                if(USES_LIST(mb_type, 0)){
4379
                    s->mv_dir = MV_DIR_FORWARD;
4380
                
4381
                    for(i=0; i<2; i++){
4382
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4383
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4384
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4385
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4386
                    }
4387
                }
4388
    
4389
                if(USES_LIST(mb_type, 1)){
4390
                    s->mv_dir |= MV_DIR_BACKWARD;
4391

    
4392
                    for(i=0; i<2; i++){
4393
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4394
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4395
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4396
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4397
                    }
4398
                }
4399
            }
4400
        }
4401
          
4402
        if(IS_DIRECT(mb_type)){
4403
            if(IS_SKIP(mb_type))
4404
                mx=my=0;
4405
            else{
4406
                mx = h263_decode_motion(s, 0, 1);
4407
                my = h263_decode_motion(s, 0, 1);
4408
            }
4409
 
4410
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4411
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4412
        }
4413
        s->current_picture.mb_type[xy]= mb_type;
4414
    } else { /* I-Frame */
4415
        do{
4416
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4417
            if (cbpc < 0){
4418
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4419
                return -1;
4420
            }
4421
        }while(cbpc == 8);
4422

    
4423
        dquant = cbpc & 4;
4424
        s->mb_intra = 1;
4425
intra:
4426
        s->ac_pred = get_bits1(&s->gb);
4427
        if(s->ac_pred)
4428
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4429
        else
4430
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4431
        
4432
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4433
        if(cbpy<0){
4434
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4435
            return -1;
4436
        }
4437
        cbp = (cbpc & 3) | (cbpy << 2);
4438
        if (dquant) {
4439
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4440
        }
4441
        
4442
        if(!s->progressive_sequence)
4443
            s->interlaced_dct= get_bits1(&s->gb);
4444

    
4445
        /* decode each block */
4446
        for (i = 0; i < 6; i++) {
4447
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4448
                return -1;
4449
            cbp+=cbp;
4450
        }
4451
        goto end;
4452
    }
4453

    
4454
    /* decode each block */
4455
    for (i = 0; i < 6; i++) {
4456
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4457
            return -1;
4458
        cbp+=cbp;
4459
    }
4460
end:
4461

    
4462
        /* per-MB end of slice check */
4463
    if(s->codec_id==CODEC_ID_MPEG4){
4464
        if(mpeg4_is_resync(s)){
4465
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4466
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4467
                return SLICE_OK;
4468
            return SLICE_END;
4469
        }
4470
    }
4471

    
4472
    return SLICE_OK;     
4473
}
4474

    
4475
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4476
{
4477
    int code, val, sign, shift, l;
4478
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4479

    
4480
    if (code == 0)
4481
        return pred;
4482
    if (code < 0)
4483
        return 0xffff;
4484

    
4485
    sign = get_bits1(&s->gb);
4486
    shift = f_code - 1;
4487
    val = code;
4488
    if (shift) {
4489
        val = (val - 1) << shift;
4490
        val |= get_bits(&s->gb, shift);
4491
        val++;
4492
    }
4493
    if (sign)
4494
        val = -val;
4495
    val += pred;
4496

    
4497
    /* modulo decoding */
4498
    if (!s->h263_long_vectors) {
4499
        l = INT_BIT - 5 - f_code;
4500
        val = (val<<l)>>l;
4501
    } else {
4502
        /* horrible h263 long vector mode */
4503
        if (pred < -31 && val < -63)
4504
            val += 64;
4505
        if (pred > 32 && val > 63)
4506
            val -= 64;
4507
        
4508
    }
4509
    return val;
4510
}
4511

    
4512
/* Decodes RVLC of H.263+ UMV */
4513
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4514
{
4515
   int code = 0, sign;
4516
   
4517
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4518
      return pred;
4519
   
4520
   code = 2 + get_bits1(&s->gb);
4521
   
4522
   while (get_bits1(&s->gb))
4523
   {
4524
      code <<= 1;
4525
      code += get_bits1(&s->gb);
4526
   }
4527
   sign = code & 1;
4528
   code >>= 1;
4529
   
4530
   code = (sign) ? (pred - code) : (pred + code);
4531
#ifdef DEBUG
4532
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
4533
#endif
4534
   return code;   
4535

    
4536
}
4537

    
4538
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4539
                             int n, int coded)
4540
{
4541
    int code, level, i, j, last, run;
4542
    RLTable *rl = &rl_inter;
4543
    const uint8_t *scan_table;
4544
    GetBitContext gb= s->gb;
4545

    
4546
    scan_table = s->intra_scantable.permutated;
4547
    if (s->h263_aic && s->mb_intra) {
4548
        rl = &rl_intra_aic;
4549
        i = 0;
4550
        if (s->ac_pred) {
4551
            if (s->h263_aic_dir) 
4552
                scan_table = s->intra_v_scantable.permutated; /* left */
4553
            else
4554
                scan_table = s->intra_h_scantable.permutated; /* top */
4555
        }
4556
    } else if (s->mb_intra) {
4557
        /* DC coef */
4558
        if(s->codec_id == CODEC_ID_RV10){
4559
          if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4560
            int component, diff;
4561
            component = (n <= 3 ? 0 : n - 4 + 1);
4562
            level = s->last_dc[component];
4563
            if (s->rv10_first_dc_coded[component]) {
4564
                diff = rv_decode_dc(s, n);
4565
                if (diff == 0xffff)
4566
                    return -1;
4567
                level += diff;
4568
                level = level & 0xff; /* handle wrap round */
4569
                s->last_dc[component] = level;
4570
            } else {
4571
                s->rv10_first_dc_coded[component] = 1;
4572
            }
4573
          } else {
4574
                level = get_bits(&s->gb, 8);
4575
                if (level == 255)
4576
                    level = 128;
4577
          }
4578
        }else{
4579
            level = get_bits(&s->gb, 8);
4580
            if((level&0x7F) == 0){
4581
                av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4582
                if(s->error_resilience >= FF_ER_COMPLIANT)
4583
                    return -1;
4584
            }
4585
            if (level == 255)
4586
                level = 128;
4587
        }
4588
        block[0] = level;
4589
        i = 1;
4590
    } else {
4591
        i = 0;
4592
    }
4593
    if (!coded) {
4594
        if (s->mb_intra && s->h263_aic)
4595
            goto not_coded;
4596
        s->block_last_index[n] = i - 1;
4597
        return 0;
4598
    }
4599
retry:
4600
    for(;;) {
4601
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4602
        if (code < 0){
4603
            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4604
            return -1;
4605
        }
4606
        if (code == rl->n) {
4607
            /* escape */
4608
            if (s->h263_flv > 1) {
4609
                int is11 = get_bits1(&s->gb);
4610
                last = get_bits1(&s->gb);
4611
                run = get_bits(&s->gb, 6);
4612
                if(is11){
4613
                    level = get_sbits(&s->gb, 11);
4614
                } else {
4615
                    level = get_sbits(&s->gb, 7);
4616
                }
4617
            } else {
4618
                last = get_bits1(&s->gb);
4619
                run = get_bits(&s->gb, 6);
4620
                level = (int8_t)get_bits(&s->gb, 8);
4621
                if(level == -128){
4622
                    if (s->codec_id == CODEC_ID_RV10) {
4623
                        /* XXX: should patch encoder too */
4624
                        level = get_sbits(&s->gb, 12);
4625
                    }else{
4626
                        level = get_bits(&s->gb, 5);
4627
                        level |= get_sbits(&s->gb, 6)<<5;
4628
                    }
4629
                }
4630
            }
4631
        } else {
4632
            run = rl->table_run[code];
4633
            level = rl->table_level[code];
4634
            last = code >= rl->last;
4635
            if (get_bits1(&s->gb))
4636
                level = -level;
4637
        }
4638
        i += run;
4639
        if (i >= 64){
4640
            if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4641
                //looks like a hack but no, its the way its supposed to work ...
4642
                rl = &rl_intra_aic;
4643
                i = 0;
4644
                s->gb= gb;
4645
                memset(block, 0, sizeof(DCTELEM)*64);
4646
                goto retry;
4647
            }
4648
            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4649
            return -1;
4650
        }
4651
        j = scan_table[i];
4652
        block[j] = level;
4653
        if (last)
4654
            break;
4655
        i++;
4656
    }
4657
not_coded:    
4658
    if (s->mb_intra && s->h263_aic) {
4659
        h263_pred_acdc(s, block, n);
4660
        i = 63;
4661
    }
4662
    s->block_last_index[n] = i;
4663
    return 0;
4664
}
4665

    
4666
/**
4667
 * decodes the dc value.
4668
 * @param n block index (0-3 are luma, 4-5 are chroma)
4669
 * @param dir_ptr the prediction direction will be stored here
4670
 * @return the quantized dc
4671
 */
4672
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4673
{
4674
    int level, code;
4675

    
4676
    if (n < 4) 
4677
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4678
    else 
4679
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4680
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4681
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4682
        return -1;
4683
    }
4684
    if (code == 0) {
4685
        level = 0;
4686
    } else {
4687
        if(IS_3IV1){
4688
            if(code==1)
4689
                level= 2*get_bits1(&s->gb)-1;
4690
            else{
4691
                if(get_bits1(&s->gb))
4692
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4693
                else
4694
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4695
            }
4696
        }else{
4697
            level = get_xbits(&s->gb, code);
4698
        }
4699

    
4700
        if (code > 8){
4701
            if(get_bits1(&s->gb)==0){ /* marker */
4702
                if(s->error_resilience>=2){
4703
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4704
                    return -1;
4705
                }
4706
            }
4707
        }
4708
    }
4709

    
4710
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4711
}
4712

    
4713
/**
4714
 * decodes a block.
4715
 * @return <0 if an error occured
4716
 */
4717
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4718
                              int n, int coded, int intra, int rvlc)
4719
{
4720
    int level, i, last, run;
4721
    int dc_pred_dir;
4722
    RLTable * rl;
4723
    RL_VLC_ELEM * rl_vlc;
4724
    const uint8_t * scan_table;
4725
    int qmul, qadd;
4726

    
4727
    //Note intra & rvlc should be optimized away if this is inlined
4728
    
4729
    if(intra) {
4730
      if(s->qscale < s->intra_dc_threshold){
4731
        /* DC coef */
4732
        if(s->partitioned_frame){
4733
            level = s->dc_val[0][ s->block_index[n] ];
4734
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4735
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4736
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4737
        }else{
4738
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4739
            if (level < 0)
4740
                return -1;
4741
        }
4742
        block[0] = level;
4743
        i = 0;
4744
      }else{
4745
            i = -1;
4746
      }  
4747
        if (!coded) 
4748
            goto not_coded;
4749
        
4750
        if(rvlc){        
4751
            rl = &rvlc_rl_intra;
4752
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
4753
        }else{
4754
            rl = &rl_intra;
4755
            rl_vlc = rl_intra.rl_vlc[0];
4756
        }
4757
        if (s->ac_pred) {
4758
            if (dc_pred_dir == 0) 
4759
                scan_table = s->intra_v_scantable.permutated; /* left */
4760
            else
4761
                scan_table = s->intra_h_scantable.permutated; /* top */
4762
        } else {
4763
            scan_table = s->intra_scantable.permutated;
4764
        }
4765
        qmul=1;
4766
        qadd=0;
4767
    } else {
4768
        i = -1;
4769
        if (!coded) {
4770
            s->block_last_index[n] = i;
4771
            return 0;
4772
        }
4773
        if(rvlc) rl = &rvlc_rl_inter;
4774
        else     rl = &rl_inter;
4775