Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ c1341a57

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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 it 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->time_base.num) / //FIXME use timestamp
164
                           s->avctx->time_base.den) & 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->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
212
            div= clip(1, div, 127);
213
            error= ABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*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->time_base.num / //FIXME use timestamp
231
                         (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
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 */
251
        put_bits(&s->pb, 1, 0);         /* only I/P frames, no 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 isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
527

    
528
        for(i=0; i<s->mb_num; i++){
529
            int mb_xy= s->mb_index2xy[i];
530
            odd += qscale_table[mb_xy]&1;
531
        }
532

    
533
        if(2*odd > s->mb_num) odd=1;
534
        else                  odd=0;
535

    
536
        for(i=0; i<s->mb_num; i++){
537
            int mb_xy= s->mb_index2xy[i];
538
            if((qscale_table[mb_xy]&1) != odd)
539
                qscale_table[mb_xy]++;
540
            if(qscale_table[mb_xy] > 31)
541
                qscale_table[mb_xy]= 31;
542
        }
543

    
544
        for(i=1; i<s->mb_num; i++){
545
            int mb_xy= s->mb_index2xy[i];
546
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
547
                s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
548
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
549
            }
550
        }
551
    }
552
}
553

    
554
#endif //CONFIG_ENCODERS
555
/**
556
 *
557
 * @return the mb_type
558
 */
559
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
560
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
561
    const int colocated_mb_type= s->next_picture.mb_type[mb_index];
562
    int xy= s->block_index[0];
563
    uint16_t time_pp= s->pp_time;
564
    uint16_t time_pb= s->pb_time;
565
    int i;
566

    
567
    //FIXME avoid divides
568

    
569
    if(IS_8X8(colocated_mb_type)){
570
        s->mv_type = MV_TYPE_8X8;
571
        for(i=0; i<4; i++){
572
            xy= s->block_index[i];
573
            s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
574
            s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
575
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
576
                                : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
577
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1]
578
                                : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
579
        }
580
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
581
    } else if(IS_INTERLACED(colocated_mb_type)){
582
        s->mv_type = MV_TYPE_FIELD;
583
        for(i=0; i<2; i++){
584
            int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
585
            if(s->top_field_first){
586
                time_pp= s->pp_field_time - field_select + i;
587
                time_pb= s->pb_field_time - field_select + i;
588
            }else{
589
                time_pp= s->pp_field_time + field_select - i;
590
                time_pb= s->pb_field_time + field_select - i;
591
            }
592
            s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
593
            s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
594
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
595
                                : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
596
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
597
                                : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
598
        }
599
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
600
    }else{
601
        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;
602
        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;
603
        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]
604
                            : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
605
        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]
606
                            : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
607
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
608
            s->mv_type= MV_TYPE_16X16;
609
        else
610
            s->mv_type= MV_TYPE_8X8;
611
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
612
    }
613
}
614

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

    
621
    s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
622

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

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

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

    
667
#ifdef CONFIG_ENCODERS
668

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

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

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

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

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

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

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

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

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

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

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

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

    
758
    if(s->flags & CODEC_FLAG_CBP_RD){
759
        int score=0;
760
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
761

    
762
        for(i=0; i<6; i++){
763
            if(s->coded_score[i] < 0){
764
                score += s->coded_score[i];
765
                cbp |= 1 << (5 - i);
766
            }
767
        }
768

    
769
        if(cbp){
770
            int zero_score= -6;
771
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
772
                zero_score-= 4; //2*MV + mb_type + cbp bit
773
            }
774

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

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

    
796
static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
797
                               uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
798
    int i;
799

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

    
825
void mpeg4_encode_mb(MpegEncContext * s,
826
                    DCTELEM block[6][64],
827
                    int motion_x, int motion_y)
828
{
829
    int cbpc, cbpy, pred_x, pred_y;
830
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
831
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
832
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
833
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
834
    const int dquant_code[5]= {1,0,9,2,3};
835

    
836
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
837
    if (!s->mb_intra) {
838
        int i, cbp;
839

    
840
        if(s->pict_type==B_TYPE){
841
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
842
            int mb_type=  mb_type_table[s->mv_dir];
843

    
844
            if(s->mb_x==0){
845
                for(i=0; i<2; i++){
846
                    s->last_mv[i][0][0]=
847
                    s->last_mv[i][0][1]=
848
                    s->last_mv[i][1][0]=
849
                    s->last_mv[i][1][1]= 0;
850
                }
851
            }
852

    
853
            assert(s->dquant>=-2 && s->dquant<=2);
854
            assert((s->dquant&1)==0);
855
            assert(mb_type>=0);
856

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

    
868
                return;
869
            }
870

    
871
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
872

    
873
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
874
                /* direct MB with MV={0,0} */
875
                assert(s->dquant==0);
876

    
877
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
878

    
879
                if(interleaved_stats){
880
                    s->misc_bits++;
881
                    s->last_bits++;
882
                }
883
                s->skip_count++;
884
                return;
885
            }
886

    
887
            put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
888
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
889
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
890
            if(cbp) put_bits(&s->pb, 6, cbp);
891

    
892
            if(cbp && mb_type){
893
                if(s->dquant)
894
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
895
                else
896
                    put_bits(&s->pb, 1, 0);
897
            }else
898
                s->qscale -= s->dquant;
899

    
900
            if(!s->progressive_sequence){
901
                if(cbp)
902
                    put_bits(&s->pb, 1, s->interlaced_dct);
903
                if(mb_type) // not direct mode
904
                    put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
905
            }
906

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

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

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

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

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

    
973
        }else{ /* s->pict_type==B_TYPE */
974
            cbp= get_p_cbp(s, block, motion_x, motion_y);
975

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

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

    
989
                    offset= x + y*s->linesize;
990
                    p_pic= s->new_picture.data[0] + offset;
991

    
992
                    s->mb_skipped=1;
993
                    for(i=0; i<s->max_b_frames; i++){
994
                        uint8_t *b_pic;
995
                        int diff;
996
                        Picture *pic= s->reordered_input_picture[i+1];
997

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

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

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

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

    
1022
                    return;
1023
                }
1024
            }
1025

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

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

    
1040
                if(!s->progressive_sequence){
1041
                    if(cbp)
1042
                        put_bits(pb2, 1, s->interlaced_dct);
1043
                    put_bits(pb2, 1, 0);
1044
                }
1045

    
1046
                if(interleaved_stats){
1047
                    s->misc_bits+= get_bits_diff(s);
1048
                }
1049

    
1050
                /* motion vectors: 16x16 mode */
1051
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1052

    
1053
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
1054
                                                motion_y - pred_y, s->f_code);
1055
            }else if(s->mv_type==MV_TYPE_FIELD){
1056
                if(s->dquant) cbpc+= 8;
1057
                put_bits(&s->pb,
1058
                        inter_MCBPC_bits[cbpc],
1059
                        inter_MCBPC_code[cbpc]);
1060

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

    
1065
                assert(!s->progressive_sequence);
1066
                if(cbp)
1067
                    put_bits(pb2, 1, s->interlaced_dct);
1068
                put_bits(pb2, 1, 1);
1069

    
1070
                if(interleaved_stats){
1071
                    s->misc_bits+= get_bits_diff(s);
1072
                }
1073

    
1074
                /* motion vectors: 16x8 interlaced mode */
1075
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1076
                pred_y /=2;
1077

    
1078
                put_bits(&s->pb, 1, s->field_select[0][0]);
1079
                put_bits(&s->pb, 1, s->field_select[0][1]);
1080

    
1081
                ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1082
                                                s->mv[0][0][1] - pred_y, s->f_code);
1083
                ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1084
                                                s->mv[0][1][1] - pred_y, s->f_code);
1085
            }else{
1086
                assert(s->mv_type==MV_TYPE_8X8);
1087
                put_bits(&s->pb,
1088
                        inter_MCBPC_bits[cbpc+16],
1089
                        inter_MCBPC_code[cbpc+16]);
1090
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1091

    
1092
                if(!s->progressive_sequence){
1093
                    if(cbp)
1094
                        put_bits(pb2, 1, s->interlaced_dct);
1095
                }
1096

    
1097
                if(interleaved_stats){
1098
                    s->misc_bits+= get_bits_diff(s);
1099
                }
1100

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1189
void h263_encode_mb(MpegEncContext * s,
1190
                    DCTELEM block[6][64],
1191
                    int motion_x, int motion_y)
1192
{
1193
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
1194
    int16_t pred_dc;
1195
    int16_t rec_intradc[6];
1196
    uint16_t *dc_ptr[6];
1197
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1198
    const int dquant_code[5]= {1,0,9,2,3};
1199

    
1200
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1201
    if (!s->mb_intra) {
1202
        /* compute cbp */
1203
        cbp= get_p_cbp(s, block, motion_x, motion_y);
1204

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

    
1214
            return;
1215
        }
1216
        put_bits(&s->pb, 1, 0);         /* mb coded */
1217

    
1218
        cbpc = cbp & 3;
1219
        cbpy = cbp >> 2;
1220
        if(s->alt_inter_vlc==0 || cbpc!=3)
1221
            cbpy ^= 0xF;
1222
        if(s->dquant) cbpc+= 8;
1223
        if(s->mv_type==MV_TYPE_16X16){
1224
            put_bits(&s->pb,
1225
                    inter_MCBPC_bits[cbpc],
1226
                    inter_MCBPC_code[cbpc]);
1227

    
1228
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1229
            if(s->dquant)
1230
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1231

    
1232
            if(interleaved_stats){
1233
                s->misc_bits+= get_bits_diff(s);
1234
            }
1235

    
1236
            /* motion vectors: 16x16 mode */
1237
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1238

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

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

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

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

    
1282
        if(interleaved_stats){
1283
            s->mv_bits+= get_bits_diff(s);
1284
        }
1285
    } else {
1286
        assert(s->mb_intra);
1287

    
1288
        cbp = 0;
1289
        if (s->h263_aic) {
1290
            /* Predict DC */
1291
            for(i=0; i<6; i++) {
1292
                int16_t level = block[i][0];
1293
                int scale;
1294

    
1295
                if(i<4) scale= s->y_dc_scale;
1296
                else    scale= s->c_dc_scale;
1297

    
1298
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1299
                level -= pred_dc;
1300
                /* Quant */
1301
                if (level >= 0)
1302
                    level = (level + (scale>>1))/scale;
1303
                else
1304
                    level = (level - (scale>>1))/scale;
1305

    
1306
                /* AIC can change CBP */
1307
                if (level == 0 && s->block_last_index[i] == 0)
1308
                    s->block_last_index[i] = -1;
1309

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

    
1317
                block[i][0] = level;
1318
                /* Reconstruction */
1319
                rec_intradc[i] = scale*level + pred_dc;
1320
                /* Oddify */
1321
                rec_intradc[i] |= 1;
1322
                //if ((rec_intradc[i] % 2) == 0)
1323
                //    rec_intradc[i]++;
1324
                /* Clipping */
1325
                if (rec_intradc[i] < 0)
1326
                    rec_intradc[i] = 0;
1327
                else if (rec_intradc[i] > 2047)
1328
                    rec_intradc[i] = 2047;
1329

    
1330
                /* Update AC/DC tables */
1331
                *dc_ptr[i] = rec_intradc[i];
1332
                if (s->block_last_index[i] >= 0)
1333
                    cbp |= 1 << (5 - i);
1334
            }
1335
        }else{
1336
            for(i=0; i<6; i++) {
1337
                /* compute cbp */
1338
                if (s->block_last_index[i] >= 1)
1339
                    cbp |= 1 << (5 - i);
1340
            }
1341
        }
1342

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

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

    
1370
    for(i=0; i<6; i++) {
1371
        /* encode each block */
1372
        h263_encode_block(s, block[i], i);
1373

    
1374
        /* Update INTRADC for decoding */
1375
        if (s->h263_aic && s->mb_intra) {
1376
            block[i][0] = rec_intradc[i];
1377

    
1378
        }
1379
    }
1380

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

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

    
1402
//    if(s->pict_type==B_TYPE && !s->readable) return;
1403

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

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

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

    
1423
        if(qp_c)
1424
            qp_tc= qp_c;
1425
        else
1426
            qp_tc= qp_t;
1427

    
1428
        if(qp_tc){
1429
            const int chroma_qp= s->chroma_qscale_table[qp_tc];
1430
            s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
1431
            s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
1432

    
1433
            s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1434
            s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1435
        }
1436

    
1437
        if(qp_t)
1438
            s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_t);
1439

    
1440
        if(s->mb_x){
1441
            if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1442
                qp_dt= qp_t;
1443
            else
1444
                qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1445

    
1446
            if(qp_dt){
1447
                const int chroma_qp= s->chroma_qscale_table[qp_dt];
1448
                s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
1449
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1450
                s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1451
            }
1452
        }
1453
    }
1454

    
1455
    if(qp_c){
1456
        s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1457
        if(s->mb_y + 1 == s->mb_height)
1458
            s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1459
    }
1460

    
1461
    if(s->mb_x){
1462
        int qp_lc;
1463
        if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1464
            qp_lc= qp_c;
1465
        else
1466
            qp_lc= s->current_picture.qscale_table[xy-1];
1467

    
1468
        if(qp_lc){
1469
            s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1470
            if(s->mb_y + 1 == s->mb_height){
1471
                const int chroma_qp= s->chroma_qscale_table[qp_lc];
1472
                s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1473
                s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1474
                s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1475
            }
1476
        }
1477
    }
1478
}
1479

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

    
1485
    /* find prediction */
1486
    if (n < 4) {
1487
        x = 2 * s->mb_x + (n & 1);
1488
        y = 2 * s->mb_y + ((n & 2) >> 1);
1489
        wrap = s->b8_stride;
1490
        dc_val = s->dc_val[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
        scale = s->c_dc_scale;
1498
    }
1499
    /* B C
1500
     * A X
1501
     */
1502
    a = dc_val[(x - 1) + (y) * wrap];
1503
    c = dc_val[(x) + (y - 1) * wrap];
1504

    
1505
    /* No prediction outside GOB boundary */
1506
    if(s->first_slice_line && n!=3){
1507
        if(n!=2) c= 1024;
1508
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1509
    }
1510
    pred_dc = 1024;
1511
    /* just DC prediction */
1512
    if (a != 1024 && c != 1024)
1513
        pred_dc = (a + c) >> 1;
1514
    else if (a != 1024)
1515
        pred_dc = a;
1516
    else
1517
        pred_dc = c;
1518

    
1519
    /* we assume pred is positive */
1520
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1521
    *dc_val_ptr = &dc_val[x + y * wrap];
1522
    return pred_dc;
1523
}
1524

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

    
1530
    /* find prediction */
1531
    if (n < 4) {
1532
        x = 2 * s->mb_x + (n & 1);
1533
        y = 2 * s->mb_y + (n>> 1);
1534
        wrap = s->b8_stride;
1535
        dc_val = s->dc_val[0];
1536
        ac_val = s->ac_val[0][0];
1537
        scale = s->y_dc_scale;
1538
    } else {
1539
        x = s->mb_x;
1540
        y = s->mb_y;
1541
        wrap = s->mb_stride;
1542
        dc_val = s->dc_val[n - 4 + 1];
1543
        ac_val = s->ac_val[n - 4 + 1][0];
1544
        scale = s->c_dc_scale;
1545
    }
1546

    
1547
    ac_val += ((y) * wrap + (x)) * 16;
1548
    ac_val1 = ac_val;
1549

    
1550
    /* B C
1551
     * A X
1552
     */
1553
    a = dc_val[(x - 1) + (y) * wrap];
1554
    c = dc_val[(x) + (y - 1) * wrap];
1555

    
1556
    /* No prediction outside GOB boundary */
1557
    if(s->first_slice_line && n!=3){
1558
        if(n!=2) c= 1024;
1559
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1560
    }
1561

    
1562
    if (s->ac_pred) {
1563
        pred_dc = 1024;
1564
        if (s->h263_aic_dir) {
1565
            /* left prediction */
1566
            if (a != 1024) {
1567
                ac_val -= 16;
1568
                for(i=1;i<8;i++) {
1569
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1570
                }
1571
                pred_dc = a;
1572
            }
1573
        } else {
1574
            /* top prediction */
1575
            if (c != 1024) {
1576
                ac_val -= 16 * wrap;
1577
                for(i=1;i<8;i++) {
1578
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1579
                }
1580
                pred_dc = c;
1581
            }
1582
        }
1583
    } else {
1584
        /* just DC prediction */
1585
        if (a != 1024 && c != 1024)
1586
            pred_dc = (a + c) >> 1;
1587
        else if (a != 1024)
1588
            pred_dc = a;
1589
        else
1590
            pred_dc = c;
1591
    }
1592

    
1593
    /* we assume pred is positive */
1594
    block[0]=block[0]*scale + pred_dc;
1595

    
1596
    if (block[0] < 0)
1597
        block[0] = 0;
1598
    else
1599
        block[0] |= 1;
1600

    
1601
    /* Update AC/DC tables */
1602
    dc_val[(x) + (y) * wrap] = block[0];
1603

    
1604
    /* left copy */
1605
    for(i=1;i<8;i++)
1606
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1607
    /* top copy */
1608
    for(i=1;i<8;i++)
1609
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1610
}
1611

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

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

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

    
1658
            *px = mid_pred(A[0], B[0], C[0]);
1659
            *py = mid_pred(A[1], B[1], C[1]);
1660
        }
1661
    } else {
1662
        B = mot_val[ - wrap];
1663
        C = mot_val[off[block] - wrap];
1664
        *px = mid_pred(A[0], B[0], C[0]);
1665
        *py = mid_pred(A[1], B[1], C[1]);
1666
    }
1667
    return *mot_val;
1668
}
1669

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

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

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

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

    
1700
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1701
static void h263p_encode_umotion(MpegEncContext * s, int val)
1702
{
1703
    short sval = 0;
1704
    short i = 0;
1705
    short n_bits = 0;
1706
    short temp_val;
1707
    int code = 0;
1708
    int tcode;
1709

    
1710
    if ( val == 0)
1711
        put_bits(&s->pb, 1, 1);
1712
    else if (val == 1)
1713
        put_bits(&s->pb, 3, 0);
1714
    else if (val == -1)
1715
        put_bits(&s->pb, 3, 2);
1716
    else {
1717

    
1718
        sval = ((val < 0) ? (short)(-val):(short)val);
1719
        temp_val = sval;
1720

    
1721
        while (temp_val != 0) {
1722
            temp_val = temp_val >> 1;
1723
            n_bits++;
1724
        }
1725

    
1726
        i = n_bits - 1;
1727
        while (i > 0) {
1728
            tcode = (sval & (1 << (i-1))) >> (i-1);
1729
            tcode = (tcode << 1) | 1;
1730
            code = (code << 2) | tcode;
1731
            i--;
1732
        }
1733
        code = ((code << 1) | (val < 0)) << 1;
1734
        put_bits(&s->pb, (2*n_bits)+1, code);
1735
        //printf("\nVal = %d\tCode = %d", sval, code);
1736
    }
1737
}
1738

    
1739
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1740
{
1741
    int f_code;
1742
    int mv;
1743

    
1744
    if(mv_penalty==NULL)
1745
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1746

    
1747
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1748
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1749
            int len;
1750

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

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

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

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

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

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

    
1786
#ifdef CONFIG_ENCODERS
1787

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

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

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

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

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

    
1822
        /* chrominance */
1823
        uni_code= DCtab_chrom[size][0];
1824
        uni_len = DCtab_chrom[size][1];
1825

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

    
1837
    }
1838
}
1839

    
1840
#endif //CONFIG_ENCODERS
1841

    
1842
#ifdef CONFIG_ENCODERS
1843
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1844
    int slevel, run, last;
1845

    
1846
    assert(MAX_LEVEL >= 64);
1847
    assert(MAX_RUN   >= 63);
1848

    
1849
    for(slevel=-64; slevel<64; slevel++){
1850
        if(slevel==0) continue;
1851
        for(run=0; run<64; run++){
1852
            for(last=0; last<=1; last++){
1853
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1854
                int level= slevel < 0 ? -slevel : slevel;
1855
                int sign= slevel < 0 ? 1 : 0;
1856
                int bits, len, code;
1857
                int level1, run1;
1858

    
1859
                len_tab[index]= 100;
1860

    
1861
                /* ESC0 */
1862
                code= get_rl_index(rl, last, run, level);
1863
                bits= rl->table_vlc[code][0];
1864
                len=  rl->table_vlc[code][1];
1865
                bits=bits*2+sign; len++;
1866

    
1867
                if(code!=rl->n && len < len_tab[index]){
1868
                    bits_tab[index]= bits;
1869
                    len_tab [index]= len;
1870
                }
1871
#if 1
1872
                /* ESC1 */
1873
                bits= rl->table_vlc[rl->n][0];
1874
                len=  rl->table_vlc[rl->n][1];
1875
                bits=bits*2;    len++; //esc1
1876
                level1= level - rl->max_level[last][run];
1877
                if(level1>0){
1878
                    code= get_rl_index(rl, last, run, level1);
1879
                    bits<<= rl->table_vlc[code][1];
1880
                    len  += rl->table_vlc[code][1];
1881
                    bits += rl->table_vlc[code][0];
1882
                    bits=bits*2+sign; len++;
1883

    
1884
                    if(code!=rl->n && len < len_tab[index]){
1885
                        bits_tab[index]= bits;
1886
                        len_tab [index]= len;
1887
                    }
1888
                }
1889
#endif
1890
#if 1
1891
                /* ESC2 */
1892
                bits= rl->table_vlc[rl->n][0];
1893
                len=  rl->table_vlc[rl->n][1];
1894
                bits=bits*4+2;    len+=2; //esc2
1895
                run1 = run - rl->max_run[last][level] - 1;
1896
                if(run1>=0){
1897
                    code= get_rl_index(rl, last, run1, level);
1898
                    bits<<= rl->table_vlc[code][1];
1899
                    len  += rl->table_vlc[code][1];
1900
                    bits += rl->table_vlc[code][0];
1901
                    bits=bits*2+sign; len++;
1902

    
1903
                    if(code!=rl->n && len < len_tab[index]){
1904
                        bits_tab[index]= bits;
1905
                        len_tab [index]= len;
1906
                    }
1907
                }
1908
#endif
1909
                /* ESC3 */
1910
                bits= rl->table_vlc[rl->n][0];
1911
                len = rl->table_vlc[rl->n][1];
1912
                bits=bits*4+3;    len+=2; //esc3
1913
                bits=bits*2+last; len++;
1914
                bits=bits*64+run; len+=6;
1915
                bits=bits*2+1;    len++;  //marker
1916
                bits=bits*4096+(slevel&0xfff); len+=12;
1917
                bits=bits*2+1;    len++;  //marker
1918

    
1919
                if(len < len_tab[index]){
1920
                    bits_tab[index]= bits;
1921
                    len_tab [index]= len;
1922
                }
1923
            }
1924
        }
1925
    }
1926
}
1927

    
1928
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1929
    int slevel, run, last;
1930

    
1931
    assert(MAX_LEVEL >= 64);
1932
    assert(MAX_RUN   >= 63);
1933

    
1934
    for(slevel=-64; slevel<64; slevel++){
1935
        if(slevel==0) continue;
1936
        for(run=0; run<64; run++){
1937
            for(last=0; last<=1; last++){
1938
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1939
                int level= slevel < 0 ? -slevel : slevel;
1940
                int sign= slevel < 0 ? 1 : 0;
1941
                int bits, len, code;
1942

    
1943
                len_tab[index]= 100;
1944

    
1945
                /* ESC0 */
1946
                code= get_rl_index(rl, last, run, level);
1947
                bits= rl->table_vlc[code][0];
1948
                len=  rl->table_vlc[code][1];
1949
                bits=bits*2+sign; len++;
1950

    
1951
                if(code!=rl->n && len < len_tab[index]){
1952
                    if(bits_tab) bits_tab[index]= bits;
1953
                    len_tab [index]= len;
1954
                }
1955
                /* ESC */
1956
                bits= rl->table_vlc[rl->n][0];
1957
                len = rl->table_vlc[rl->n][1];
1958
                bits=bits*2+last; len++;
1959
                bits=bits*64+run; len+=6;
1960
                bits=bits*256+(level&0xff); len+=8;
1961

    
1962
                if(len < len_tab[index]){
1963
                    if(bits_tab) bits_tab[index]= bits;
1964
                    len_tab [index]= len;
1965
                }
1966
            }
1967
        }
1968
    }
1969
}
1970

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

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

    
1978
        init_uni_dc_tab();
1979

    
1980
        init_rl(&rl_inter, 1);
1981
        init_rl(&rl_intra, 1);
1982
        init_rl(&rl_intra_aic, 1);
1983

    
1984
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1985
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1986

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

    
1990
        init_mv_penalty_and_fcode(s);
1991
    }
1992
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1993

    
1994
    s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
1995
    s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
1996
    if(s->h263_aic){
1997
        s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
1998
        s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
1999
    }
2000
    s->ac_esc_length= 7+1+6+8;
2001

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

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

    
2020
            s->avctx->extradata= av_malloc(1024);
2021
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
2022

    
2023
            if(!(s->workaround_bugs & FF_BUG_MS))
2024
                mpeg4_encode_visual_object_header(s);
2025
            mpeg4_encode_vol_header(s, 0, 0);
2026

    
2027
//            ff_mpeg4_stuffing(&s->pb); ?
2028
            flush_put_bits(&s->pb);
2029
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2030
        }
2031

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

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

    
2074
    rl = &rl_inter;
2075
    if (s->mb_intra && !s->h263_aic) {
2076
        /* DC coef */
2077
        level = block[0];
2078
        /* 255 cannot be represented, so we clamp */
2079
        if (level > 254) {
2080
            level = 254;
2081
            block[0] = 254;
2082
        }
2083
        /* 0 cannot be represented also */
2084
        else if (level < 1) {
2085
            level = 1;
2086
            block[0] = 1;
2087
        }
2088
        if (level == 128) //FIXME check rv10
2089
            put_bits(&s->pb, 8, 0xff);
2090
        else
2091
            put_bits(&s->pb, 8, level);
2092
        i = 1;
2093
    } else {
2094
        i = 0;
2095
        if (s->h263_aic && s->mb_intra)
2096
            rl = &rl_intra_aic;
2097

    
2098
        if(s->alt_inter_vlc && !s->mb_intra){
2099
            int aic_vlc_bits=0;
2100
            int inter_vlc_bits=0;
2101
            int wrong_pos=-1;
2102
            int aic_code;
2103

    
2104
            last_index = s->block_last_index[n];
2105
            last_non_zero = i - 1;
2106
            for (; i <= last_index; i++) {
2107
                j = s->intra_scantable.permutated[i];
2108
                level = block[j];
2109
                if (level) {
2110
                    run = i - last_non_zero - 1;
2111
                    last = (i == last_index);
2112

    
2113
                    if(level<0) level= -level;
2114

    
2115
                    code = get_rl_index(rl, last, run, level);
2116
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2117
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2118
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2119

    
2120
                    if (code == rl->n) {
2121
                        inter_vlc_bits += 1+6+8-1;
2122
                    }
2123
                    if (aic_code == rl_intra_aic.n) {
2124
                        aic_vlc_bits += 1+6+8-1;
2125
                        wrong_pos += run + 1;
2126
                    }else
2127
                        wrong_pos += wrong_run[aic_code];
2128
                    last_non_zero = i;
2129
                }
2130
            }
2131
            i = 0;
2132
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2133
                rl = &rl_intra_aic;
2134
        }
2135
    }
2136

    
2137
    /* AC coefs */
2138
    last_index = s->block_last_index[n];
2139
    last_non_zero = i - 1;
2140
    for (; i <= last_index; i++) {
2141
        j = s->intra_scantable.permutated[i];
2142
        level = block[j];
2143
        if (level) {
2144
            run = i - last_non_zero - 1;
2145
            last = (i == last_index);
2146
            sign = 0;
2147
            slevel = level;
2148
            if (level < 0) {
2149
                sign = 1;
2150
                level = -level;
2151
            }
2152
            code = get_rl_index(rl, last, run, level);
2153
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2154
            if (code == rl->n) {
2155
              if(s->h263_flv <= 1){
2156
                put_bits(&s->pb, 1, last);
2157
                put_bits(&s->pb, 6, run);
2158

    
2159
                assert(slevel != 0);
2160

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

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

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

    
2193
#ifdef CONFIG_ENCODERS
2194

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

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

    
2211
    assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2212
    s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2213

    
2214
    time_div= s->time/s->avctx->time_base.den;
2215
    time_mod= s->time%s->avctx->time_base.den;
2216

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

    
2229
static void mpeg4_encode_gop_header(MpegEncContext * s){
2230
    int hours, minutes, seconds;
2231
    int64_t time;
2232

    
2233
    put_bits(&s->pb, 16, 0);
2234
    put_bits(&s->pb, 16, GOP_STARTCODE);
2235

    
2236
    time= s->current_picture_ptr->pts;
2237
    if(s->reordered_input_picture[1])
2238
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2239
    time= time*s->avctx->time_base.num;
2240

    
2241
    seconds= time/s->avctx->time_base.den;
2242
    minutes= seconds/60; seconds %= 60;
2243
    hours= minutes/60; minutes %= 60;
2244
    hours%=24;
2245

    
2246
    put_bits(&s->pb, 5, hours);
2247
    put_bits(&s->pb, 6, minutes);
2248
    put_bits(&s->pb, 1, 1);
2249
    put_bits(&s->pb, 6, seconds);
2250

    
2251
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2252
    put_bits(&s->pb, 1, 0); //broken link == NO
2253

    
2254
    s->last_time_base= time / s->avctx->time_base.den;
2255

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

    
2259
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2260
    int profile_and_level_indication;
2261
    int vo_ver_id;
2262

    
2263
    if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2264
        profile_and_level_indication = s->avctx->profile << 4;
2265
    }else if(s->max_b_frames || s->quarter_sample){
2266
        profile_and_level_indication= 0xF0; // adv simple
2267
    }else{
2268
        profile_and_level_indication= 0x00; // simple
2269
    }
2270

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

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

    
2283
    //FIXME levels
2284

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

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

    
2290
    put_bits(&s->pb, 16, 0);
2291
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2292

    
2293
    put_bits(&s->pb, 1, 1);
2294
        put_bits(&s->pb, 4, vo_ver_id);
2295
        put_bits(&s->pb, 3, 1); //priority
2296

    
2297
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
2298

    
2299
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2300

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

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

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

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

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

    
2331
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2332

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

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

    
2348
    put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2349
    put_bits(&s->pb, 1, 1);             /* marker bit */
2350

    
2351
    put_bits(&s->pb, 16, s->avctx->time_base.den);
2352
    if (s->time_increment_bits < 1)
2353
        s->time_increment_bits = 1;
2354
    put_bits(&s->pb, 1, 1);             /* marker bit */
2355
    put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
2356
    put_bits(&s->pb, 1, 1);             /* marker bit */
2357
    put_bits(&s->pb, 13, s->width);     /* vol width */
2358
    put_bits(&s->pb, 1, 1);             /* marker bit */
2359
    put_bits(&s->pb, 13, s->height);    /* vol height */
2360
    put_bits(&s->pb, 1, 1);             /* marker bit */
2361
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2362
    put_bits(&s->pb, 1, 1);             /* obmc disable */
2363
    if (vo_ver_id == 1) {
2364
        put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
2365
    }else{
2366
        put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
2367
    }
2368

    
2369
    put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
2370
    put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2371

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

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

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

    
2393
    ff_mpeg4_stuffing(&s->pb);
2394

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

    
2403
/* write mpeg4 VOP header */
2404
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2405
{
2406
    int time_incr;
2407
    int time_div, time_mod;
2408

    
2409
    if(s->pict_type==I_TYPE){
2410
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2411
            if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2412
                mpeg4_encode_visual_object_header(s);
2413
            if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2414
                mpeg4_encode_vol_header(s, 0, 0);
2415
        }
2416
        if(!(s->workaround_bugs & FF_BUG_MS))
2417
            mpeg4_encode_gop_header(s);
2418
    }
2419

    
2420
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2421

    
2422
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2423

    
2424
    put_bits(&s->pb, 16, 0);                /* vop header */
2425
    put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2426
    put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2427

    
2428
    assert(s->time>=0);
2429
    time_div= s->time/s->avctx->time_base.den;
2430
    time_mod= s->time%s->avctx->time_base.den;
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 can't 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 skipped 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 don't 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 can't 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, it's 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_skipped = 0;
3733
            }else{
3734
                s->mcsel=0;
3735
                s->mb_skipped = 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
        s->dsp.clear_blocks(s->block[0]);
3757
        /* decode each block */
3758
        for (i = 0; i < 6; i++) {
3759
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3760
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3761
                return -1;
3762
            }
3763
            cbp+=cbp;
3764
        }
3765
    }
3766

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

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

    
3785
/**
3786
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3787
 */
3788
static void preview_obmc(MpegEncContext *s){
3789
    GetBitContext gb= s->gb;
3790

    
3791
    int cbpc, i, pred_x, pred_y, mx, my;
3792
    int16_t *mot_val;
3793
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3794
    const int stride= s->b8_stride*2;
3795

    
3796
    for(i=0; i<4; i++)
3797
        s->block_index[i]+= 2;
3798
    for(i=4; i<6; i++)
3799
        s->block_index[i]+= 1;
3800
    s->mb_x++;
3801

    
3802
    assert(s->pict_type == P_TYPE);
3803

    
3804
    do{
3805
        if (get_bits1(&s->gb)) {
3806
            /* skip mb */
3807
            mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3808
            mot_val[0       ]= mot_val[2       ]=
3809
            mot_val[0+stride]= mot_val[2+stride]= 0;
3810
            mot_val[1       ]= mot_val[3       ]=
3811
            mot_val[1+stride]= mot_val[3+stride]= 0;
3812

    
3813
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3814
            goto end;
3815
        }
3816
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3817
    }while(cbpc == 20);
3818

    
3819
    if(cbpc & 4){
3820
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3821
    }else{
3822
        get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3823
        if (cbpc & 8) {
3824
            if(s->modified_quant){
3825
                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3826
                else                  skip_bits(&s->gb, 5);
3827
            }else
3828
                skip_bits(&s->gb, 2);
3829
        }
3830

    
3831
        if ((cbpc & 16) == 0) {
3832
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3833
                /* 16x16 motion prediction */
3834
                mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3835
                if (s->umvplus)
3836
                   mx = h263p_decode_umotion(s, pred_x);
3837
                else
3838
                   mx = h263_decode_motion(s, pred_x, 1);
3839

    
3840
                if (s->umvplus)
3841
                   my = h263p_decode_umotion(s, pred_y);
3842
                else
3843
                   my = h263_decode_motion(s, pred_y, 1);
3844

    
3845
                mot_val[0       ]= mot_val[2       ]=
3846
                mot_val[0+stride]= mot_val[2+stride]= mx;
3847
                mot_val[1       ]= mot_val[3       ]=
3848
                mot_val[1+stride]= mot_val[3+stride]= my;
3849
        } else {
3850
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3851
            for(i=0;i<4;i++) {
3852
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3853
                if (s->umvplus)
3854
                  mx = h263p_decode_umotion(s, pred_x);
3855
                else
3856
                  mx = h263_decode_motion(s, pred_x, 1);
3857

    
3858
                if (s->umvplus)
3859
                  my = h263p_decode_umotion(s, pred_y);
3860
                else
3861
                  my = h263_decode_motion(s, pred_y, 1);
3862
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3863
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3864
                mot_val[0] = mx;
3865
                mot_val[1] = my;
3866
            }
3867
        }
3868
    }
3869
end:
3870

    
3871
    for(i=0; i<4; i++)
3872
        s->block_index[i]-= 2;
3873
    for(i=4; i<6; i++)
3874
        s->block_index[i]-= 1;
3875
    s->mb_x--;
3876

    
3877
    s->gb= gb;
3878
}
3879

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

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

    
3893
int ff_h263_decode_mb(MpegEncContext *s,
3894
                      DCTELEM block[6][64])
3895
{
3896
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3897
    int16_t *mot_val;
3898
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3899

    
3900
    assert(!s->h263_pred);
3901

    
3902
    if (s->pict_type == P_TYPE) {
3903
        do{
3904
            if (get_bits1(&s->gb)) {
3905
                /* skip mb */
3906
                s->mb_intra = 0;
3907
                for(i=0;i<6;i++)
3908
                    s->block_last_index[i] = -1;
3909
                s->mv_dir = MV_DIR_FORWARD;
3910
                s->mv_type = MV_TYPE_16X16;
3911
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3912
                s->mv[0][0][0] = 0;
3913
                s->mv[0][0][1] = 0;
3914
                s->mb_skipped = !(s->obmc | s->loop_filter);
3915
                goto end;
3916
            }
3917
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3918
            //fprintf(stderr, "\tCBPC: %d", cbpc);
3919
            if (cbpc < 0){
3920
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3921
                return -1;
3922
            }
3923
        }while(cbpc == 20);
3924

    
3925
        s->dsp.clear_blocks(s->block[0]);
3926

    
3927
        dquant = cbpc & 8;
3928
        s->mb_intra = ((cbpc & 4) != 0);
3929
        if (s->mb_intra) goto intra;
3930

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

    
3933
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3934
            cbpy ^= 0xF;
3935

    
3936
        cbp = (cbpc & 3) | (cbpy << 2);
3937
        if (dquant) {
3938
            h263_decode_dquant(s);
3939
        }
3940

    
3941
        s->mv_dir = MV_DIR_FORWARD;
3942
        if ((cbpc & 16) == 0) {
3943
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3944
            /* 16x16 motion prediction */
3945
            s->mv_type = MV_TYPE_16X16;
3946
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3947
            if (s->umvplus)
3948
               mx = h263p_decode_umotion(s, pred_x);
3949
            else
3950
               mx = h263_decode_motion(s, pred_x, 1);
3951

    
3952
            if (mx >= 0xffff)
3953
                return -1;
3954

    
3955
            if (s->umvplus)
3956
               my = h263p_decode_umotion(s, pred_y);
3957
            else
3958
               my = h263_decode_motion(s, pred_y, 1);
3959

    
3960
            if (my >= 0xffff)
3961
                return -1;
3962
            s->mv[0][0][0] = mx;
3963
            s->mv[0][0][1] = my;
3964

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

    
3979
                if (s->umvplus)
3980
                  my = h263p_decode_umotion(s, pred_y);
3981
                else
3982
                  my = h263_decode_motion(s, pred_y, 1);
3983
                if (my >= 0xffff)
3984
                    return -1;
3985
                s->mv[0][i][0] = mx;
3986
                s->mv[0][i][1] = my;
3987
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3988
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3989
                mot_val[0] = mx;
3990
                mot_val[1] = my;
3991
            }
3992
        }
3993

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

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

    
4012
        //FIXME ugly
4013
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4014
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4015
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4016
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4017

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

    
4025
            mb_type= h263_mb_type_b_map[ mb_type ];
4026
        }while(!mb_type);
4027

    
4028
        s->mb_intra = IS_INTRA(mb_type);
4029
        if(HAS_CBP(mb_type)){
4030
            s->dsp.clear_blocks(s->block[0]);
4031
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4032
            if(s->mb_intra){
4033
                dquant = IS_QUANT(mb_type);
4034
                goto intra;
4035
            }
4036

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

    
4039
            if (cbpy < 0){
4040
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4041
                return -1;
4042
            }
4043

    
4044
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4045
                cbpy ^= 0xF;
4046

    
4047
            cbp = (cbpc & 3) | (cbpy << 2);
4048
        }else
4049
            cbp=0;
4050

    
4051
        assert(!s->mb_intra);
4052

    
4053
        if(IS_QUANT(mb_type)){
4054
            h263_decode_dquant(s);
4055
        }
4056

    
4057
        if(IS_DIRECT(mb_type)){
4058
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4059
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4060
        }else{
4061
            s->mv_dir = 0;
4062
            s->mv_type= MV_TYPE_16X16;
4063
//FIXME UMV
4064

    
4065
            if(USES_LIST(mb_type, 0)){
4066
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4067
                s->mv_dir = MV_DIR_FORWARD;
4068

    
4069
                mx = h263_decode_motion(s, mx, 1);
4070
                my = h263_decode_motion(s, my, 1);
4071

    
4072
                s->mv[0][0][0] = mx;
4073
                s->mv[0][0][1] = my;
4074
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4075
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4076
            }
4077

    
4078
            if(USES_LIST(mb_type, 1)){
4079
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4080
                s->mv_dir |= MV_DIR_BACKWARD;
4081

    
4082
                mx = h263_decode_motion(s, mx, 1);
4083
                my = h263_decode_motion(s, my, 1);
4084

    
4085
                s->mv[1][0][0] = mx;
4086
                s->mv[1][0][1] = my;
4087
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4088
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4089
            }
4090
        }
4091

    
4092
        s->current_picture.mb_type[xy]= mb_type;
4093

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

    
4109
        s->dsp.clear_blocks(s->block[0]);
4110

    
4111
        dquant = cbpc & 4;
4112
        s->mb_intra = 1;
4113
intra:
4114
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4115
        if (s->h263_aic) {
4116
            s->ac_pred = get_bits1(&s->gb);
4117
            if(s->ac_pred){
4118
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4119

    
4120
                s->h263_aic_dir = get_bits1(&s->gb);
4121
            }
4122
        }else
4123
            s->ac_pred = 0;
4124

    
4125
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4126
        if(cbpy<0){
4127
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4128
            return -1;
4129
        }
4130
        cbp = (cbpc & 3) | (cbpy << 2);
4131
        if (dquant) {
4132
            h263_decode_dquant(s);
4133
        }
4134

    
4135
        /* decode each block */
4136
        for (i = 0; i < 6; i++) {
4137
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4138
                return -1;
4139
            cbp+=cbp;
4140
        }
4141
    }
4142
end:
4143

    
4144
        /* per-MB end of slice check */
4145
    {
4146
        int v= show_bits(&s->gb, 16);
4147

    
4148
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4149
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4150
        }
4151

    
4152
        if(v==0)
4153
            return SLICE_END;
4154
    }
4155

    
4156
    return SLICE_OK;
4157
}
4158

    
4159
int ff_mpeg4_decode_mb(MpegEncContext *s,
4160
                      DCTELEM block[6][64])
4161
{
4162
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4163
    int16_t *mot_val;
4164
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4165
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4166

    
4167
    assert(s->h263_pred);
4168

    
4169
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4170
        do{
4171
            if (get_bits1(&s->gb)) {
4172
                /* skip mb */
4173
                s->mb_intra = 0;
4174
                for(i=0;i<6;i++)
4175
                    s->block_last_index[i] = -1;
4176
                s->mv_dir = MV_DIR_FORWARD;
4177
                s->mv_type = MV_TYPE_16X16;
4178
                if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4179
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4180
                    s->mcsel=1;
4181
                    s->mv[0][0][0]= get_amv(s, 0);
4182
                    s->mv[0][0][1]= get_amv(s, 1);
4183

    
4184
                    s->mb_skipped = 0;
4185
                }else{
4186
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4187
                    s->mcsel=0;
4188
                    s->mv[0][0][0] = 0;
4189
                    s->mv[0][0][1] = 0;
4190
                    s->mb_skipped = 1;
4191
                }
4192
                goto end;
4193
            }
4194
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4195
            //fprintf(stderr, "\tCBPC: %d", cbpc);
4196
            if (cbpc < 0){
4197
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4198
                return -1;
4199
            }
4200
        }while(cbpc == 20);
4201

    
4202
        s->dsp.clear_blocks(s->block[0]);
4203
        dquant = cbpc & 8;
4204
        s->mb_intra = ((cbpc & 4) != 0);
4205
        if (s->mb_intra) goto intra;
4206

    
4207
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4208
            s->mcsel= get_bits1(&s->gb);
4209
        else s->mcsel= 0;
4210
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4211

    
4212
        cbp = (cbpc & 3) | (cbpy << 2);
4213
        if (dquant) {
4214
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4215
        }
4216
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4217
            s->interlaced_dct= get_bits1(&s->gb);
4218

    
4219
        s->mv_dir = MV_DIR_FORWARD;
4220
        if ((cbpc & 16) == 0) {
4221
            if(s->mcsel){
4222
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4223
                /* 16x16 global motion prediction */
4224
                s->mv_type = MV_TYPE_16X16;
4225
                mx= get_amv(s, 0);
4226
                my= get_amv(s, 1);
4227
                s->mv[0][0][0] = mx;
4228
                s->mv[0][0][1] = my;
4229
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4230
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4231
                /* 16x8 field motion prediction */
4232
                s->mv_type= MV_TYPE_FIELD;
4233

    
4234
                s->field_select[0][0]= get_bits1(&s->gb);
4235
                s->field_select[0][1]= get_bits1(&s->gb);
4236

    
4237
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4238

    
4239
                for(i=0; i<2; i++){
4240
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4241
                    if (mx >= 0xffff)
4242
                        return -1;
4243

    
4244
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4245
                    if (my >= 0xffff)
4246
                        return -1;
4247

    
4248
                    s->mv[0][i][0] = mx;
4249
                    s->mv[0][i][1] = my;
4250
                }
4251
            }else{
4252
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4253
                /* 16x16 motion prediction */
4254
                s->mv_type = MV_TYPE_16X16;
4255
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4256
                mx = h263_decode_motion(s, pred_x, s->f_code);
4257

    
4258
                if (mx >= 0xffff)
4259
                    return -1;
4260

    
4261
                my = h263_decode_motion(s, pred_y, s->f_code);
4262

    
4263
                if (my >= 0xffff)
4264
                    return -1;
4265
                s->mv[0][0][0] = mx;
4266
                s->mv[0][0][1] = my;
4267
            }
4268
        } else {
4269
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4270
            s->mv_type = MV_TYPE_8X8;
4271
            for(i=0;i<4;i++) {
4272
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4273
                mx = h263_decode_motion(s, pred_x, s->f_code);
4274
                if (mx >= 0xffff)
4275
                    return -1;
4276

    
4277
                my = h263_decode_motion(s, pred_y, s->f_code);
4278
                if (my >= 0xffff)
4279
                    return -1;
4280
                s->mv[0][i][0] = mx;
4281
                s->mv[0][i][1] = my;
4282
                mot_val[0] = mx;
4283
                mot_val[1] = my;
4284
            }
4285
        }
4286
    } else if(s->pict_type==B_TYPE) {
4287
        int modb1; // first bit of modb
4288
        int modb2; // second bit of modb
4289
        int mb_type;
4290

    
4291
        s->mb_intra = 0; //B-frames never contain intra blocks
4292
        s->mcsel=0;      //     ...               true gmc blocks
4293

    
4294
        if(s->mb_x==0){
4295
            for(i=0; i<2; i++){
4296
                s->last_mv[i][0][0]=
4297
                s->last_mv[i][0][1]=
4298
                s->last_mv[i][1][0]=
4299
                s->last_mv[i][1][1]= 0;
4300
            }
4301
        }
4302

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

    
4306
        if(s->mb_skipped){
4307
                /* skip mb */
4308
            for(i=0;i<6;i++)
4309
                s->block_last_index[i] = -1;
4310

    
4311
            s->mv_dir = MV_DIR_FORWARD;
4312
            s->mv_type = MV_TYPE_16X16;
4313
            s->mv[0][0][0] = 0;
4314
            s->mv[0][0][1] = 0;
4315
            s->mv[1][0][0] = 0;
4316
            s->mv[1][0][1] = 0;
4317
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4318
            goto end;
4319
        }
4320

    
4321
        modb1= get_bits1(&s->gb);
4322
        if(modb1){
4323
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4324
            cbp=0;
4325
        }else{
4326
            modb2= get_bits1(&s->gb);
4327
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4328
            if(mb_type<0){
4329
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4330
                return -1;
4331
            }
4332
            mb_type= mb_type_b_map[ mb_type ];
4333
            if(modb2) cbp= 0;
4334
            else{
4335
                s->dsp.clear_blocks(s->block[0]);
4336
                cbp= get_bits(&s->gb, 6);
4337
            }
4338

    
4339
            if ((!IS_DIRECT(mb_type)) && cbp) {
4340
                if(get_bits1(&s->gb)){
4341
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4342
                }
4343
            }
4344

    
4345
            if(!s->progressive_sequence){
4346
                if(cbp)
4347
                    s->interlaced_dct= get_bits1(&s->gb);
4348

    
4349
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4350
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4351
                    mb_type &= ~MB_TYPE_16x16;
4352

    
4353
                    if(USES_LIST(mb_type, 0)){
4354
                        s->field_select[0][0]= get_bits1(&s->gb);
4355
                        s->field_select[0][1]= get_bits1(&s->gb);
4356
                    }
4357
                    if(USES_LIST(mb_type, 1)){
4358
                        s->field_select[1][0]= get_bits1(&s->gb);
4359
                        s->field_select[1][1]= get_bits1(&s->gb);
4360
                    }
4361
                }
4362
            }
4363

    
4364
            s->mv_dir = 0;
4365
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4366
                s->mv_type= MV_TYPE_16X16;
4367

    
4368
                if(USES_LIST(mb_type, 0)){
4369
                    s->mv_dir = MV_DIR_FORWARD;
4370

    
4371
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4372
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4373
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4374
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4375
                }
4376

    
4377
                if(USES_LIST(mb_type, 1)){
4378
                    s->mv_dir |= MV_DIR_BACKWARD;
4379

    
4380
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4381
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4382
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4383
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4384
                }
4385
            }else if(!IS_DIRECT(mb_type)){
4386
                s->mv_type= MV_TYPE_FIELD;
4387

    
4388
                if(USES_LIST(mb_type, 0)){
4389
                    s->mv_dir = MV_DIR_FORWARD;
4390

    
4391
                    for(i=0; i<2; i++){
4392
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4393
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4394
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4395
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4396
                    }
4397
                }
4398

    
4399
                if(USES_LIST(mb_type, 1)){
4400
                    s->mv_dir |= MV_DIR_BACKWARD;
4401

    
4402
                    for(i=0; i<2; i++){
4403
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4404
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4405
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4406
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4407
                    }
4408
                }
4409
            }
4410
        }
4411

    
4412
        if(IS_DIRECT(mb_type)){
4413
            if(IS_SKIP(mb_type))
4414
                mx=my=0;
4415
            else{
4416
                mx = h263_decode_motion(s, 0, 1);
4417
                my = h263_decode_motion(s, 0, 1);
4418
            }
4419

    
4420
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4421
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4422
        }
4423
        s->current_picture.mb_type[xy]= mb_type;
4424
    } else { /* I-Frame */
4425
        do{
4426
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4427
            if (cbpc < 0){
4428
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4429
                return -1;
4430
            }
4431
        }while(cbpc == 8);
4432

    
4433
        dquant = cbpc & 4;
4434
        s->mb_intra = 1;
4435
intra:
4436
        s->ac_pred = get_bits1(&s->gb);
4437
        if(s->ac_pred)
4438
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4439
        else
4440
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4441

    
4442
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4443
        if(cbpy<0){
4444
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4445
            return -1;
4446
        }
4447
        cbp = (cbpc & 3) | (cbpy << 2);
4448
        if (dquant) {
4449
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4450
        }
4451

    
4452
        if(!s->progressive_sequence)
4453
            s->interlaced_dct= get_bits1(&s->gb);
4454

    
4455
        s->dsp.clear_blocks(s->block[0]);
4456
        /* decode each block */
4457
        for (i = 0; i < 6; i++) {
4458
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4459
                return -1;
4460
            cbp+=cbp;
4461
        }
4462
        goto end;
4463
    }
4464

    
4465
    /* decode each block */
4466
    for (i = 0; i < 6; i++) {
4467
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4468
            return -1;
4469
        cbp+=cbp;
4470
    }
4471
end:
4472

    
4473
        /* per-MB end of slice check */
4474
    if(s->codec_id==CODEC_ID_MPEG4){
4475
        if(mpeg4_is_resync(s)){
4476
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4477
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4478
                return SLICE_OK;
4479
            return SLICE_END;
4480
        }
4481
    }
4482

    
4483
    return SLICE_OK;
4484
}
4485

    
4486
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4487
{
4488
    int code, val, sign, shift, l;
4489
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4490

    
4491
    if (code == 0)
4492
        return pred;
4493
    if (code < 0)
4494
        return 0xffff;
4495

    
4496
    sign = get_bits1(&s->gb);
4497
    shift = f_code - 1;
4498
    val = code;
4499
    if (shift) {
4500
        val = (val - 1) << shift;
4501
        val |= get_bits(&s->gb, shift);
4502
        val++;
4503
    }
4504
    if (sign)
4505
        val = -val;
4506
    val += pred;
4507

    
4508
    /* modulo decoding */
4509
    if (!s->h263_long_vectors) {
4510
        l = INT_BIT - 5 - f_code;
4511
        val = (val<<l)>>l;
4512
    } else {
4513
        /* horrible h263 long vector mode */
4514
        if (pred < -31 && val < -63)
4515
            val += 64;
4516
        if (pred > 32 && val > 63)
4517
            val -= 64;
4518

    
4519
    }
4520
    return val;
4521
}
4522

    
4523
/* Decodes RVLC of H.263+ UMV */
4524
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4525
{
4526
   int code = 0, sign;
4527

    
4528
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4529
      return pred;
4530

    
4531
   code = 2 + get_bits1(&s->gb);
4532

    
4533
   while (get_bits1(&s->gb))
4534
   {
4535
      code <<= 1;
4536
      code += get_bits1(&s->gb);
4537
   }
4538
   sign = code & 1;
4539
   code >>= 1;
4540

    
4541
   code = (sign) ? (pred - code) : (pred + code);
4542
#ifdef DEBUG
4543
   av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4544
#endif
4545
   return code;
4546

    
4547
}
4548

    
4549
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4550
                             int n, int coded)
4551
{
4552
    int code, level, i, j, last, run;
4553
    RLTable *rl = &rl_inter;
4554
    const uint8_t *scan_table;
4555
    GetBitContext gb= s->gb;
4556

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

    
4679
/**
4680
 * decodes the dc value.
4681
 * @param n block index (0-3 are luma, 4-5 are chroma)
4682
 * @param dir_ptr the prediction direction will be stored here
4683
 * @return the quantized dc
4684
 */
4685
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4686
{
4687
    int level, code;
4688

    
4689
    if (n < 4)
4690
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4691
    else
4692
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4693
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4694
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4695
        return -1;
4696
    }
4697
    if (code == 0) {
4698
        level = 0;
4699
    } else {
4700
        if(IS_3IV1){
4701
            if(code==1)
4702
                level= 2*get_bits1(&s->gb)-1;
4703
            else{
4704
                if(get_bits1(&s->gb))
4705
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4706
                else
4707
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4708
            }
4709
        }else{
4710
            level = get_xbits(&s->gb, code);
4711
        }
4712

    
4713
        if (code > 8){
4714
            if(get_bits1(&s->gb)==0){ /* marker */
4715
                if(s->error_resilience>=2){
4716
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4717
                    return -1;
4718
                }
4719
            }
4720
        }
4721
    }
4722

    
4723
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4724
}
4725

    
4726
/**
4727
 * decodes a block.
4728
 * @return <0 if an error occured
4729
 */
4730
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4731
                              int n, int coded, int intra, int rvlc)
4732
{
4733
    int level, i, last, run;
4734
    int dc_pred_dir;
4735
    RLTable * rl;
4736
    RL_VLC_ELEM * rl_vlc;
4737
    const uint8_t * scan_table;
4738
    int qmul, qadd;
4739

    
4740
    //Note intra & rvlc should be optimized away if this is inlined
4741

    
4742
    if(intra) {
4743
      if(s->qscale < s->intra_dc_threshold){
4744
        /* DC coef */
4745
        if(s->partitioned_frame){
4746
            level = s->dc_val[0][ s->block_index[n] ];
4747
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4748
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4749
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4750
        }else{
4751
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4752
            if (level < 0)
4753
                return -1;
4754
        }
4755
        block[0] = level;
4756
        i = 0;
4757
      }else{
4758
            i = -1;
4759
            ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4760
      }
4761
        if (!coded)
4762
            goto not_coded;
4763

    
4764
        if(rvlc){
4765
            rl = &rvlc_rl_intra;
4766
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
4767
        }else{
4768
            rl = &rl_intra;
4769
            rl_vlc = rl_intra.rl_vlc[0];
4770
        }
4771
        if (s->ac_pred) {
4772
            if (dc_pred_dir == 0)
4773
                scan_table = s->intra_v_scantable.permutated; /* left */
4774
            else
4775
                scan_table = s->intra_h_scantable.permutated; /* top */
4776
        } else {
4777
            scan_table = s->intra_scantable.permutated;
4778
        }
4779
        qmul=1;
4780
        qadd=0;
4781
    } else {
4782
        i = -1;
4783
        if (!coded) {
4784
            s->block_last_index[n] = i;
4785
            return 0;
4786
        }