Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ ee3e3631

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

    
29
/**
30
 * @file libavcodec/h263.c
31
 * h263/mpeg4 codec.
32
 */
33

    
34
//#define DEBUG
35
#include <limits.h>
36

    
37
#include "dsputil.h"
38
#include "avcodec.h"
39
#include "mpegvideo.h"
40
#include "h263data.h"
41
#include "mpeg4data.h"
42
#include "mathops.h"
43

    
44
//#undef NDEBUG
45
//#include <assert.h>
46

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

    
58
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
59
                              int n);
60
static void h263p_encode_umotion(MpegEncContext * s, int val);
61
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
62
                               int n, int dc, uint8_t *scan_table,
63
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
64
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
65
                                  uint8_t *scan_table);
66

    
67
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
68
static int h263p_decode_umotion(MpegEncContext * s, int pred);
69
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
70
                             int n, int coded);
71
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
72
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
73
                              int n, int coded, int intra, int rvlc);
74

    
75
static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
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

    
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
#if 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_FCODE+1][MAX_MV*2+1];
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
static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
114

    
115
#if 0 //3IV1 is quite rare and it slows things down a tiny bit
116
#define IS_3IV1 s->codec_tag == AV_RL32("3IV1")
117
#else
118
#define IS_3IV1 0
119
#endif
120

    
121
int h263_get_picture_format(int width, int height)
122
{
123
    int format;
124

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

    
140
static void show_pict_info(MpegEncContext *s){
141
    av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
142
         s->qscale, av_get_pict_type_char(s->pict_type),
143
         s->gb.size_in_bits, 1-s->no_rounding,
144
         s->obmc ? " AP" : "",
145
         s->umvplus ? " UMV" : "",
146
         s->h263_long_vectors ? " LONG" : "",
147
         s->h263_plus ? " +" : "",
148
         s->h263_aic ? " AIC" : "",
149
         s->alt_inter_vlc ? " AIV" : "",
150
         s->modified_quant ? " MQ" : "",
151
         s->loop_filter ? " LOOP" : "",
152
         s->h263_slice_structured ? " SS" : "",
153
         s->avctx->time_base.den, s->avctx->time_base.num
154
    );
155
}
156

    
157
#if CONFIG_ENCODERS
158

    
159
static void aspect_to_info(MpegEncContext * s, AVRational aspect){
160
    int i;
161

    
162
    if(aspect.num==0) aspect= (AVRational){1,1};
163

    
164
    for(i=1; i<6; i++){
165
        if(av_cmp_q(pixel_aspect[i], aspect) == 0){
166
            s->aspect_ratio_info=i;
167
            return;
168
        }
169
    }
170

    
171
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
172
}
173

    
174
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
175
{
176
      int format;
177

    
178
      align_put_bits(&s->pb);
179

    
180
      put_bits(&s->pb, 17, 1);
181
      put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
182
      put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
183
                           s->avctx->time_base.den) & 0xff); /* TemporalReference */
184
      if (s->width == 352 && s->height == 288)
185
        format = 2;
186
      else if (s->width == 176 && s->height == 144)
187
        format = 3;
188
      else if (s->width == 128 && s->height == 96)
189
        format = 4;
190
      else if (s->width == 320 && s->height == 240)
191
        format = 5;
192
      else if (s->width == 160 && s->height == 120)
193
        format = 6;
194
      else if (s->width <= 255 && s->height <= 255)
195
        format = 0; /* use 1 byte width & height */
196
      else
197
        format = 1; /* use 2 bytes width & height */
198
      put_bits(&s->pb, 3, format); /* PictureSize */
199
      if (format == 0) {
200
        put_bits(&s->pb, 8, s->width);
201
        put_bits(&s->pb, 8, s->height);
202
      } else if (format == 1) {
203
        put_bits(&s->pb, 16, s->width);
204
        put_bits(&s->pb, 16, s->height);
205
      }
206
      put_bits(&s->pb, 2, s->pict_type == FF_P_TYPE); /* PictureType */
207
      put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
208
      put_bits(&s->pb, 5, s->qscale); /* Quantizer */
209
      put_bits(&s->pb, 1, 0); /* ExtraInformation */
210

    
211
      if(s->h263_aic){
212
        s->y_dc_scale_table=
213
          s->c_dc_scale_table= ff_aic_dc_scale_table;
214
      }else{
215
        s->y_dc_scale_table=
216
          s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
217
      }
218
}
219

    
220
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
221
{
222
    int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
223
    int best_clock_code=1;
224
    int best_divisor=60;
225
    int best_error= INT_MAX;
226

    
227
    if(s->h263_plus){
228
        for(i=0; i<2; i++){
229
            int div, error;
230
            div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
231
            div= av_clip(div, 1, 127);
232
            error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
233
            if(error < best_error){
234
                best_error= error;
235
                best_divisor= div;
236
                best_clock_code= i;
237
            }
238
        }
239
    }
240
    s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
241
    coded_frame_rate= 1800000;
242
    coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
243

    
244
    align_put_bits(&s->pb);
245

    
246
    /* Update the pointer to last GOB */
247
    s->ptr_lastgob = pbBufPtr(&s->pb);
248
    put_bits(&s->pb, 22, 0x20); /* PSC */
249
    temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
250
                         (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
251
    put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
252

    
253
    put_bits(&s->pb, 1, 1);     /* marker */
254
    put_bits(&s->pb, 1, 0);     /* h263 id */
255
    put_bits(&s->pb, 1, 0);     /* split screen off */
256
    put_bits(&s->pb, 1, 0);     /* camera  off */
257
    put_bits(&s->pb, 1, 0);     /* freeze picture release off */
258

    
259
    format = h263_get_picture_format(s->width, s->height);
260
    if (!s->h263_plus) {
261
        /* H.263v1 */
262
        put_bits(&s->pb, 3, format);
263
        put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE));
264
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
265
        of H.263v1 UMV implies to check the predicted MV after
266
        calculation of the current MB to see if we're on the limits */
267
        put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
268
        put_bits(&s->pb, 1, 0);         /* SAC: off */
269
        put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
270
        put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
271
        put_bits(&s->pb, 5, s->qscale);
272
        put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
273
    } else {
274
        int ufep=1;
275
        /* H.263v2 */
276
        /* H.263 Plus PTYPE */
277

    
278
        put_bits(&s->pb, 3, 7);
279
        put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
280
        if (format == 7)
281
            put_bits(&s->pb,3,6); /* Custom Source Format */
282
        else
283
            put_bits(&s->pb, 3, format);
284

    
285
        put_bits(&s->pb,1, s->custom_pcf);
286
        put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
287
        put_bits(&s->pb,1,0); /* SAC: off */
288
        put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
289
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
290
        put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
291
        put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
292
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
293
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
294
        put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
295
        put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
296
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
297
        put_bits(&s->pb,3,0); /* Reserved */
298

    
299
        put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE);
300

    
301
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
302
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
303
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
304
        put_bits(&s->pb,2,0); /* Reserved */
305
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
306

    
307
        /* This should be here if PLUSPTYPE */
308
        put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
309

    
310
                if (format == 7) {
311
            /* Custom Picture Format (CPFMT) */
312
            aspect_to_info(s, s->avctx->sample_aspect_ratio);
313

    
314
            put_bits(&s->pb,4,s->aspect_ratio_info);
315
            put_bits(&s->pb,9,(s->width >> 2) - 1);
316
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
317
            put_bits(&s->pb,9,(s->height >> 2));
318
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
319
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
320
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
321
            }
322
        }
323
        if(s->custom_pcf){
324
            if(ufep){
325
                put_bits(&s->pb, 1, best_clock_code);
326
                put_bits(&s->pb, 7, best_divisor);
327
            }
328
            put_sbits(&s->pb, 2, temp_ref>>8);
329
        }
330

    
331
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
332
        if (s->umvplus)
333
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
334
//FIXME check actual requested range
335
            put_bits(&s->pb,2,1); /* unlimited */
336
        if(s->h263_slice_structured)
337
            put_bits(&s->pb,2,0); /* no weird submodes */
338

    
339
        put_bits(&s->pb, 5, s->qscale);
340
    }
341

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

    
344
    if(s->h263_slice_structured){
345
        put_bits(&s->pb, 1, 1);
346

    
347
        assert(s->mb_x == 0 && s->mb_y == 0);
348
        ff_h263_encode_mba(s);
349

    
350
        put_bits(&s->pb, 1, 1);
351
    }
352

    
353
    if(s->h263_aic){
354
         s->y_dc_scale_table=
355
         s->c_dc_scale_table= ff_aic_dc_scale_table;
356
    }else{
357
        s->y_dc_scale_table=
358
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
359
    }
360
}
361

    
362
/**
363
 * Encodes a group of blocks header.
364
 */
365
void h263_encode_gob_header(MpegEncContext * s, int mb_line)
366
{
367
    put_bits(&s->pb, 17, 1); /* GBSC */
368

    
369
    if(s->h263_slice_structured){
370
        put_bits(&s->pb, 1, 1);
371

    
372
        ff_h263_encode_mba(s);
373

    
374
        if(s->mb_num > 1583)
375
            put_bits(&s->pb, 1, 1);
376
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
377
        put_bits(&s->pb, 1, 1);
378
        put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
379
    }else{
380
        int gob_number= mb_line / s->gob_index;
381

    
382
        put_bits(&s->pb, 5, gob_number); /* GN */
383
        put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
384
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
385
    }
386
}
387

    
388
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
389
    int last=0;
390
    int j;
391
    int rate=0;
392

    
393
    for(j=1; j<=block_last_index; j++){
394
        const int index= scantable[j];
395
        int level= block[index];
396
        if(level){
397
            level+= 64;
398
            if((level&(~127)) == 0){
399
                if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
400
                else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
401
            }else
402
                rate += s->ac_esc_length;
403
            level-= 64;
404

    
405
            last= j;
406
        }
407
    }
408

    
409
    return rate;
410
}
411

    
412
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
413
{
414
    int score= 0;
415
    int i, n;
416
    int8_t * const qscale_table= s->current_picture.qscale_table;
417

    
418
    memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
419

    
420
    for(n=0; n<6; n++){
421
        int16_t *ac_val, *ac_val1;
422

    
423
        score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
424

    
425
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
426
        ac_val1= ac_val;
427
        if(dir[n]){
428
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
429
            /* top prediction */
430
            ac_val-= s->block_wrap[n]*16;
431
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
432
                /* same qscale */
433
                for(i=1; i<8; i++){
434
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
435
                    block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
436
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
437
                    ac_val1[i+8]= level;
438
                }
439
            }else{
440
                /* different qscale, we must rescale */
441
                for(i=1; i<8; i++){
442
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
443
                    block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
444
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
445
                    ac_val1[i+8]= level;
446
                }
447
            }
448
            st[n]= s->intra_h_scantable.permutated;
449
        }else{
450
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
451
            /* left prediction */
452
            ac_val-= 16;
453
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
454
                /* same qscale */
455
                for(i=1; i<8; i++){
456
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
457
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
458
                    ac_val1[i  ]= level;
459
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
460
                }
461
            }else{
462
                /* different qscale, we must rescale */
463
                for(i=1; i<8; i++){
464
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
465
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
466
                    ac_val1[i  ]= level;
467
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
468
                }
469
            }
470
            st[n]= s->intra_v_scantable.permutated;
471
        }
472

    
473
        for(i=63; i>0; i--) //FIXME optimize
474
            if(block[n][ st[n][i] ]) break;
475
        s->block_last_index[n]= i;
476

    
477
        score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
478
    }
479

    
480
    return score < 0;
481
}
482

    
483
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
484
{
485
    int i, n;
486
    memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
487

    
488
    for(n=0; n<6; n++){
489
        int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
490

    
491
        st[n]= s->intra_scantable.permutated;
492
        if(dir[n]){
493
            /* top prediction */
494
            for(i=1; i<8; i++){
495
                block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
496
            }
497
        }else{
498
            /* left prediction */
499
            for(i=1; i<8; i++){
500
                block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
501
            }
502
        }
503
    }
504
}
505

    
506
/**
507
 * init s->current_picture.qscale_table from s->lambda_table
508
 */
509
static void ff_init_qscale_tab(MpegEncContext *s){
510
    int8_t * const qscale_table= s->current_picture.qscale_table;
511
    int i;
512

    
513
    for(i=0; i<s->mb_num; i++){
514
        unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
515
        int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
516
        qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax);
517
    }
518
}
519

    
520
/**
521
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
522
 */
523
void ff_clean_h263_qscales(MpegEncContext *s){
524
    int i;
525
    int8_t * const qscale_table= s->current_picture.qscale_table;
526

    
527
    ff_init_qscale_tab(s);
528

    
529
    for(i=1; i<s->mb_num; i++){
530
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
531
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
532
    }
533
    for(i=s->mb_num-2; i>=0; i--){
534
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
535
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
536
    }
537

    
538
    if(s->codec_id != CODEC_ID_H263P){
539
        for(i=1; i<s->mb_num; i++){
540
            int mb_xy= s->mb_index2xy[i];
541

    
542
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
543
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
544
            }
545
        }
546
    }
547
}
548

    
549
/**
550
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
551
 */
552
void ff_clean_mpeg4_qscales(MpegEncContext *s){
553
    int i;
554
    int8_t * const qscale_table= s->current_picture.qscale_table;
555

    
556
    ff_clean_h263_qscales(s);
557

    
558
    if(s->pict_type== FF_B_TYPE){
559
        int odd=0;
560
        /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
561

    
562
        for(i=0; i<s->mb_num; i++){
563
            int mb_xy= s->mb_index2xy[i];
564
            odd += qscale_table[mb_xy]&1;
565
        }
566

    
567
        if(2*odd > s->mb_num) odd=1;
568
        else                  odd=0;
569

    
570
        for(i=0; i<s->mb_num; i++){
571
            int mb_xy= s->mb_index2xy[i];
572
            if((qscale_table[mb_xy]&1) != odd)
573
                qscale_table[mb_xy]++;
574
            if(qscale_table[mb_xy] > 31)
575
                qscale_table[mb_xy]= 31;
576
        }
577

    
578
        for(i=1; i<s->mb_num; i++){
579
            int mb_xy= s->mb_index2xy[i];
580
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
581
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
582
            }
583
        }
584
    }
585
}
586

    
587
#endif //CONFIG_ENCODERS
588

    
589
#define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0]))
590
#define tab_bias (tab_size/2)
591

    
592
void ff_mpeg4_init_direct_mv(MpegEncContext *s){
593
    int i;
594
    for(i=0; i<tab_size; i++){
595
        s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
596
        s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
597
    }
598
}
599

    
600
static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
601
    int xy= s->block_index[i];
602
    uint16_t time_pp= s->pp_time;
603
    uint16_t time_pb= s->pb_time;
604
    int p_mx, p_my;
605

    
606
    p_mx= s->next_picture.motion_val[0][xy][0];
607
    if((unsigned)(p_mx + tab_bias) < tab_size){
608
        s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
609
        s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
610
                            : s->direct_scale_mv[1][p_mx + tab_bias];
611
    }else{
612
        s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
613
        s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
614
                            : p_mx*(time_pb - time_pp)/time_pp;
615
    }
616
    p_my= s->next_picture.motion_val[0][xy][1];
617
    if((unsigned)(p_my + tab_bias) < tab_size){
618
        s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
619
        s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
620
                            : s->direct_scale_mv[1][p_my + tab_bias];
621
    }else{
622
        s->mv[0][i][1] = p_my*time_pb/time_pp + my;
623
        s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
624
                            : p_my*(time_pb - time_pp)/time_pp;
625
    }
626
}
627

    
628
#undef tab_size
629
#undef tab_bias
630

    
631
/**
632
 *
633
 * @return the mb_type
634
 */
635
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
636
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
637
    const int colocated_mb_type= s->next_picture.mb_type[mb_index];
638
    uint16_t time_pp= s->pp_time;
639
    uint16_t time_pb= s->pb_time;
640
    int i;
641

    
642
    //FIXME avoid divides
643
    // try special case with shifts for 1 and 3 B-frames?
644

    
645
    if(IS_8X8(colocated_mb_type)){
646
        s->mv_type = MV_TYPE_8X8;
647
        for(i=0; i<4; i++){
648
            ff_mpeg4_set_one_direct_mv(s, mx, my, i);
649
        }
650
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
651
    } else if(IS_INTERLACED(colocated_mb_type)){
652
        s->mv_type = MV_TYPE_FIELD;
653
        for(i=0; i<2; i++){
654
            int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
655
            s->field_select[0][i]= field_select;
656
            s->field_select[1][i]= i;
657
            if(s->top_field_first){
658
                time_pp= s->pp_field_time - field_select + i;
659
                time_pb= s->pb_field_time - field_select + i;
660
            }else{
661
                time_pp= s->pp_field_time + field_select - i;
662
                time_pb= s->pb_field_time + field_select - i;
663
            }
664
            s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
665
            s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
666
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
667
                                : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
668
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
669
                                : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
670
        }
671
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
672
    }else{
673
        ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
674
        s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
675
        s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
676
        s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
677
        s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
678
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
679
            s->mv_type= MV_TYPE_16X16;
680
        else
681
            s->mv_type= MV_TYPE_8X8;
682
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
683
    }
684
}
685

    
686
void ff_h263_update_motion_val(MpegEncContext * s){
687
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
688
               //FIXME a lot of that is only needed for !low_delay
689
    const int wrap = s->b8_stride;
690
    const int xy = s->block_index[0];
691

    
692
    s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
693

    
694
    if(s->mv_type != MV_TYPE_8X8){
695
        int motion_x, motion_y;
696
        if (s->mb_intra) {
697
            motion_x = 0;
698
            motion_y = 0;
699
        } else if (s->mv_type == MV_TYPE_16X16) {
700
            motion_x = s->mv[0][0][0];
701
            motion_y = s->mv[0][0][1];
702
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
703
            int i;
704
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
705
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
706
            motion_x = (motion_x>>1) | (motion_x&1);
707
            for(i=0; i<2; i++){
708
                s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
709
                s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
710
            }
711
            s->current_picture.ref_index[0][xy           ]=
712
            s->current_picture.ref_index[0][xy        + 1]= s->field_select[0][0];
713
            s->current_picture.ref_index[0][xy + wrap    ]=
714
            s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
715
        }
716

    
717
        /* no update if 8X8 because it has been done during parsing */
718
        s->current_picture.motion_val[0][xy][0] = motion_x;
719
        s->current_picture.motion_val[0][xy][1] = motion_y;
720
        s->current_picture.motion_val[0][xy + 1][0] = motion_x;
721
        s->current_picture.motion_val[0][xy + 1][1] = motion_y;
722
        s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
723
        s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
724
        s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
725
        s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
726
    }
727

    
728
    if(s->encoding){ //FIXME encoding MUST be cleaned up
729
        if (s->mv_type == MV_TYPE_8X8)
730
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
731
        else if(s->mb_intra)
732
            s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
733
        else
734
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
735
    }
736
}
737

    
738
#if CONFIG_ENCODERS
739

    
740
static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
741
    int l, bit_size, code;
742

    
743
    if (val == 0) {
744
        return mvtab[0][1];
745
    } else {
746
        bit_size = f_code - 1;
747
        /* modulo encoding */
748
        l= INT_BIT - 6 - bit_size;
749
        val = (val<<l)>>l;
750
        val--;
751
        code = (val >> bit_size) + 1;
752

    
753
        return mvtab[code][1] + 1 + bit_size;
754
    }
755
}
756

    
757
static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
758
    if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
759
        skip_put_bits(&s->pb,
760
            h263_get_motion_length(s, x, f_code)
761
           +h263_get_motion_length(s, y, f_code));
762
    }else{
763
        ff_h263_encode_motion(s, x, f_code);
764
        ff_h263_encode_motion(s, y, f_code);
765
    }
766
}
767

    
768
static inline int get_p_cbp(MpegEncContext * s,
769
                      DCTELEM block[6][64],
770
                      int motion_x, int motion_y){
771
    int cbp, i;
772

    
773
    if(s->flags & CODEC_FLAG_CBP_RD){
774
        int best_cbpy_score= INT_MAX;
775
        int best_cbpc_score= INT_MAX;
776
        int cbpc = (-1), cbpy= (-1);
777
        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
778
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
779

    
780
        for(i=0; i<4; i++){
781
            int score= inter_MCBPC_bits[i + offset] * lambda;
782
            if(i&1) score += s->coded_score[5];
783
            if(i&2) score += s->coded_score[4];
784

    
785
            if(score < best_cbpc_score){
786
                best_cbpc_score= score;
787
                cbpc= i;
788
            }
789
        }
790

    
791
        for(i=0; i<16; i++){
792
            int score= cbpy_tab[i ^ 0xF][1] * lambda;
793
            if(i&1) score += s->coded_score[3];
794
            if(i&2) score += s->coded_score[2];
795
            if(i&4) score += s->coded_score[1];
796
            if(i&8) score += s->coded_score[0];
797

    
798
            if(score < best_cbpy_score){
799
                best_cbpy_score= score;
800
                cbpy= i;
801
            }
802
        }
803
        cbp= cbpc + 4*cbpy;
804
        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
805
            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
806
                cbp= 0;
807
        }
808

    
809
        for (i = 0; i < 6; i++) {
810
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
811
                s->block_last_index[i]= -1;
812
                s->dsp.clear_block(s->block[i]);
813
            }
814
        }
815
    }else{
816
        cbp= 0;
817
        for (i = 0; i < 6; i++) {
818
            if (s->block_last_index[i] >= 0)
819
                cbp |= 1 << (5 - i);
820
        }
821
    }
822
    return cbp;
823
}
824

    
825
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
826
                            int motion_x, int motion_y, int mb_type){
827
    int cbp=0, i;
828

    
829
    if(s->flags & CODEC_FLAG_CBP_RD){
830
        int score=0;
831
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
832

    
833
        for(i=0; i<6; i++){
834
            if(s->coded_score[i] < 0){
835
                score += s->coded_score[i];
836
                cbp |= 1 << (5 - i);
837
            }
838
        }
839

    
840
        if(cbp){
841
            int zero_score= -6;
842
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
843
                zero_score-= 4; //2*MV + mb_type + cbp bit
844
            }
845

    
846
            zero_score*= lambda;
847
            if(zero_score <= score){
848
                cbp=0;
849
            }
850
        }
851

    
852
        for (i = 0; i < 6; i++) {
853
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
854
                s->block_last_index[i]= -1;
855
                s->dsp.clear_block(s->block[i]);
856
            }
857
        }
858
    }else{
859
        for (i = 0; i < 6; i++) {
860
            if (s->block_last_index[i] >= 0)
861
                cbp |= 1 << (5 - i);
862
        }
863
    }
864
    return cbp;
865
}
866

    
867
static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
868
                               uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
869
    int i;
870

    
871
    if(scan_table){
872
        if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
873
            for (i = 0; i < 6; i++) {
874
                skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
875
            }
876
        }else{
877
            /* encode each block */
878
            for (i = 0; i < 6; i++) {
879
                mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
880
            }
881
        }
882
    }else{
883
        if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
884
            for (i = 0; i < 6; i++) {
885
                skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
886
            }
887
        }else{
888
            /* encode each block */
889
            for (i = 0; i < 6; i++) {
890
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
891
            }
892
        }
893
    }
894
}
895

    
896
static const int dquant_code[5]= {1,0,9,2,3};
897

    
898
void mpeg4_encode_mb(MpegEncContext * s,
899
                    DCTELEM block[6][64],
900
                    int motion_x, int motion_y)
901
{
902
    int cbpc, cbpy, pred_x, pred_y;
903
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
904
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=FF_B_TYPE ? &s->tex_pb : &s->pb;
905
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=FF_I_TYPE ? &s->pb2    : &s->pb;
906
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
907

    
908
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
909
    if (!s->mb_intra) {
910
        int i, cbp;
911

    
912
        if(s->pict_type==FF_B_TYPE){
913
            static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
914
            int mb_type=  mb_type_table[s->mv_dir];
915

    
916
            if(s->mb_x==0){
917
                for(i=0; i<2; i++){
918
                    s->last_mv[i][0][0]=
919
                    s->last_mv[i][0][1]=
920
                    s->last_mv[i][1][0]=
921
                    s->last_mv[i][1][1]= 0;
922
                }
923
            }
924

    
925
            assert(s->dquant>=-2 && s->dquant<=2);
926
            assert((s->dquant&1)==0);
927
            assert(mb_type>=0);
928

    
929
            /* nothing to do if this MB was skipped in the next P Frame */
930
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
931
                s->skip_count++;
932
                s->mv[0][0][0]=
933
                s->mv[0][0][1]=
934
                s->mv[1][0][0]=
935
                s->mv[1][0][1]= 0;
936
                s->mv_dir= MV_DIR_FORWARD; //doesn't matter
937
                s->qscale -= s->dquant;
938
//                s->mb_skipped=1;
939

    
940
                return;
941
            }
942

    
943
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
944

    
945
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
946
                /* direct MB with MV={0,0} */
947
                assert(s->dquant==0);
948

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

    
951
                if(interleaved_stats){
952
                    s->misc_bits++;
953
                    s->last_bits++;
954
                }
955
                s->skip_count++;
956
                return;
957
            }
958

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

    
964
            if(cbp && mb_type){
965
                if(s->dquant)
966
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
967
                else
968
                    put_bits(&s->pb, 1, 0);
969
            }else
970
                s->qscale -= s->dquant;
971

    
972
            if(!s->progressive_sequence){
973
                if(cbp)
974
                    put_bits(&s->pb, 1, s->interlaced_dct);
975
                if(mb_type) // not direct mode
976
                    put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
977
            }
978

    
979
            if(interleaved_stats){
980
                s->misc_bits+= get_bits_diff(s);
981
            }
982

    
983
            if(mb_type == 0){
984
                assert(s->mv_dir & MV_DIRECT);
985
                ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
986
                s->b_count++;
987
                s->f_count++;
988
            }else{
989
                assert(mb_type > 0 && mb_type < 4);
990
                if(s->mv_type != MV_TYPE_FIELD){
991
                    if(s->mv_dir & MV_DIR_FORWARD){
992
                        ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
993
                                                        s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
994
                        s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
995
                        s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
996
                        s->f_count++;
997
                    }
998
                    if(s->mv_dir & MV_DIR_BACKWARD){
999
                        ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
1000
                                                        s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
1001
                        s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
1002
                        s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
1003
                        s->b_count++;
1004
                    }
1005
                }else{
1006
                    if(s->mv_dir & MV_DIR_FORWARD){
1007
                        put_bits(&s->pb, 1, s->field_select[0][0]);
1008
                        put_bits(&s->pb, 1, s->field_select[0][1]);
1009
                    }
1010
                    if(s->mv_dir & MV_DIR_BACKWARD){
1011
                        put_bits(&s->pb, 1, s->field_select[1][0]);
1012
                        put_bits(&s->pb, 1, s->field_select[1][1]);
1013
                    }
1014
                    if(s->mv_dir & MV_DIR_FORWARD){
1015
                        for(i=0; i<2; i++){
1016
                            ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
1017
                                                            s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1018
                            s->last_mv[0][i][0]= s->mv[0][i][0];
1019
                            s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1020
                        }
1021
                        s->f_count++;
1022
                    }
1023
                    if(s->mv_dir & MV_DIR_BACKWARD){
1024
                        for(i=0; i<2; i++){
1025
                            ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
1026
                                                            s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1027
                            s->last_mv[1][i][0]= s->mv[1][i][0];
1028
                            s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1029
                        }
1030
                        s->b_count++;
1031
                    }
1032
                }
1033
            }
1034

    
1035
            if(interleaved_stats){
1036
                s->mv_bits+= get_bits_diff(s);
1037
            }
1038

    
1039
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1040

    
1041
            if(interleaved_stats){
1042
                s->p_tex_bits+= get_bits_diff(s);
1043
            }
1044

    
1045
        }else{ /* s->pict_type==FF_B_TYPE */
1046
            cbp= get_p_cbp(s, block, motion_x, motion_y);
1047

    
1048
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1049
                /* check if the B frames can skip it too, as we must skip it if we skip here
1050
                   why didn't they just compress the skip-mb bits instead of reusing them ?! */
1051
                if(s->max_b_frames>0){
1052
                    int i;
1053
                    int x,y, offset;
1054
                    uint8_t *p_pic;
1055

    
1056
                    x= s->mb_x*16;
1057
                    y= s->mb_y*16;
1058
                    if(x+16 > s->width)  x= s->width-16;
1059
                    if(y+16 > s->height) y= s->height-16;
1060

    
1061
                    offset= x + y*s->linesize;
1062
                    p_pic= s->new_picture.data[0] + offset;
1063

    
1064
                    s->mb_skipped=1;
1065
                    for(i=0; i<s->max_b_frames; i++){
1066
                        uint8_t *b_pic;
1067
                        int diff;
1068
                        Picture *pic= s->reordered_input_picture[i+1];
1069

    
1070
                        if(pic==NULL || pic->pict_type!=FF_B_TYPE) break;
1071

    
1072
                        b_pic= pic->data[0] + offset;
1073
                        if(pic->type != FF_BUFFER_TYPE_SHARED)
1074
                            b_pic+= INPLACE_OFFSET;
1075
                        diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1076
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1077
                            s->mb_skipped=0;
1078
                            break;
1079
                        }
1080
                    }
1081
                }else
1082
                    s->mb_skipped=1;
1083

    
1084
                if(s->mb_skipped==1){
1085
                    /* skip macroblock */
1086
                    put_bits(&s->pb, 1, 1);
1087

    
1088
                    if(interleaved_stats){
1089
                        s->misc_bits++;
1090
                        s->last_bits++;
1091
                    }
1092
                    s->skip_count++;
1093

    
1094
                    return;
1095
                }
1096
            }
1097

    
1098
            put_bits(&s->pb, 1, 0);     /* mb coded */
1099
            cbpc = cbp & 3;
1100
            cbpy = cbp >> 2;
1101
            cbpy ^= 0xf;
1102
            if(s->mv_type==MV_TYPE_16X16){
1103
                if(s->dquant) cbpc+= 8;
1104
                put_bits(&s->pb,
1105
                        inter_MCBPC_bits[cbpc],
1106
                        inter_MCBPC_code[cbpc]);
1107

    
1108
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1109
                if(s->dquant)
1110
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1111

    
1112
                if(!s->progressive_sequence){
1113
                    if(cbp)
1114
                        put_bits(pb2, 1, s->interlaced_dct);
1115
                    put_bits(pb2, 1, 0);
1116
                }
1117

    
1118
                if(interleaved_stats){
1119
                    s->misc_bits+= get_bits_diff(s);
1120
                }
1121

    
1122
                /* motion vectors: 16x16 mode */
1123
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1124

    
1125
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
1126
                                                motion_y - pred_y, s->f_code);
1127
            }else if(s->mv_type==MV_TYPE_FIELD){
1128
                if(s->dquant) cbpc+= 8;
1129
                put_bits(&s->pb,
1130
                        inter_MCBPC_bits[cbpc],
1131
                        inter_MCBPC_code[cbpc]);
1132

    
1133
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1134
                if(s->dquant)
1135
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
1136

    
1137
                assert(!s->progressive_sequence);
1138
                if(cbp)
1139
                    put_bits(pb2, 1, s->interlaced_dct);
1140
                put_bits(pb2, 1, 1);
1141

    
1142
                if(interleaved_stats){
1143
                    s->misc_bits+= get_bits_diff(s);
1144
                }
1145

    
1146
                /* motion vectors: 16x8 interlaced mode */
1147
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1148
                pred_y /=2;
1149

    
1150
                put_bits(&s->pb, 1, s->field_select[0][0]);
1151
                put_bits(&s->pb, 1, s->field_select[0][1]);
1152

    
1153
                ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1154
                                                s->mv[0][0][1] - pred_y, s->f_code);
1155
                ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1156
                                                s->mv[0][1][1] - pred_y, s->f_code);
1157
            }else{
1158
                assert(s->mv_type==MV_TYPE_8X8);
1159
                put_bits(&s->pb,
1160
                        inter_MCBPC_bits[cbpc+16],
1161
                        inter_MCBPC_code[cbpc+16]);
1162
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1163

    
1164
                if(!s->progressive_sequence){
1165
                    if(cbp)
1166
                        put_bits(pb2, 1, s->interlaced_dct);
1167
                }
1168

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

    
1173
                for(i=0; i<4; i++){
1174
                    /* motion vectors: 8x8 mode*/
1175
                    h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1176

    
1177
                    ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1178
                                                    s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1179
                }
1180
            }
1181

    
1182
            if(interleaved_stats){
1183
                s->mv_bits+= get_bits_diff(s);
1184
            }
1185

    
1186
            mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1187

    
1188
            if(interleaved_stats){
1189
                s->p_tex_bits+= get_bits_diff(s);
1190
            }
1191
            s->f_count++;
1192
        }
1193
    } else {
1194
        int cbp;
1195
        int dc_diff[6];   //dc values with the dc prediction subtracted
1196
        int dir[6];  //prediction direction
1197
        int zigzag_last_index[6];
1198
        uint8_t *scan_table[6];
1199
        int i;
1200

    
1201
        for(i=0; i<6; i++){
1202
            dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1203
        }
1204

    
1205
        if(s->flags & CODEC_FLAG_AC_PRED){
1206
            s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1207
            if(!s->ac_pred)
1208
                restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1209
        }else{
1210
            for(i=0; i<6; i++)
1211
                scan_table[i]= s->intra_scantable.permutated;
1212
        }
1213

    
1214
        /* compute cbp */
1215
        cbp = 0;
1216
        for (i = 0; i < 6; i++) {
1217
            if (s->block_last_index[i] >= 1)
1218
                cbp |= 1 << (5 - i);
1219
        }
1220

    
1221
        cbpc = cbp & 3;
1222
        if (s->pict_type == FF_I_TYPE) {
1223
            if(s->dquant) cbpc+=4;
1224
            put_bits(&s->pb,
1225
                intra_MCBPC_bits[cbpc],
1226
                intra_MCBPC_code[cbpc]);
1227
        } else {
1228
            if(s->dquant) cbpc+=8;
1229
            put_bits(&s->pb, 1, 0);     /* mb coded */
1230
            put_bits(&s->pb,
1231
                inter_MCBPC_bits[cbpc + 4],
1232
                inter_MCBPC_code[cbpc + 4]);
1233
        }
1234
        put_bits(pb2, 1, s->ac_pred);
1235
        cbpy = cbp >> 2;
1236
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1237
        if(s->dquant)
1238
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1239

    
1240
        if(!s->progressive_sequence){
1241
            put_bits(dc_pb, 1, s->interlaced_dct);
1242
        }
1243

    
1244
        if(interleaved_stats){
1245
            s->misc_bits+= get_bits_diff(s);
1246
        }
1247

    
1248
        mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1249

    
1250
        if(interleaved_stats){
1251
            s->i_tex_bits+= get_bits_diff(s);
1252
        }
1253
        s->i_count++;
1254

    
1255
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1256
        if(s->ac_pred)
1257
            restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1258
    }
1259
}
1260

    
1261
void h263_encode_mb(MpegEncContext * s,
1262
                    DCTELEM block[6][64],
1263
                    int motion_x, int motion_y)
1264
{
1265
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
1266
    int16_t pred_dc;
1267
    int16_t rec_intradc[6];
1268
    int16_t *dc_ptr[6];
1269
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1270

    
1271
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1272
    if (!s->mb_intra) {
1273
        /* compute cbp */
1274
        cbp= get_p_cbp(s, block, motion_x, motion_y);
1275

    
1276
        if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1277
            /* skip macroblock */
1278
            put_bits(&s->pb, 1, 1);
1279
            if(interleaved_stats){
1280
                s->misc_bits++;
1281
                s->last_bits++;
1282
            }
1283
            s->skip_count++;
1284

    
1285
            return;
1286
        }
1287
        put_bits(&s->pb, 1, 0);         /* mb coded */
1288

    
1289
        cbpc = cbp & 3;
1290
        cbpy = cbp >> 2;
1291
        if(s->alt_inter_vlc==0 || cbpc!=3)
1292
            cbpy ^= 0xF;
1293
        if(s->dquant) cbpc+= 8;
1294
        if(s->mv_type==MV_TYPE_16X16){
1295
            put_bits(&s->pb,
1296
                    inter_MCBPC_bits[cbpc],
1297
                    inter_MCBPC_code[cbpc]);
1298

    
1299
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1300
            if(s->dquant)
1301
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1302

    
1303
            if(interleaved_stats){
1304
                s->misc_bits+= get_bits_diff(s);
1305
            }
1306

    
1307
            /* motion vectors: 16x16 mode */
1308
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1309

    
1310
            if (!s->umvplus) {
1311
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
1312
                                                motion_y - pred_y, 1);
1313
            }
1314
            else {
1315
                h263p_encode_umotion(s, motion_x - pred_x);
1316
                h263p_encode_umotion(s, motion_y - pred_y);
1317
                if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1318
                    /* To prevent Start Code emulation */
1319
                    put_bits(&s->pb,1,1);
1320
            }
1321
        }else{
1322
            put_bits(&s->pb,
1323
                    inter_MCBPC_bits[cbpc+16],
1324
                    inter_MCBPC_code[cbpc+16]);
1325
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1326
            if(s->dquant)
1327
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1328

    
1329
            if(interleaved_stats){
1330
                s->misc_bits+= get_bits_diff(s);
1331
            }
1332

    
1333
            for(i=0; i<4; i++){
1334
                /* motion vectors: 8x8 mode*/
1335
                h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1336

    
1337
                motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1338
                motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1339
                if (!s->umvplus) {
1340
                    ff_h263_encode_motion_vector(s, motion_x - pred_x,
1341
                                                    motion_y - pred_y, 1);
1342
                }
1343
                else {
1344
                    h263p_encode_umotion(s, motion_x - pred_x);
1345
                    h263p_encode_umotion(s, motion_y - pred_y);
1346
                    if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1347
                        /* To prevent Start Code emulation */
1348
                        put_bits(&s->pb,1,1);
1349
                }
1350
            }
1351
        }
1352

    
1353
        if(interleaved_stats){
1354
            s->mv_bits+= get_bits_diff(s);
1355
        }
1356
    } else {
1357
        assert(s->mb_intra);
1358

    
1359
        cbp = 0;
1360
        if (s->h263_aic) {
1361
            /* Predict DC */
1362
            for(i=0; i<6; i++) {
1363
                int16_t level = block[i][0];
1364
                int scale;
1365

    
1366
                if(i<4) scale= s->y_dc_scale;
1367
                else    scale= s->c_dc_scale;
1368

    
1369
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1370
                level -= pred_dc;
1371
                /* Quant */
1372
                if (level >= 0)
1373
                    level = (level + (scale>>1))/scale;
1374
                else
1375
                    level = (level - (scale>>1))/scale;
1376

    
1377
                /* AIC can change CBP */
1378
                if (level == 0 && s->block_last_index[i] == 0)
1379
                    s->block_last_index[i] = -1;
1380

    
1381
                if(!s->modified_quant){
1382
                    if (level < -127)
1383
                        level = -127;
1384
                    else if (level > 127)
1385
                        level = 127;
1386
                }
1387

    
1388
                block[i][0] = level;
1389
                /* Reconstruction */
1390
                rec_intradc[i] = scale*level + pred_dc;
1391
                /* Oddify */
1392
                rec_intradc[i] |= 1;
1393
                //if ((rec_intradc[i] % 2) == 0)
1394
                //    rec_intradc[i]++;
1395
                /* Clipping */
1396
                if (rec_intradc[i] < 0)
1397
                    rec_intradc[i] = 0;
1398
                else if (rec_intradc[i] > 2047)
1399
                    rec_intradc[i] = 2047;
1400

    
1401
                /* Update AC/DC tables */
1402
                *dc_ptr[i] = rec_intradc[i];
1403
                if (s->block_last_index[i] >= 0)
1404
                    cbp |= 1 << (5 - i);
1405
            }
1406
        }else{
1407
            for(i=0; i<6; i++) {
1408
                /* compute cbp */
1409
                if (s->block_last_index[i] >= 1)
1410
                    cbp |= 1 << (5 - i);
1411
            }
1412
        }
1413

    
1414
        cbpc = cbp & 3;
1415
        if (s->pict_type == FF_I_TYPE) {
1416
            if(s->dquant) cbpc+=4;
1417
            put_bits(&s->pb,
1418
                intra_MCBPC_bits[cbpc],
1419
                intra_MCBPC_code[cbpc]);
1420
        } else {
1421
            if(s->dquant) cbpc+=8;
1422
            put_bits(&s->pb, 1, 0);     /* mb coded */
1423
            put_bits(&s->pb,
1424
                inter_MCBPC_bits[cbpc + 4],
1425
                inter_MCBPC_code[cbpc + 4]);
1426
        }
1427
        if (s->h263_aic) {
1428
            /* XXX: currently, we do not try to use ac prediction */
1429
            put_bits(&s->pb, 1, 0);     /* no AC prediction */
1430
        }
1431
        cbpy = cbp >> 2;
1432
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1433
        if(s->dquant)
1434
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1435

    
1436
        if(interleaved_stats){
1437
            s->misc_bits+= get_bits_diff(s);
1438
        }
1439
    }
1440

    
1441
    for(i=0; i<6; i++) {
1442
        /* encode each block */
1443
        h263_encode_block(s, block[i], i);
1444

    
1445
        /* Update INTRADC for decoding */
1446
        if (s->h263_aic && s->mb_intra) {
1447
            block[i][0] = rec_intradc[i];
1448

    
1449
        }
1450
    }
1451

    
1452
    if(interleaved_stats){
1453
        if (!s->mb_intra) {
1454
            s->p_tex_bits+= get_bits_diff(s);
1455
            s->f_count++;
1456
        }else{
1457
            s->i_tex_bits+= get_bits_diff(s);
1458
            s->i_count++;
1459
        }
1460
    }
1461
}
1462
#endif
1463

    
1464
void ff_h263_loop_filter(MpegEncContext * s){
1465
    int qp_c;
1466
    const int linesize  = s->linesize;
1467
    const int uvlinesize= s->uvlinesize;
1468
    const int xy = s->mb_y * s->mb_stride + s->mb_x;
1469
    uint8_t *dest_y = s->dest[0];
1470
    uint8_t *dest_cb= s->dest[1];
1471
    uint8_t *dest_cr= s->dest[2];
1472

    
1473
//    if(s->pict_type==FF_B_TYPE && !s->readable) return;
1474

    
1475
    /*
1476
       Diag Top
1477
       Left Center
1478
    */
1479
    if(!IS_SKIP(s->current_picture.mb_type[xy])){
1480
        qp_c= s->qscale;
1481
        s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1482
        s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1483
    }else
1484
        qp_c= 0;
1485

    
1486
    if(s->mb_y){
1487
        int qp_dt, qp_tt, qp_tc;
1488

    
1489
        if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1490
            qp_tt=0;
1491
        else
1492
            qp_tt= s->current_picture.qscale_table[xy-s->mb_stride];
1493

    
1494
        if(qp_c)
1495
            qp_tc= qp_c;
1496
        else
1497
            qp_tc= qp_tt;
1498

    
1499
        if(qp_tc){
1500
            const int chroma_qp= s->chroma_qscale_table[qp_tc];
1501
            s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
1502
            s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
1503

    
1504
            s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1505
            s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1506
        }
1507

    
1508
        if(qp_tt)
1509
            s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_tt);
1510

    
1511
        if(s->mb_x){
1512
            if(qp_tt || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1513
                qp_dt= qp_tt;
1514
            else
1515
                qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1516

    
1517
            if(qp_dt){
1518
                const int chroma_qp= s->chroma_qscale_table[qp_dt];
1519
                s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
1520
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1521
                s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1522
            }
1523
        }
1524
    }
1525

    
1526
    if(qp_c){
1527
        s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1528
        if(s->mb_y + 1 == s->mb_height)
1529
            s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1530
    }
1531

    
1532
    if(s->mb_x){
1533
        int qp_lc;
1534
        if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1535
            qp_lc= qp_c;
1536
        else
1537
            qp_lc= s->current_picture.qscale_table[xy-1];
1538

    
1539
        if(qp_lc){
1540
            s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1541
            if(s->mb_y + 1 == s->mb_height){
1542
                const int chroma_qp= s->chroma_qscale_table[qp_lc];
1543
                s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1544
                s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1545
                s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1546
            }
1547
        }
1548
    }
1549
}
1550

    
1551
#if CONFIG_ENCODERS
1552
static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1553
{
1554
    int x, y, wrap, a, c, pred_dc, scale;
1555
    int16_t *dc_val;
1556

    
1557
    /* find prediction */
1558
    if (n < 4) {
1559
        x = 2 * s->mb_x + (n & 1);
1560
        y = 2 * s->mb_y + ((n & 2) >> 1);
1561
        wrap = s->b8_stride;
1562
        dc_val = s->dc_val[0];
1563
        scale = s->y_dc_scale;
1564
    } else {
1565
        x = s->mb_x;
1566
        y = s->mb_y;
1567
        wrap = s->mb_stride;
1568
        dc_val = s->dc_val[n - 4 + 1];
1569
        scale = s->c_dc_scale;
1570
    }
1571
    /* B C
1572
     * A X
1573
     */
1574
    a = dc_val[(x - 1) + (y) * wrap];
1575
    c = dc_val[(x) + (y - 1) * wrap];
1576

    
1577
    /* No prediction outside GOB boundary */
1578
    if(s->first_slice_line && n!=3){
1579
        if(n!=2) c= 1024;
1580
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1581
    }
1582
    pred_dc = 1024;
1583
    /* just DC prediction */
1584
    if (a != 1024 && c != 1024)
1585
        pred_dc = (a + c) >> 1;
1586
    else if (a != 1024)
1587
        pred_dc = a;
1588
    else
1589
        pred_dc = c;
1590

    
1591
    /* we assume pred is positive */
1592
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1593
    *dc_val_ptr = &dc_val[x + y * wrap];
1594
    return pred_dc;
1595
}
1596
#endif /* CONFIG_ENCODERS */
1597

    
1598
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1599
{
1600
    int x, y, wrap, a, c, pred_dc, scale, i;
1601
    int16_t *dc_val, *ac_val, *ac_val1;
1602

    
1603
    /* find prediction */
1604
    if (n < 4) {
1605
        x = 2 * s->mb_x + (n & 1);
1606
        y = 2 * s->mb_y + (n>> 1);
1607
        wrap = s->b8_stride;
1608
        dc_val = s->dc_val[0];
1609
        ac_val = s->ac_val[0][0];
1610
        scale = s->y_dc_scale;
1611
    } else {
1612
        x = s->mb_x;
1613
        y = s->mb_y;
1614
        wrap = s->mb_stride;
1615
        dc_val = s->dc_val[n - 4 + 1];
1616
        ac_val = s->ac_val[n - 4 + 1][0];
1617
        scale = s->c_dc_scale;
1618
    }
1619

    
1620
    ac_val += ((y) * wrap + (x)) * 16;
1621
    ac_val1 = ac_val;
1622

    
1623
    /* B C
1624
     * A X
1625
     */
1626
    a = dc_val[(x - 1) + (y) * wrap];
1627
    c = dc_val[(x) + (y - 1) * wrap];
1628

    
1629
    /* No prediction outside GOB boundary */
1630
    if(s->first_slice_line && n!=3){
1631
        if(n!=2) c= 1024;
1632
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1633
    }
1634

    
1635
    if (s->ac_pred) {
1636
        pred_dc = 1024;
1637
        if (s->h263_aic_dir) {
1638
            /* left prediction */
1639
            if (a != 1024) {
1640
                ac_val -= 16;
1641
                for(i=1;i<8;i++) {
1642
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1643
                }
1644
                pred_dc = a;
1645
            }
1646
        } else {
1647
            /* top prediction */
1648
            if (c != 1024) {
1649
                ac_val -= 16 * wrap;
1650
                for(i=1;i<8;i++) {
1651
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1652
                }
1653
                pred_dc = c;
1654
            }
1655
        }
1656
    } else {
1657
        /* just DC prediction */
1658
        if (a != 1024 && c != 1024)
1659
            pred_dc = (a + c) >> 1;
1660
        else if (a != 1024)
1661
            pred_dc = a;
1662
        else
1663
            pred_dc = c;
1664
    }
1665

    
1666
    /* we assume pred is positive */
1667
    block[0]=block[0]*scale + pred_dc;
1668

    
1669
    if (block[0] < 0)
1670
        block[0] = 0;
1671
    else
1672
        block[0] |= 1;
1673

    
1674
    /* Update AC/DC tables */
1675
    dc_val[(x) + (y) * wrap] = block[0];
1676

    
1677
    /* left copy */
1678
    for(i=1;i<8;i++)
1679
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1680
    /* top copy */
1681
    for(i=1;i<8;i++)
1682
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1683
}
1684

    
1685
int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1686
                        int *px, int *py)
1687
{
1688
    int wrap;
1689
    int16_t *A, *B, *C, (*mot_val)[2];
1690
    static const int off[4]= {2, 1, 1, -1};
1691

    
1692
    wrap = s->b8_stride;
1693
    mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1694

    
1695
    A = mot_val[ - 1];
1696
    /* special case for first (slice) line */
1697
    if (s->first_slice_line && block<3) {
1698
        // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1699
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1700
        if(block==0){ //most common case
1701
            if(s->mb_x  == s->resync_mb_x){ //rare
1702
                *px= *py = 0;
1703
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1704
                C = mot_val[off[block] - wrap];
1705
                if(s->mb_x==0){
1706
                    *px = C[0];
1707
                    *py = C[1];
1708
                }else{
1709
                    *px = mid_pred(A[0], 0, C[0]);
1710
                    *py = mid_pred(A[1], 0, C[1]);
1711
                }
1712
            }else{
1713
                *px = A[0];
1714
                *py = A[1];
1715
            }
1716
        }else if(block==1){
1717
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1718
                C = mot_val[off[block] - wrap];
1719
                *px = mid_pred(A[0], 0, C[0]);
1720
                *py = mid_pred(A[1], 0, C[1]);
1721
            }else{
1722
                *px = A[0];
1723
                *py = A[1];
1724
            }
1725
        }else{ /* block==2*/
1726
            B = mot_val[ - wrap];
1727
            C = mot_val[off[block] - wrap];
1728
            if(s->mb_x == s->resync_mb_x) //rare
1729
                A[0]=A[1]=0;
1730

    
1731
            *px = mid_pred(A[0], B[0], C[0]);
1732
            *py = mid_pred(A[1], B[1], C[1]);
1733
        }
1734
    } else {
1735
        B = mot_val[ - wrap];
1736
        C = mot_val[off[block] - wrap];
1737
        *px = mid_pred(A[0], B[0], C[0]);
1738
        *py = mid_pred(A[1], B[1], C[1]);
1739
    }
1740
    return *mot_val;
1741
}
1742

    
1743
#if CONFIG_ENCODERS
1744
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1745
{
1746
    int range, l, bit_size, sign, code, bits;
1747

    
1748
    if (val == 0) {
1749
        /* zero vector */
1750
        code = 0;
1751
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1752
    } else {
1753
        bit_size = f_code - 1;
1754
        range = 1 << bit_size;
1755
        /* modulo encoding */
1756
        l= INT_BIT - 6 - bit_size;
1757
        val = (val<<l)>>l;
1758
        sign = val>>31;
1759
        val= (val^sign)-sign;
1760
        sign&=1;
1761

    
1762
        val--;
1763
        code = (val >> bit_size) + 1;
1764
        bits = val & (range - 1);
1765

    
1766
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1767
        if (bit_size > 0) {
1768
            put_bits(&s->pb, bit_size, bits);
1769
        }
1770
    }
1771
}
1772

    
1773
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1774
static void h263p_encode_umotion(MpegEncContext * s, int val)
1775
{
1776
    short sval = 0;
1777
    short i = 0;
1778
    short n_bits = 0;
1779
    short temp_val;
1780
    int code = 0;
1781
    int tcode;
1782

    
1783
    if ( val == 0)
1784
        put_bits(&s->pb, 1, 1);
1785
    else if (val == 1)
1786
        put_bits(&s->pb, 3, 0);
1787
    else if (val == -1)
1788
        put_bits(&s->pb, 3, 2);
1789
    else {
1790

    
1791
        sval = ((val < 0) ? (short)(-val):(short)val);
1792
        temp_val = sval;
1793

    
1794
        while (temp_val != 0) {
1795
            temp_val = temp_val >> 1;
1796
            n_bits++;
1797
        }
1798

    
1799
        i = n_bits - 1;
1800
        while (i > 0) {
1801
            tcode = (sval & (1 << (i-1))) >> (i-1);
1802
            tcode = (tcode << 1) | 1;
1803
            code = (code << 2) | tcode;
1804
            i--;
1805
        }
1806
        code = ((code << 1) | (val < 0)) << 1;
1807
        put_bits(&s->pb, (2*n_bits)+1, code);
1808
        //printf("\nVal = %d\tCode = %d", sval, code);
1809
    }
1810
}
1811

    
1812
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1813
{
1814
    int f_code;
1815
    int mv;
1816

    
1817
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1818
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1819
            int len;
1820

    
1821
            if(mv==0) len= mvtab[0][1];
1822
            else{
1823
                int val, bit_size, range, code;
1824

    
1825
                bit_size = f_code - 1;
1826
                range = 1 << bit_size;
1827

    
1828
                val=mv;
1829
                if (val < 0)
1830
                    val = -val;
1831
                val--;
1832
                code = (val >> bit_size) + 1;
1833
                if(code<33){
1834
                    len= mvtab[code][1] + 1 + bit_size;
1835
                }else{
1836
                    len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1837
                }
1838
            }
1839

    
1840
            mv_penalty[f_code][mv+MAX_MV]= len;
1841
        }
1842
    }
1843

    
1844
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1845
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1846
            fcode_tab[mv+MAX_MV]= f_code;
1847
        }
1848
    }
1849

    
1850
    for(mv=0; mv<MAX_MV*2+1; mv++){
1851
        umv_fcode_tab[mv]= 1;
1852
    }
1853
}
1854

    
1855
static void init_uni_dc_tab(void)
1856
{
1857
    int level, uni_code, uni_len;
1858

    
1859
    for(level=-256; level<256; level++){
1860
        int size, v, l;
1861
        /* find number of bits */
1862
        size = 0;
1863
        v = abs(level);
1864
        while (v) {
1865
            v >>= 1;
1866
            size++;
1867
        }
1868

    
1869
        if (level < 0)
1870
            l= (-level) ^ ((1 << size) - 1);
1871
        else
1872
            l= level;
1873

    
1874
        /* luminance */
1875
        uni_code= DCtab_lum[size][0];
1876
        uni_len = DCtab_lum[size][1];
1877

    
1878
        if (size > 0) {
1879
            uni_code<<=size; uni_code|=l;
1880
            uni_len+=size;
1881
            if (size > 8){
1882
                uni_code<<=1; uni_code|=1;
1883
                uni_len++;
1884
            }
1885
        }
1886
        uni_DCtab_lum_bits[level+256]= uni_code;
1887
        uni_DCtab_lum_len [level+256]= uni_len;
1888

    
1889
        /* chrominance */
1890
        uni_code= DCtab_chrom[size][0];
1891
        uni_len = DCtab_chrom[size][1];
1892

    
1893
        if (size > 0) {
1894
            uni_code<<=size; uni_code|=l;
1895
            uni_len+=size;
1896
            if (size > 8){
1897
                uni_code<<=1; uni_code|=1;
1898
                uni_len++;
1899
            }
1900
        }
1901
        uni_DCtab_chrom_bits[level+256]= uni_code;
1902
        uni_DCtab_chrom_len [level+256]= uni_len;
1903

    
1904
    }
1905
}
1906

    
1907
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1908
    int slevel, run, last;
1909

    
1910
    assert(MAX_LEVEL >= 64);
1911
    assert(MAX_RUN   >= 63);
1912

    
1913
    for(slevel=-64; slevel<64; slevel++){
1914
        if(slevel==0) continue;
1915
        for(run=0; run<64; run++){
1916
            for(last=0; last<=1; last++){
1917
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1918
                int level= slevel < 0 ? -slevel : slevel;
1919
                int sign= slevel < 0 ? 1 : 0;
1920
                int bits, len, code;
1921
                int level1, run1;
1922

    
1923
                len_tab[index]= 100;
1924

    
1925
                /* ESC0 */
1926
                code= get_rl_index(rl, last, run, level);
1927
                bits= rl->table_vlc[code][0];
1928
                len=  rl->table_vlc[code][1];
1929
                bits=bits*2+sign; len++;
1930

    
1931
                if(code!=rl->n && len < len_tab[index]){
1932
                    bits_tab[index]= bits;
1933
                    len_tab [index]= len;
1934
                }
1935
#if 1
1936
                /* ESC1 */
1937
                bits= rl->table_vlc[rl->n][0];
1938
                len=  rl->table_vlc[rl->n][1];
1939
                bits=bits*2;    len++; //esc1
1940
                level1= level - rl->max_level[last][run];
1941
                if(level1>0){
1942
                    code= get_rl_index(rl, last, run, level1);
1943
                    bits<<= rl->table_vlc[code][1];
1944
                    len  += rl->table_vlc[code][1];
1945
                    bits += rl->table_vlc[code][0];
1946
                    bits=bits*2+sign; len++;
1947

    
1948
                    if(code!=rl->n && len < len_tab[index]){
1949
                        bits_tab[index]= bits;
1950
                        len_tab [index]= len;
1951
                    }
1952
                }
1953
#endif
1954
#if 1
1955
                /* ESC2 */
1956
                bits= rl->table_vlc[rl->n][0];
1957
                len=  rl->table_vlc[rl->n][1];
1958
                bits=bits*4+2;    len+=2; //esc2
1959
                run1 = run - rl->max_run[last][level] - 1;
1960
                if(run1>=0){
1961
                    code= get_rl_index(rl, last, run1, level);
1962
                    bits<<= rl->table_vlc[code][1];
1963
                    len  += rl->table_vlc[code][1];
1964
                    bits += rl->table_vlc[code][0];
1965
                    bits=bits*2+sign; len++;
1966

    
1967
                    if(code!=rl->n && len < len_tab[index]){
1968
                        bits_tab[index]= bits;
1969
                        len_tab [index]= len;
1970
                    }
1971
                }
1972
#endif
1973
                /* ESC3 */
1974
                bits= rl->table_vlc[rl->n][0];
1975
                len = rl->table_vlc[rl->n][1];
1976
                bits=bits*4+3;    len+=2; //esc3
1977
                bits=bits*2+last; len++;
1978
                bits=bits*64+run; len+=6;
1979
                bits=bits*2+1;    len++;  //marker
1980
                bits=bits*4096+(slevel&0xfff); len+=12;
1981
                bits=bits*2+1;    len++;  //marker
1982

    
1983
                if(len < len_tab[index]){
1984
                    bits_tab[index]= bits;
1985
                    len_tab [index]= len;
1986
                }
1987
            }
1988
        }
1989
    }
1990
}
1991

    
1992
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1993
    int slevel, run, last;
1994

    
1995
    assert(MAX_LEVEL >= 64);
1996
    assert(MAX_RUN   >= 63);
1997

    
1998
    for(slevel=-64; slevel<64; slevel++){
1999
        if(slevel==0) continue;
2000
        for(run=0; run<64; run++){
2001
            for(last=0; last<=1; last++){
2002
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
2003
                int level= slevel < 0 ? -slevel : slevel;
2004
                int sign= slevel < 0 ? 1 : 0;
2005
                int bits, len, code;
2006

    
2007
                len_tab[index]= 100;
2008

    
2009
                /* ESC0 */
2010
                code= get_rl_index(rl, last, run, level);
2011
                bits= rl->table_vlc[code][0];
2012
                len=  rl->table_vlc[code][1];
2013
                bits=bits*2+sign; len++;
2014

    
2015
                if(code!=rl->n && len < len_tab[index]){
2016
                    if(bits_tab) bits_tab[index]= bits;
2017
                    len_tab [index]= len;
2018
                }
2019
                /* ESC */
2020
                bits= rl->table_vlc[rl->n][0];
2021
                len = rl->table_vlc[rl->n][1];
2022
                bits=bits*2+last; len++;
2023
                bits=bits*64+run; len+=6;
2024
                bits=bits*256+(level&0xff); len+=8;
2025

    
2026
                if(len < len_tab[index]){
2027
                    if(bits_tab) bits_tab[index]= bits;
2028
                    len_tab [index]= len;
2029
                }
2030
            }
2031
        }
2032
    }
2033
}
2034

    
2035
void h263_encode_init(MpegEncContext *s)
2036
{
2037
    static int done = 0;
2038

    
2039
    if (!done) {
2040
        done = 1;
2041

    
2042
        init_uni_dc_tab();
2043

    
2044
        init_rl(&rl_inter, static_rl_table_store[0]);
2045
        init_rl(&rl_intra, static_rl_table_store[1]);
2046
        init_rl(&rl_intra_aic, static_rl_table_store[2]);
2047

    
2048
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2049
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2050

    
2051
        init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2052
        init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
2053

    
2054
        init_mv_penalty_and_fcode(s);
2055
    }
2056
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2057

    
2058
    s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
2059
    s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2060
    if(s->h263_aic){
2061
        s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
2062
        s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2063
    }
2064
    s->ac_esc_length= 7+1+6+8;
2065

    
2066
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2067
    switch(s->codec_id){
2068
    case CODEC_ID_MPEG4:
2069
        s->fcode_tab= fcode_tab;
2070
        s->min_qcoeff= -2048;
2071
        s->max_qcoeff=  2047;
2072
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
2073
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2074
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
2075
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2076
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
2077
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2078
        s->ac_esc_length= 7+2+1+6+1+12+1;
2079
        s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2080
        s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2081

    
2082
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2083

    
2084
            s->avctx->extradata= av_malloc(1024);
2085
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
2086

    
2087
            if(!(s->workaround_bugs & FF_BUG_MS))
2088
                mpeg4_encode_visual_object_header(s);
2089
            mpeg4_encode_vol_header(s, 0, 0);
2090

    
2091
//            ff_mpeg4_stuffing(&s->pb); ?
2092
            flush_put_bits(&s->pb);
2093
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2094
        }
2095

    
2096
        break;
2097
    case CODEC_ID_H263P:
2098
        if(s->umvplus)
2099
            s->fcode_tab= umv_fcode_tab;
2100
        if(s->modified_quant){
2101
            s->min_qcoeff= -2047;
2102
            s->max_qcoeff=  2047;
2103
        }else{
2104
            s->min_qcoeff= -127;
2105
            s->max_qcoeff=  127;
2106
        }
2107
        break;
2108
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2109
    case CODEC_ID_FLV1:
2110
        if (s->h263_flv > 1) {
2111
            s->min_qcoeff= -1023;
2112
            s->max_qcoeff=  1023;
2113
        } else {
2114
            s->min_qcoeff= -127;
2115
            s->max_qcoeff=  127;
2116
        }
2117
        s->y_dc_scale_table=
2118
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2119
        break;
2120
    default: //nothing needed - default table already set in mpegvideo.c
2121
        s->min_qcoeff= -127;
2122
        s->max_qcoeff=  127;
2123
        s->y_dc_scale_table=
2124
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2125
    }
2126
}
2127

    
2128
/**
2129
 * encodes a 8x8 block.
2130
 * @param block the 8x8 block
2131
 * @param n block index (0-3 are luma, 4-5 are chroma)
2132
 */
2133
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2134
{
2135
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2136
    RLTable *rl;
2137

    
2138
    rl = &rl_inter;
2139
    if (s->mb_intra && !s->h263_aic) {
2140
        /* DC coef */
2141
        level = block[0];
2142
        /* 255 cannot be represented, so we clamp */
2143
        if (level > 254) {
2144
            level = 254;
2145
            block[0] = 254;
2146
        }
2147
        /* 0 cannot be represented also */
2148
        else if (level < 1) {
2149
            level = 1;
2150
            block[0] = 1;
2151
        }
2152
        if (level == 128) //FIXME check rv10
2153
            put_bits(&s->pb, 8, 0xff);
2154
        else
2155
            put_bits(&s->pb, 8, level);
2156
        i = 1;
2157
    } else {
2158
        i = 0;
2159
        if (s->h263_aic && s->mb_intra)
2160
            rl = &rl_intra_aic;
2161

    
2162
        if(s->alt_inter_vlc && !s->mb_intra){
2163
            int aic_vlc_bits=0;
2164
            int inter_vlc_bits=0;
2165
            int wrong_pos=-1;
2166
            int aic_code;
2167

    
2168
            last_index = s->block_last_index[n];
2169
            last_non_zero = i - 1;
2170
            for (; i <= last_index; i++) {
2171
                j = s->intra_scantable.permutated[i];
2172
                level = block[j];
2173
                if (level) {
2174
                    run = i - last_non_zero - 1;
2175
                    last = (i == last_index);
2176

    
2177
                    if(level<0) level= -level;
2178

    
2179
                    code = get_rl_index(rl, last, run, level);
2180
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2181
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2182
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2183

    
2184
                    if (code == rl->n) {
2185
                        inter_vlc_bits += 1+6+8-1;
2186
                    }
2187
                    if (aic_code == rl_intra_aic.n) {
2188
                        aic_vlc_bits += 1+6+8-1;
2189
                        wrong_pos += run + 1;
2190
                    }else
2191
                        wrong_pos += wrong_run[aic_code];
2192
                    last_non_zero = i;
2193
                }
2194
            }
2195
            i = 0;
2196
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2197
                rl = &rl_intra_aic;
2198
        }
2199
    }
2200

    
2201
    /* AC coefs */
2202
    last_index = s->block_last_index[n];
2203
    last_non_zero = i - 1;
2204
    for (; i <= last_index; i++) {
2205
        j = s->intra_scantable.permutated[i];
2206
        level = block[j];
2207
        if (level) {
2208
            run = i - last_non_zero - 1;
2209
            last = (i == last_index);
2210
            sign = 0;
2211
            slevel = level;
2212
            if (level < 0) {
2213
                sign = 1;
2214
                level = -level;
2215
            }
2216
            code = get_rl_index(rl, last, run, level);
2217
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2218
            if (code == rl->n) {
2219
              if(s->h263_flv <= 1){
2220
                put_bits(&s->pb, 1, last);
2221
                put_bits(&s->pb, 6, run);
2222

    
2223
                assert(slevel != 0);
2224

    
2225
                if(level < 128)
2226
                    put_sbits(&s->pb, 8, slevel);
2227
                else{
2228
                    put_bits(&s->pb, 8, 128);
2229
                    put_sbits(&s->pb, 5, slevel);
2230
                    put_sbits(&s->pb, 6, slevel>>5);
2231
                }
2232
              }else{
2233
                if(level < 64) { // 7-bit level
2234
                        put_bits(&s->pb, 1, 0);
2235
                        put_bits(&s->pb, 1, last);
2236
                        put_bits(&s->pb, 6, run);
2237

    
2238
                        put_sbits(&s->pb, 7, slevel);
2239
                    } else {
2240
                        /* 11-bit level */
2241
                        put_bits(&s->pb, 1, 1);
2242
                        put_bits(&s->pb, 1, last);
2243
                        put_bits(&s->pb, 6, run);
2244

    
2245
                        put_sbits(&s->pb, 11, slevel);
2246
                    }
2247
              }
2248
            } else {
2249
                put_bits(&s->pb, 1, sign);
2250
            }
2251
            last_non_zero = i;
2252
        }
2253
    }
2254
}
2255

    
2256
/***************************************************/
2257
/**
2258
 * add mpeg4 stuffing bits (01...1)
2259
 */
2260
void ff_mpeg4_stuffing(PutBitContext * pbc)
2261
{
2262
    int length;
2263
    put_bits(pbc, 1, 0);
2264
    length= (-put_bits_count(pbc))&7;
2265
    if(length) put_bits(pbc, length, (1<<length)-1);
2266
}
2267

    
2268
/* must be called before writing the header */
2269
void ff_set_mpeg4_time(MpegEncContext * s){
2270
    if(s->pict_type==FF_B_TYPE){
2271
        ff_mpeg4_init_direct_mv(s);
2272
    }else{
2273
        s->last_time_base= s->time_base;
2274
        s->time_base= s->time/s->avctx->time_base.den;
2275
    }
2276
}
2277

    
2278
static void mpeg4_encode_gop_header(MpegEncContext * s){
2279
    int hours, minutes, seconds;
2280
    int64_t time;
2281

    
2282
    put_bits(&s->pb, 16, 0);
2283
    put_bits(&s->pb, 16, GOP_STARTCODE);
2284

    
2285
    time= s->current_picture_ptr->pts;
2286
    if(s->reordered_input_picture[1])
2287
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2288
    time= time*s->avctx->time_base.num;
2289

    
2290
    seconds= time/s->avctx->time_base.den;
2291
    minutes= seconds/60; seconds %= 60;
2292
    hours= minutes/60; minutes %= 60;
2293
    hours%=24;
2294

    
2295
    put_bits(&s->pb, 5, hours);
2296
    put_bits(&s->pb, 6, minutes);
2297
    put_bits(&s->pb, 1, 1);
2298
    put_bits(&s->pb, 6, seconds);
2299

    
2300
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2301
    put_bits(&s->pb, 1, 0); //broken link == NO
2302

    
2303
    s->last_time_base= time / s->avctx->time_base.den;
2304

    
2305
    ff_mpeg4_stuffing(&s->pb);
2306
}
2307

    
2308
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2309
    int profile_and_level_indication;
2310
    int vo_ver_id;
2311

    
2312
    if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2313
        profile_and_level_indication = s->avctx->profile << 4;
2314
    }else if(s->max_b_frames || s->quarter_sample){
2315
        profile_and_level_indication= 0xF0; // adv simple
2316
    }else{
2317
        profile_and_level_indication= 0x00; // simple
2318
    }
2319

    
2320
    if(s->avctx->level != FF_LEVEL_UNKNOWN){
2321
        profile_and_level_indication |= s->avctx->level;
2322
    }else{
2323
        profile_and_level_indication |= 1; //level 1
2324
    }
2325

    
2326
    if(profile_and_level_indication>>4 == 0xF){
2327
        vo_ver_id= 5;
2328
    }else{
2329
        vo_ver_id= 1;
2330
    }
2331

    
2332
    //FIXME levels
2333

    
2334
    put_bits(&s->pb, 16, 0);
2335
    put_bits(&s->pb, 16, VOS_STARTCODE);
2336

    
2337
    put_bits(&s->pb, 8, profile_and_level_indication);
2338

    
2339
    put_bits(&s->pb, 16, 0);
2340
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2341

    
2342
    put_bits(&s->pb, 1, 1);
2343
        put_bits(&s->pb, 4, vo_ver_id);
2344
        put_bits(&s->pb, 3, 1); //priority
2345

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

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

    
2350
    ff_mpeg4_stuffing(&s->pb);
2351
}
2352

    
2353
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2354
{
2355
    int vo_ver_id;
2356

    
2357
    if (!CONFIG_MPEG4_ENCODER)  return;
2358

    
2359
    if(s->max_b_frames || s->quarter_sample){
2360
        vo_ver_id= 5;
2361
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2362
    }else{
2363
        vo_ver_id= 1;
2364
        s->vo_type= SIMPLE_VO_TYPE;
2365
    }
2366

    
2367
    put_bits(&s->pb, 16, 0);
2368
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2369
    put_bits(&s->pb, 16, 0);
2370
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2371

    
2372
    put_bits(&s->pb, 1, 0);             /* random access vol */
2373
    put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
2374
    if(s->workaround_bugs & FF_BUG_MS) {
2375
        put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
2376
    } else {
2377
        put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
2378
        put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2379
        put_bits(&s->pb, 3, 1);         /* is obj layer priority */
2380
    }
2381

    
2382
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2383

    
2384
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2385
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2386
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2387
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2388
    }
2389

    
2390
    if(s->workaround_bugs & FF_BUG_MS) { //
2391
        put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
2392
    } else {
2393
        put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
2394
        put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
2395
        put_bits(&s->pb, 1, s->low_delay);
2396
        put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
2397
    }
2398

    
2399
    put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2400
    put_bits(&s->pb, 1, 1);             /* marker bit */
2401

    
2402
    put_bits(&s->pb, 16, s->avctx->time_base.den);
2403
    if (s->time_increment_bits < 1)
2404
        s->time_increment_bits = 1;
2405
    put_bits(&s->pb, 1, 1);             /* marker bit */
2406
    put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
2407
    put_bits(&s->pb, 1, 1);             /* marker bit */
2408
    put_bits(&s->pb, 13, s->width);     /* vol width */
2409
    put_bits(&s->pb, 1, 1);             /* marker bit */
2410
    put_bits(&s->pb, 13, s->height);    /* vol height */
2411
    put_bits(&s->pb, 1, 1);             /* marker bit */
2412
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2413
    put_bits(&s->pb, 1, 1);             /* obmc disable */
2414
    if (vo_ver_id == 1) {
2415
        put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
2416
    }else{
2417
        put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
2418
    }
2419

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

    
2423
    if(s->mpeg_quant){
2424
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2425
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2426
    }
2427

    
2428
    if (vo_ver_id != 1)
2429
        put_bits(&s->pb, 1, s->quarter_sample);
2430
    put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2431
    s->resync_marker= s->rtp_mode;
2432
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2433
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2434
    if(s->data_partitioning){
2435
        put_bits(&s->pb, 1, 0);         /* no rvlc */
2436
    }
2437

    
2438
    if (vo_ver_id != 1){
2439
        put_bits(&s->pb, 1, 0);         /* newpred */
2440
        put_bits(&s->pb, 1, 0);         /* reduced res vop */
2441
    }
2442
    put_bits(&s->pb, 1, 0);             /* scalability */
2443

    
2444
    ff_mpeg4_stuffing(&s->pb);
2445

    
2446
    /* user data */
2447
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2448
        put_bits(&s->pb, 16, 0);
2449
        put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2450
        ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2451
    }
2452
}
2453

    
2454
/* write mpeg4 VOP header */
2455
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2456
{
2457
    int time_incr;
2458
    int time_div, time_mod;
2459

    
2460
    if(s->pict_type==FF_I_TYPE){
2461
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2462
            if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2463
                mpeg4_encode_visual_object_header(s);
2464
            if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2465
                mpeg4_encode_vol_header(s, 0, 0);
2466
        }
2467
        if(!(s->workaround_bugs & FF_BUG_MS))
2468
            mpeg4_encode_gop_header(s);
2469
    }
2470

    
2471
    s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE;
2472

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

    
2475
    put_bits(&s->pb, 16, 0);                /* vop header */
2476
    put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2477
    put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2478

    
2479
    assert(s->time>=0);
2480
    time_div= s->time/s->avctx->time_base.den;
2481
    time_mod= s->time%s->avctx->time_base.den;
2482
    time_incr= time_div - s->last_time_base;
2483
    assert(time_incr >= 0);
2484
    while(time_incr--)
2485
        put_bits(&s->pb, 1, 1);
2486

    
2487
    put_bits(&s->pb, 1, 0);
2488

    
2489
    put_bits(&s->pb, 1, 1);                             /* marker */
2490
    put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2491
    put_bits(&s->pb, 1, 1);                             /* marker */
2492
    put_bits(&s->pb, 1, 1);                             /* vop coded */
2493
    if (    s->pict_type == FF_P_TYPE
2494
        || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2495
        put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2496
    }
2497
    put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2498
    if(!s->progressive_sequence){
2499
         put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2500
         put_bits(&s->pb, 1, s->alternate_scan);
2501
    }
2502
    //FIXME sprite stuff
2503

    
2504
    put_bits(&s->pb, 5, s->qscale);
2505

    
2506
    if (s->pict_type != FF_I_TYPE)
2507
        put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2508
    if (s->pict_type == FF_B_TYPE)
2509
        put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2510
    //    printf("****frame %d\n", picture_number);
2511
}
2512

    
2513
#endif //CONFIG_ENCODERS
2514

    
2515
/**
2516
 * predicts the dc.
2517
 * encoding quantized level -> quantized diff
2518
 * decoding quantized diff -> quantized level
2519
 * @param n block index (0-3 are luma, 4-5 are chroma)
2520
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2521
 */
2522
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2523
{
2524
    int a, b, c, wrap, pred, scale, ret;
2525
    int16_t *dc_val;
2526

    
2527
    /* find prediction */
2528
    if (n < 4) {
2529
        scale = s->y_dc_scale;
2530
    } else {
2531
        scale = s->c_dc_scale;
2532
    }
2533
    if(IS_3IV1)
2534
        scale= 8;
2535

    
2536
    wrap= s->block_wrap[n];
2537
    dc_val = s->dc_val[0] + s->block_index[n];
2538

    
2539
    /* B C
2540
     * A X
2541
     */
2542
    a = dc_val[ - 1];
2543
    b = dc_val[ - 1 - wrap];
2544
    c = dc_val[ - wrap];
2545

    
2546
    /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2547
    if(s->first_slice_line && n!=3){
2548
        if(n!=2) b=c= 1024;
2549
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2550
    }
2551
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2552
        if(n==0 || n==4 || n==5)
2553
            b=1024;
2554
    }
2555

    
2556
    if (abs(a - b) < abs(b - c)) {
2557
        pred = c;
2558
        *dir_ptr = 1; /* top */
2559
    } else {
2560
        pred = a;
2561
        *dir_ptr = 0; /* left */
2562
    }
2563
    /* we assume pred is positive */
2564
    pred = FASTDIV((pred + (scale >> 1)), scale);
2565

    
2566
    if(encoding){
2567
        ret = level - pred;
2568
    }else{
2569
        level += pred;
2570
        ret= level;
2571
        if(s->error_recognition>=3){
2572
            if(level<0){
2573
                av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2574
                return -1;
2575
            }
2576
            if(level*scale > 2048 + scale){
2577
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2578
                return -1;
2579
            }
2580
        }
2581
    }
2582
    level *=scale;
2583
    if(level&(~2047)){
2584
        if(level<0)
2585
            level=0;
2586
        else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2587
            level=2047;
2588
    }
2589
    dc_val[0]= level;
2590

    
2591
    return ret;
2592
}
2593

    
2594
/**
2595
 * predicts the ac.
2596
 * @param n block index (0-3 are luma, 4-5 are chroma)
2597
 * @param dir the ac prediction direction
2598
 */
2599
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2600
                   int dir)
2601
{
2602
    int i;
2603
    int16_t *ac_val, *ac_val1;
2604
    int8_t * const qscale_table= s->current_picture.qscale_table;
2605

    
2606
    /* find prediction */
2607
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2608
    ac_val1 = ac_val;
2609
    if (s->ac_pred) {
2610
        if (dir == 0) {
2611
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2612
            /* left prediction */
2613
            ac_val -= 16;
2614

    
2615
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2616
                /* same qscale */
2617
                for(i=1;i<8;i++) {
2618
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2619
                }
2620
            }else{
2621
                /* different qscale, we must rescale */
2622
                for(i=1;i<8;i++) {
2623
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2624
                }
2625
            }
2626
        } else {
2627
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2628
            /* top prediction */
2629
            ac_val -= 16 * s->block_wrap[n];
2630

    
2631
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2632
                /* same qscale */
2633
                for(i=1;i<8;i++) {
2634
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2635
                }
2636
            }else{
2637
                /* different qscale, we must rescale */
2638
                for(i=1;i<8;i++) {
2639
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2640
                }
2641
            }
2642
        }
2643
    }
2644
    /* left copy */
2645
    for(i=1;i<8;i++)
2646
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2647

    
2648
    /* top copy */
2649
    for(i=1;i<8;i++)
2650
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2651

    
2652
}
2653

    
2654
#if CONFIG_ENCODERS
2655

    
2656
/**
2657
 * encodes the dc value.
2658
 * @param n block index (0-3 are luma, 4-5 are chroma)
2659
 */
2660
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2661
{
2662
#if 1
2663
//    if(level<-255 || level>255) printf("dc overflow\n");
2664
    level+=256;
2665
    if (n < 4) {
2666
        /* luminance */
2667
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2668
    } else {
2669
        /* chrominance */
2670
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2671
    }
2672
#else
2673
    int size, v;
2674
    /* find number of bits */
2675
    size = 0;
2676
    v = abs(level);
2677
    while (v) {
2678
        v >>= 1;
2679
        size++;
2680
    }
2681

    
2682
    if (n < 4) {
2683
        /* luminance */
2684
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2685
    } else {
2686
        /* chrominance */
2687
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2688
    }
2689

    
2690
    /* encode remaining bits */
2691
    if (size > 0) {
2692
        if (level < 0)
2693
            level = (-level) ^ ((1 << size) - 1);
2694
        put_bits(&s->pb, size, level);
2695
        if (size > 8)
2696
            put_bits(&s->pb, 1, 1);
2697
    }
2698
#endif
2699
}
2700

    
2701
static inline int mpeg4_get_dc_length(int level, int n){
2702
    if (n < 4) {
2703
        return uni_DCtab_lum_len[level + 256];
2704
    } else {
2705
        return uni_DCtab_chrom_len[level + 256];
2706
    }
2707
}
2708

    
2709
/**
2710
 * encodes a 8x8 block
2711
 * @param n block index (0-3 are luma, 4-5 are chroma)
2712
 */
2713
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2714
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2715
{
2716
    int i, last_non_zero;
2717
#if 0 //variables for the outcommented version
2718
    int code, sign, last;
2719
#endif
2720
    const RLTable *rl;
2721
    uint32_t *bits_tab;
2722
    uint8_t *len_tab;
2723
    const int last_index = s->block_last_index[n];
2724

    
2725
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2726
        /* mpeg4 based DC predictor */
2727
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2728
        if(last_index<1) return;
2729
        i = 1;
2730
        rl = &rl_intra;
2731
        bits_tab= uni_mpeg4_intra_rl_bits;
2732
        len_tab = uni_mpeg4_intra_rl_len;
2733
    } else {
2734
        if(last_index<0) return;
2735
        i = 0;
2736
        rl = &rl_inter;
2737
        bits_tab= uni_mpeg4_inter_rl_bits;
2738
        len_tab = uni_mpeg4_inter_rl_len;
2739
    }
2740

    
2741
    /* AC coefs */
2742
    last_non_zero = i - 1;
2743
#if 1
2744
    for (; i < last_index; i++) {
2745
        int level = block[ scan_table[i] ];
2746
        if (level) {
2747
            int run = i - last_non_zero - 1;
2748
            level+=64;
2749
            if((level&(~127)) == 0){
2750
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2751
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2752
            }else{ //ESC3
2753
                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);
2754
            }
2755
            last_non_zero = i;
2756
        }
2757
    }
2758
    /*if(i<=last_index)*/{
2759
        int level = block[ scan_table[i] ];
2760
        int run = i - last_non_zero - 1;
2761
        level+=64;
2762
        if((level&(~127)) == 0){
2763
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2764
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2765
        }else{ //ESC3
2766
            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);
2767
        }
2768
    }
2769
#else
2770
    for (; i <= last_index; i++) {
2771
        const int slevel = block[ scan_table[i] ];
2772
        if (slevel) {
2773
            int level;
2774
            int run = i - last_non_zero - 1;
2775
            last = (i == last_index);
2776
            sign = 0;
2777
            level = slevel;
2778
            if (level < 0) {
2779
                sign = 1;
2780
                level = -level;
2781
            }
2782
            code = get_rl_index(rl, last, run, level);
2783
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2784
            if (code == rl->n) {
2785
                int level1, run1;
2786
                level1 = level - rl->max_level[last][run];
2787
                if (level1 < 1)
2788
                    goto esc2;
2789
                code = get_rl_index(rl, last, run, level1);
2790
                if (code == rl->n) {
2791
                esc2:
2792
                    put_bits(ac_pb, 1, 1);
2793
                    if (level > MAX_LEVEL)
2794
                        goto esc3;
2795
                    run1 = run - rl->max_run[last][level] - 1;
2796
                    if (run1 < 0)
2797
                        goto esc3;
2798
                    code = get_rl_index(rl, last, run1, level);
2799
                    if (code == rl->n) {
2800
                    esc3:
2801
                        /* third escape */
2802
                        put_bits(ac_pb, 1, 1);
2803
                        put_bits(ac_pb, 1, last);
2804
                        put_bits(ac_pb, 6, run);
2805
                        put_bits(ac_pb, 1, 1);
2806
                        put_sbits(ac_pb, 12, slevel);
2807
                        put_bits(ac_pb, 1, 1);
2808
                    } else {
2809
                        /* second escape */
2810
                        put_bits(ac_pb, 1, 0);
2811
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2812
                        put_bits(ac_pb, 1, sign);
2813
                    }
2814
                } else {
2815
                    /* first escape */
2816
                    put_bits(ac_pb, 1, 0);
2817
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2818
                    put_bits(ac_pb, 1, sign);
2819
                }
2820
            } else {
2821
                put_bits(ac_pb, 1, sign);
2822
            }
2823
            last_non_zero = i;
2824
        }
2825
    }
2826
#endif
2827
}
2828

    
2829
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2830
                               uint8_t *scan_table)
2831
{
2832
    int i, last_non_zero;
2833
    const RLTable *rl;
2834
    uint8_t *len_tab;
2835
    const int last_index = s->block_last_index[n];
2836
    int len=0;
2837

    
2838
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2839
        /* mpeg4 based DC predictor */
2840
        len += mpeg4_get_dc_length(intra_dc, n);
2841
        if(last_index<1) return len;
2842
        i = 1;
2843
        rl = &rl_intra;
2844
        len_tab = uni_mpeg4_intra_rl_len;
2845
    } else {
2846
        if(last_index<0) return 0;
2847
        i = 0;
2848
        rl = &rl_inter;
2849
        len_tab = uni_mpeg4_inter_rl_len;
2850
    }
2851

    
2852
    /* AC coefs */
2853
    last_non_zero = i - 1;
2854
    for (; i < last_index; i++) {
2855
        int level = block[ scan_table[i] ];
2856
        if (level) {
2857
            int run = i - last_non_zero - 1;
2858
            level+=64;
2859
            if((level&(~127)) == 0){
2860
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2861
                len += len_tab[index];
2862
            }else{ //ESC3
2863
                len += 7+2+1+6+1+12+1;
2864
            }
2865
            last_non_zero = i;
2866
        }
2867
    }
2868
    /*if(i<=last_index)*/{
2869
        int level = block[ scan_table[i] ];
2870
        int run = i - last_non_zero - 1;
2871
        level+=64;
2872
        if((level&(~127)) == 0){
2873
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2874
            len += len_tab[index];
2875
        }else{ //ESC3
2876
            len += 7+2+1+6+1+12+1;
2877
        }
2878
    }
2879

    
2880
    return len;
2881
}
2882

    
2883
#endif
2884

    
2885

    
2886
/***********************************************/
2887
/* decoding */
2888

    
2889
static VLC intra_MCBPC_vlc;
2890
static VLC inter_MCBPC_vlc;
2891
static VLC cbpy_vlc;
2892
static VLC mv_vlc;
2893
static VLC dc_lum, dc_chrom;
2894
static VLC sprite_trajectory;
2895
static VLC mb_type_b_vlc;
2896
static VLC h263_mbtype_b_vlc;
2897
static VLC cbpc_b_vlc;
2898

    
2899
/* init vlcs */
2900

    
2901
/* XXX: find a better solution to handle static init */
2902
void h263_decode_init_vlc(MpegEncContext *s)
2903
{
2904
    static int done = 0;
2905

    
2906
    if (!done) {
2907
        done = 1;
2908

    
2909
        INIT_VLC_STATIC(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2910
                 intra_MCBPC_bits, 1, 1,
2911
                 intra_MCBPC_code, 1, 1, 72);
2912
        INIT_VLC_STATIC(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2913
                 inter_MCBPC_bits, 1, 1,
2914
                 inter_MCBPC_code, 1, 1, 198);
2915
        INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16,
2916
                 &cbpy_tab[0][1], 2, 1,
2917
                 &cbpy_tab[0][0], 2, 1, 64);
2918
        INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33,
2919
                 &mvtab[0][1], 2, 1,
2920
                 &mvtab[0][0], 2, 1, 538);
2921
        init_rl(&rl_inter, static_rl_table_store[0]);
2922
        init_rl(&rl_intra, static_rl_table_store[1]);
2923
        init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2924
        init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2925
        init_rl(&rl_intra_aic, static_rl_table_store[2]);
2926
        INIT_VLC_RL(rl_inter, 554);
2927
        INIT_VLC_RL(rl_intra, 554);
2928
        INIT_VLC_RL(rvlc_rl_inter, 1072);
2929
        INIT_VLC_RL(rvlc_rl_intra, 1072);
2930
        INIT_VLC_RL(rl_intra_aic, 554);
2931
        INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2932
                 &DCtab_lum[0][1], 2, 1,
2933
                 &DCtab_lum[0][0], 2, 1, 512);
2934
        INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2935
                 &DCtab_chrom[0][1], 2, 1,
2936
                 &DCtab_chrom[0][0], 2, 1, 512);
2937
        INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2938
                 &sprite_trajectory_tab[0][1], 4, 2,
2939
                 &sprite_trajectory_tab[0][0], 4, 2, 128);
2940
        INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2941
                 &mb_type_b_tab[0][1], 2, 1,
2942
                 &mb_type_b_tab[0][0], 2, 1, 16);
2943
        INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2944
                 &h263_mbtype_b_tab[0][1], 2, 1,
2945
                 &h263_mbtype_b_tab[0][0], 2, 1, 80);
2946
        INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2947
                 &cbpc_b_tab[0][1], 2, 1,
2948
                 &cbpc_b_tab[0][0], 2, 1, 8);
2949
    }
2950
}
2951

    
2952
/**
2953
 * Get the GOB height based on picture height.
2954
 */
2955
int ff_h263_get_gob_height(MpegEncContext *s){
2956
    if (s->height <= 400)
2957
        return 1;
2958
    else if (s->height <= 800)
2959
        return  2;
2960
    else
2961
        return 4;
2962
}
2963

    
2964
int ff_h263_decode_mba(MpegEncContext *s)
2965
{
2966
    int i, mb_pos;
2967

    
2968
    for(i=0; i<6; i++){
2969
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2970
    }
2971
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2972
    s->mb_x= mb_pos % s->mb_width;
2973
    s->mb_y= mb_pos / s->mb_width;
2974

    
2975
    return mb_pos;
2976
}
2977

    
2978
void ff_h263_encode_mba(MpegEncContext *s)
2979
{
2980
    int i, mb_pos;
2981

    
2982
    for(i=0; i<6; i++){
2983
        if(s->mb_num-1 <= ff_mba_max[i]) break;
2984
    }
2985
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
2986
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
2987
}
2988

    
2989
/**
2990
 * decodes the group of blocks header or slice header.
2991
 * @return <0 if an error occurred
2992
 */
2993
static int h263_decode_gob_header(MpegEncContext *s)
2994
{
2995
    unsigned int val, gfid, gob_number;
2996
    int left;
2997

    
2998
    /* Check for GOB Start Code */
2999
    val = show_bits(&s->gb, 16);
3000
    if(val)
3001
        return -1;
3002

    
3003
        /* We have a GBSC probably with GSTUFF */
3004
    skip_bits(&s->gb, 16); /* Drop the zeros */
3005
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3006
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3007
    for(;left>13; left--){
3008
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3009
    }
3010
    if(left<=13)
3011
        return -1;
3012

    
3013
    if(s->h263_slice_structured){
3014
        if(get_bits1(&s->gb)==0)
3015
            return -1;
3016

    
3017
        ff_h263_decode_mba(s);
3018

    
3019
        if(s->mb_num > 1583)
3020
            if(get_bits1(&s->gb)==0)
3021
                return -1;
3022

    
3023
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3024
        if(get_bits1(&s->gb)==0)
3025
            return -1;
3026
        gfid = get_bits(&s->gb, 2); /* GFID */
3027
    }else{
3028
        gob_number = get_bits(&s->gb, 5); /* GN */
3029
        s->mb_x= 0;
3030
        s->mb_y= s->gob_index* gob_number;
3031
        gfid = get_bits(&s->gb, 2); /* GFID */
3032
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3033
    }
3034

    
3035
    if(s->mb_y >= s->mb_height)
3036
        return -1;
3037

    
3038
    if(s->qscale==0)
3039
        return -1;
3040

    
3041
    return 0;
3042
}
3043

    
3044
static inline void memsetw(short *tab, int val, int n)
3045
{
3046
    int i;
3047
    for(i=0;i<n;i++)
3048
        tab[i] = val;
3049
}
3050

    
3051
#if CONFIG_ENCODERS
3052

    
3053
void ff_mpeg4_init_partitions(MpegEncContext *s)
3054
{
3055
    uint8_t *start= pbBufPtr(&s->pb);
3056
    uint8_t *end= s->pb.buf_end;
3057
    int size= end - start;
3058
    int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3059
    int tex_size= (size - 2*pb_size)&(~3);
3060

    
3061
    set_put_bits_buffer_size(&s->pb, pb_size);
3062
    init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3063
    init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3064
}
3065

    
3066
void ff_mpeg4_merge_partitions(MpegEncContext *s)
3067
{
3068
    const int pb2_len   = put_bits_count(&s->pb2   );
3069
    const int tex_pb_len= put_bits_count(&s->tex_pb);
3070
    const int bits= put_bits_count(&s->pb);
3071

    
3072
    if(s->pict_type==FF_I_TYPE){
3073
        put_bits(&s->pb, 19, DC_MARKER);
3074
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3075
        s->i_tex_bits+= tex_pb_len;
3076
    }else{
3077
        put_bits(&s->pb, 17, MOTION_MARKER);
3078
        s->misc_bits+=17 + pb2_len;
3079
        s->mv_bits+= bits - s->last_bits;
3080
        s->p_tex_bits+= tex_pb_len;
3081
    }
3082

    
3083
    flush_put_bits(&s->pb2);
3084
    flush_put_bits(&s->tex_pb);
3085

    
3086
    set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3087
    ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3088
    ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3089
    s->last_bits= put_bits_count(&s->pb);
3090
}
3091

    
3092
#endif //CONFIG_ENCODERS
3093

    
3094
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3095
    switch(s->pict_type){
3096
        case FF_I_TYPE:
3097
            return 16;
3098
        case FF_P_TYPE:
3099
        case FF_S_TYPE:
3100
            return s->f_code+15;
3101
        case FF_B_TYPE:
3102
            return FFMAX3(s->f_code, s->b_code, 2) + 15;
3103
        default:
3104
            return -1;
3105
    }
3106
}
3107

    
3108
#if CONFIG_ENCODERS
3109

    
3110
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3111
{
3112
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3113

    
3114
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3115
    put_bits(&s->pb, 1, 1);
3116

    
3117
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3118
    put_bits(&s->pb, s->quant_precision, s->qscale);
3119
    put_bits(&s->pb, 1, 0); /* no HEC */
3120
}
3121

    
3122
#endif //CONFIG_ENCODERS
3123

    
3124
/**
3125
 * check if the next stuff is a resync marker or the end.
3126
 * @return 0 if not
3127
 */
3128
static inline int mpeg4_is_resync(MpegEncContext *s){
3129
    int bits_count= get_bits_count(&s->gb);
3130
    int v= show_bits(&s->gb, 16);
3131

    
3132
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
3133
        return 0;
3134
    }
3135

    
3136
    while(v<=0xFF){
3137
        if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3138
            break;
3139
        skip_bits(&s->gb, 8+s->pict_type);
3140
        bits_count+= 8+s->pict_type;
3141
        v= show_bits(&s->gb, 16);
3142
    }
3143

    
3144
    if(bits_count + 8 >= s->gb.size_in_bits){
3145
        v>>=8;
3146
        v|= 0x7F >> (7-(bits_count&7));
3147

    
3148
        if(v==0x7F)
3149
            return 1;
3150
    }else{
3151
        if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3152
            int len;
3153
            GetBitContext gb= s->gb;
3154

    
3155
            skip_bits(&s->gb, 1);
3156
            align_get_bits(&s->gb);
3157

    
3158
            for(len=0; len<32; len++){
3159
                if(get_bits1(&s->gb)) break;
3160
            }
3161

    
3162
            s->gb= gb;
3163

    
3164
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3165
                return 1;
3166
        }
3167
    }
3168
    return 0;
3169
}
3170

    
3171
/**
3172
 * decodes the next video packet.
3173
 * @return <0 if something went wrong
3174
 */
3175
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3176
{
3177
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3178
    int header_extension=0, mb_num, len;
3179

    
3180
    /* is there enough space left for a video packet + header */
3181
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3182

    
3183
    for(len=0; len<32; len++){
3184
        if(get_bits1(&s->gb)) break;
3185
    }
3186

    
3187
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3188
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3189
        return -1;
3190
    }
3191

    
3192
    if(s->shape != RECT_SHAPE){
3193
        header_extension= get_bits1(&s->gb);
3194
        //FIXME more stuff here
3195
    }
3196

    
3197
    mb_num= get_bits(&s->gb, mb_num_bits);
3198
    if(mb_num>=s->mb_num){
3199
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3200
        return -1;
3201
    }
3202
    if(s->pict_type == FF_B_TYPE){
3203
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3204
        if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded
3205
    }
3206

    
3207
    s->mb_x= mb_num % s->mb_width;
3208
    s->mb_y= mb_num / s->mb_width;
3209

    
3210
    if(s->shape != BIN_ONLY_SHAPE){
3211
        int qscale= get_bits(&s->gb, s->quant_precision);
3212
        if(qscale)
3213
            s->chroma_qscale=s->qscale= qscale;
3214
    }
3215

    
3216
    if(s->shape == RECT_SHAPE){
3217
        header_extension= get_bits1(&s->gb);
3218
    }
3219
    if(header_extension){
3220
        int time_increment;
3221
        int time_incr=0;
3222

    
3223
        while (get_bits1(&s->gb) != 0)
3224
            time_incr++;
3225

    
3226
        check_marker(&s->gb, "before time_increment in video packed header");
3227
        time_increment= get_bits(&s->gb, s->time_increment_bits);
3228
        check_marker(&s->gb, "before vop_coding_type in video packed header");
3229

    
3230
        skip_bits(&s->gb, 2); /* vop coding type */
3231
        //FIXME not rect stuff here
3232

    
3233
        if(s->shape != BIN_ONLY_SHAPE){
3234
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3235
//FIXME don't just ignore everything
3236
            if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3237
                mpeg4_decode_sprite_trajectory(s, &s->gb);
3238
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3239
            }
3240

    
3241
            //FIXME reduced res stuff here
3242

    
3243
            if (s->pict_type != FF_I_TYPE) {
3244
                int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3245
                if(f_code==0){
3246
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3247
                }
3248
            }
3249
            if (s->pict_type == FF_B_TYPE) {
3250
                int b_code = get_bits(&s->gb, 3);
3251
                if(b_code==0){
3252
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3253
                }
3254
            }
3255
        }
3256
    }
3257
    //FIXME new-pred stuff
3258

    
3259
//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));
3260

    
3261
    return 0;
3262
}
3263

    
3264
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3265
{
3266
    int c_wrap, c_xy, l_wrap, l_xy;
3267

    
3268
    l_wrap= s->b8_stride;
3269
    l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3270
    c_wrap= s->mb_stride;
3271
    c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3272

    
3273
#if 0
3274
    /* clean DC */
3275
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3276
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3277
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3278
#endif
3279

    
3280
    /* clean AC */
3281
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3282
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3283
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3284

    
3285
    /* clean MV */
3286
    // we can't clear the MVs as they might be needed by a b frame
3287
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3288
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3289
    s->last_mv[0][0][0]=
3290
    s->last_mv[0][0][1]=
3291
    s->last_mv[1][0][0]=
3292
    s->last_mv[1][0][1]= 0;
3293
}
3294

    
3295
/**
3296
 * finds the next resync_marker
3297
 * @param p pointer to buffer to scan
3298
 * @param end pointer to the end of the buffer
3299
 * @return pointer to the next resync_marker, or \p end if none was found
3300
 */
3301
const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end)
3302
{
3303
    assert(p < end);
3304

    
3305
    end-=2;
3306
    p++;
3307
    for(;p<end; p+=2){
3308
        if(!*p){
3309
            if     (!p[-1] && p[1]) return p - 1;
3310
            else if(!p[ 1] && p[2]) return p;
3311
        }
3312
    }
3313
    return end+2;
3314
}
3315

    
3316
/**
3317
 * decodes the group of blocks / video packet header.
3318
 * @return bit position of the resync_marker, or <0 if none was found
3319
 */
3320
int ff_h263_resync(MpegEncContext *s){
3321
    int left, pos, ret;
3322

    
3323
    if(s->codec_id==CODEC_ID_MPEG4){
3324
        skip_bits1(&s->gb);
3325
        align_get_bits(&s->gb);
3326
    }
3327

    
3328
    if(show_bits(&s->gb, 16)==0){
3329
        pos= get_bits_count(&s->gb);
3330
        if(s->codec_id==CODEC_ID_MPEG4)
3331
            ret= mpeg4_decode_video_packet_header(s);
3332
        else
3333
            ret= h263_decode_gob_header(s);
3334
        if(ret>=0)
3335
            return pos;
3336
    }
3337
    //OK, it's not where it is supposed to be ...
3338
    s->gb= s->last_resync_gb;
3339
    align_get_bits(&s->gb);
3340
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3341

    
3342
    for(;left>16+1+5+5; left-=8){
3343
        if(show_bits(&s->gb, 16)==0){
3344
            GetBitContext bak= s->gb;
3345

    
3346
            pos= get_bits_count(&s->gb);
3347
            if(s->codec_id==CODEC_ID_MPEG4)
3348
                ret= mpeg4_decode_video_packet_header(s);
3349
            else
3350
                ret= h263_decode_gob_header(s);
3351
            if(ret>=0)
3352
                return pos;
3353

    
3354
            s->gb= bak;
3355
        }
3356
        skip_bits(&s->gb, 8);
3357
    }
3358

    
3359
    return -1;
3360
}
3361

    
3362
/**
3363
 * gets the average motion vector for a GMC MB.
3364
 * @param n either 0 for the x component or 1 for y
3365
 * @returns the average MV for a GMC MB
3366
 */
3367
static inline int get_amv(MpegEncContext *s, int n){
3368
    int x, y, mb_v, sum, dx, dy, shift;
3369
    int len = 1 << (s->f_code + 4);
3370
    const int a= s->sprite_warping_accuracy;
3371

    
3372
    if(s->workaround_bugs & FF_BUG_AMV)
3373
        len >>= s->quarter_sample;
3374

    
3375
    if(s->real_sprite_warping_points==1){
3376
        if(s->divx_version==500 && s->divx_build==413)
3377
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3378
        else
3379
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3380
    }else{
3381
        dx= s->sprite_delta[n][0];
3382
        dy= s->sprite_delta[n][1];
3383
        shift= s->sprite_shift[0];
3384
        if(n) dy -= 1<<(shift + a + 1);
3385
        else  dx -= 1<<(shift + a + 1);
3386
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3387

    
3388
        sum=0;
3389
        for(y=0; y<16; y++){
3390
            int v;
3391

    
3392
            v= mb_v + dy*y;
3393
            //XXX FIXME optimize
3394
            for(x=0; x<16; x++){
3395
                sum+= v>>shift;
3396
                v+= dx;
3397
            }
3398
        }
3399
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3400
    }
3401

    
3402
    if      (sum < -len) sum= -len;
3403
    else if (sum >= len) sum= len-1;
3404

    
3405
    return sum;
3406
}
3407

    
3408
/**
3409
 * decodes first partition.
3410
 * @return number of MBs decoded or <0 if an error occurred
3411
 */
3412
static int mpeg4_decode_partition_a(MpegEncContext *s){
3413
    int mb_num;
3414
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3415

    
3416
    /* decode first partition */
3417
    mb_num=0;
3418
    s->first_slice_line=1;
3419
    for(; s->mb_y<s->mb_height; s->mb_y++){
3420
        ff_init_block_index(s);
3421
        for(; s->mb_x<s->mb_width; s->mb_x++){
3422
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3423
            int cbpc;
3424
            int dir=0;
3425

    
3426
            mb_num++;
3427
            ff_update_block_index(s);
3428
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3429
                s->first_slice_line=0;
3430

    
3431
            if(s->pict_type==FF_I_TYPE){
3432
                int i;
3433

    
3434
                do{
3435
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
3436
                        return mb_num-1;
3437
                    }
3438

    
3439
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3440
                    if (cbpc < 0){
3441
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3442
                        return -1;
3443
                    }
3444
                }while(cbpc == 8);
3445

    
3446
                s->cbp_table[xy]= cbpc & 3;
3447
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3448
                s->mb_intra = 1;
3449

    
3450
                if(cbpc & 4) {
3451
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3452
                }
3453
                s->current_picture.qscale_table[xy]= s->qscale;
3454

    
3455
                s->mbintra_table[xy]= 1;
3456
                for(i=0; i<6; i++){
3457
                    int dc_pred_dir;
3458
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3459
                    if(dc < 0){
3460
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3461
                        return -1;
3462
                    }
3463
                    dir<<=1;
3464
                    if(dc_pred_dir) dir|=1;
3465
                }
3466
                s->pred_dir_table[xy]= dir;
3467
            }else{ /* P/S_TYPE */
3468
                int mx, my, pred_x, pred_y, bits;
3469
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3470
                const int stride= s->b8_stride*2;
3471

    
3472
try_again:
3473
                bits= show_bits(&s->gb, 17);
3474
                if(bits==MOTION_MARKER){
3475
                    return mb_num-1;
3476
                }
3477
                skip_bits1(&s->gb);
3478
                if(bits&0x10000){
3479
                    /* skip mb */
3480
                    if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3481
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3482
                        mx= get_amv(s, 0);
3483
                        my= get_amv(s, 1);
3484
                    }else{
3485
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3486
                        mx=my=0;
3487
                    }
3488
                    mot_val[0       ]= mot_val[2       ]=
3489
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3490
                    mot_val[1       ]= mot_val[3       ]=
3491
                    mot_val[1+stride]= mot_val[3+stride]= my;
3492

    
3493
                    if(s->mbintra_table[xy])
3494
                        ff_clean_intra_table_entries(s);
3495
                    continue;
3496
                }
3497

    
3498
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3499
                if (cbpc < 0){
3500
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3501
                    return -1;
3502
                }
3503
                if(cbpc == 20)
3504
                    goto try_again;
3505

    
3506
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3507

    
3508
                s->mb_intra = ((cbpc & 4) != 0);
3509

    
3510
                if(s->mb_intra){
3511
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3512
                    s->mbintra_table[xy]= 1;
3513
                    mot_val[0       ]= mot_val[2       ]=
3514
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3515
                    mot_val[1       ]= mot_val[3       ]=
3516
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3517
                }else{
3518
                    if(s->mbintra_table[xy])
3519
                        ff_clean_intra_table_entries(s);
3520

    
3521
                    if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3522
                        s->mcsel= get_bits1(&s->gb);
3523
                    else s->mcsel= 0;
3524

    
3525
                    if ((cbpc & 16) == 0) {
3526
                        /* 16x16 motion prediction */
3527

    
3528
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3529
                        if(!s->mcsel){
3530
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3531
                            if (mx >= 0xffff)
3532
                                return -1;
3533

    
3534
                            my = h263_decode_motion(s, pred_y, s->f_code);
3535
                            if (my >= 0xffff)
3536
                                return -1;
3537
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3538
                        } else {
3539
                            mx = get_amv(s, 0);
3540
                            my = get_amv(s, 1);
3541
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3542
                        }
3543

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

    
3557
                            my = h263_decode_motion(s, pred_y, s->f_code);
3558
                            if (my >= 0xffff)
3559
                                return -1;
3560
                            mot_val[0] = mx;
3561
                            mot_val[1] = my;
3562
                        }
3563
                    }
3564
                }
3565
            }
3566
        }
3567
        s->mb_x= 0;
3568
    }
3569

    
3570
    return mb_num;
3571
}
3572

    
3573
/**
3574
 * decode second partition.
3575
 * @return <0 if an error occurred
3576
 */
3577
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3578
    int mb_num=0;
3579
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3580

    
3581
    s->mb_x= s->resync_mb_x;
3582
    s->first_slice_line=1;
3583
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3584
        ff_init_block_index(s);
3585
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3586
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3587

    
3588
            mb_num++;
3589
            ff_update_block_index(s);
3590
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3591
                s->first_slice_line=0;
3592

    
3593
            if(s->pict_type==FF_I_TYPE){
3594
                int ac_pred= get_bits1(&s->gb);
3595
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3596
                if(cbpy<0){
3597
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3598
                    return -1;
3599
                }
3600

    
3601
                s->cbp_table[xy]|= cbpy<<2;
3602
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3603
            }else{ /* P || S_TYPE */
3604
                if(IS_INTRA(s->current_picture.mb_type[xy])){
3605
                    int dir=0,i;
3606
                    int ac_pred = get_bits1(&s->gb);
3607
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3608

    
3609
                    if(cbpy<0){
3610
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3611
                        return -1;
3612
                    }
3613

    
3614
                    if(s->cbp_table[xy] & 8) {
3615
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3616
                    }
3617
                    s->current_picture.qscale_table[xy]= s->qscale;
3618

    
3619
                    for(i=0; i<6; i++){
3620
                        int dc_pred_dir;
3621
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3622
                        if(dc < 0){
3623
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3624
                            return -1;
3625
                        }
3626
                        dir<<=1;
3627
                        if(dc_pred_dir) dir|=1;
3628
                    }
3629
                    s->cbp_table[xy]&= 3; //remove dquant
3630
                    s->cbp_table[xy]|= cbpy<<2;
3631
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3632
                    s->pred_dir_table[xy]= dir;
3633
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3634
                    s->current_picture.qscale_table[xy]= s->qscale;
3635
                    s->cbp_table[xy]= 0;
3636
                }else{
3637
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3638

    
3639
                    if(cbpy<0){
3640
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3641
                        return -1;
3642
                    }
3643

    
3644
                    if(s->cbp_table[xy] & 8) {
3645
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3646
                    }
3647
                    s->current_picture.qscale_table[xy]= s->qscale;
3648

    
3649
                    s->cbp_table[xy]&= 3; //remove dquant
3650
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3651
                }
3652
            }
3653
        }
3654
        if(mb_num >= mb_count) return 0;
3655
        s->mb_x= 0;
3656
    }
3657
    return 0;
3658
}
3659

    
3660
/**
3661
 * decodes the first & second partition
3662
 * @return <0 if error (and sets error type in the error_status_table)
3663
 */
3664
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3665
{
3666
    int mb_num;
3667
    const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3668
    const int part_a_end  = s->pict_type==FF_I_TYPE ? (DC_END  |MV_END)   : MV_END;
3669

    
3670
    mb_num= mpeg4_decode_partition_a(s);
3671
    if(mb_num<0){
3672
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3673
        return -1;
3674
    }
3675

    
3676
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3677
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3678
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3679
        return -1;
3680
    }
3681

    
3682
    s->mb_num_left= mb_num;
3683

    
3684
    if(s->pict_type==FF_I_TYPE){
3685
        while(show_bits(&s->gb, 9) == 1)
3686
            skip_bits(&s->gb, 9);
3687
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3688
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3689
            return -1;
3690
        }
3691
    }else{
3692
        while(show_bits(&s->gb, 10) == 1)
3693
            skip_bits(&s->gb, 10);
3694
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3695
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3696
            return -1;
3697
        }
3698
    }
3699
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3700

    
3701
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3702
        if(s->pict_type==FF_P_TYPE)
3703
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3704
        return -1;
3705
    }else{
3706
        if(s->pict_type==FF_P_TYPE)
3707
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3708
    }
3709

    
3710
    return 0;
3711
}
3712

    
3713
/**
3714
 * decode partition C of one MB.
3715
 * @return <0 if an error occurred
3716
 */
3717
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3718
{
3719
    int cbp, mb_type;
3720
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3721

    
3722
    mb_type= s->current_picture.mb_type[xy];
3723
    cbp = s->cbp_table[xy];
3724

    
3725
    s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3726

    
3727
    if(s->current_picture.qscale_table[xy] != s->qscale){
3728
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3729
    }
3730

    
3731
    if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
3732
        int i;
3733
        for(i=0; i<4; i++){
3734
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3735
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3736
        }
3737
        s->mb_intra = IS_INTRA(mb_type);
3738

    
3739
        if (IS_SKIP(mb_type)) {
3740
            /* skip mb */
3741
            for(i=0;i<6;i++)
3742
                s->block_last_index[i] = -1;
3743
            s->mv_dir = MV_DIR_FORWARD;
3744
            s->mv_type = MV_TYPE_16X16;
3745
            if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3746
                s->mcsel=1;
3747
                s->mb_skipped = 0;
3748
            }else{
3749
                s->mcsel=0;
3750
                s->mb_skipped = 1;
3751
            }
3752
        }else if(s->mb_intra){
3753
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3754
        }else if(!s->mb_intra){
3755
//            s->mcsel= 0; //FIXME do we need to init that
3756

    
3757
            s->mv_dir = MV_DIR_FORWARD;
3758
            if (IS_8X8(mb_type)) {
3759
                s->mv_type = MV_TYPE_8X8;
3760
            } else {
3761
                s->mv_type = MV_TYPE_16X16;
3762
            }
3763
        }
3764
    } else { /* I-Frame */
3765
        s->mb_intra = 1;
3766
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3767
    }
3768

    
3769
    if (!IS_SKIP(mb_type)) {
3770
        int i;
3771
        s->dsp.clear_blocks(s->block[0]);
3772
        /* decode each block */
3773
        for (i = 0; i < 6; i++) {
3774
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3775
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3776
                return -1;
3777
            }
3778
            cbp+=cbp;
3779
        }
3780
    }
3781

    
3782
    /* per-MB end of slice check */
3783

    
3784
    if(--s->mb_num_left <= 0){
3785
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3786
        if(mpeg4_is_resync(s))
3787
            return SLICE_END;
3788
        else
3789
            return SLICE_NOEND;
3790
    }else{
3791
        if(mpeg4_is_resync(s)){
3792
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3793
            if(s->cbp_table[xy+delta])
3794
                return SLICE_END;
3795
        }
3796
        return SLICE_OK;
3797
    }
3798
}
3799

    
3800
/**
3801
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3802
 */
3803
static void preview_obmc(MpegEncContext *s){
3804
    GetBitContext gb= s->gb;
3805

    
3806
    int cbpc, i, pred_x, pred_y, mx, my;
3807
    int16_t *mot_val;
3808
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3809
    const int stride= s->b8_stride*2;
3810

    
3811
    for(i=0; i<4; i++)
3812
        s->block_index[i]+= 2;
3813
    for(i=4; i<6; i++)
3814
        s->block_index[i]+= 1;
3815
    s->mb_x++;
3816

    
3817
    assert(s->pict_type == FF_P_TYPE);
3818

    
3819
    do{
3820
        if (get_bits1(&s->gb)) {
3821
            /* skip mb */
3822
            mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3823
            mot_val[0       ]= mot_val[2       ]=
3824
            mot_val[0+stride]= mot_val[2+stride]= 0;
3825
            mot_val[1       ]= mot_val[3       ]=
3826
            mot_val[1+stride]= mot_val[3+stride]= 0;
3827

    
3828
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3829
            goto end;
3830
        }
3831
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3832
    }while(cbpc == 20);
3833

    
3834
    if(cbpc & 4){
3835
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3836
    }else{
3837
        get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3838
        if (cbpc & 8) {
3839
            if(s->modified_quant){
3840
                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3841
                else                  skip_bits(&s->gb, 5);
3842
            }else
3843
                skip_bits(&s->gb, 2);
3844
        }
3845

    
3846
        if ((cbpc & 16) == 0) {
3847
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3848
                /* 16x16 motion prediction */
3849
                mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3850
                if (s->umvplus)
3851
                   mx = h263p_decode_umotion(s, pred_x);
3852
                else
3853
                   mx = h263_decode_motion(s, pred_x, 1);
3854

    
3855
                if (s->umvplus)
3856
                   my = h263p_decode_umotion(s, pred_y);
3857
                else
3858
                   my = h263_decode_motion(s, pred_y, 1);
3859

    
3860
                mot_val[0       ]= mot_val[2       ]=
3861
                mot_val[0+stride]= mot_val[2+stride]= mx;
3862
                mot_val[1       ]= mot_val[3       ]=
3863
                mot_val[1+stride]= mot_val[3+stride]= my;
3864
        } else {
3865
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3866
            for(i=0;i<4;i++) {
3867
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3868
                if (s->umvplus)
3869
                  mx = h263p_decode_umotion(s, pred_x);
3870
                else
3871
                  mx = h263_decode_motion(s, pred_x, 1);
3872

    
3873
                if (s->umvplus)
3874
                  my = h263p_decode_umotion(s, pred_y);
3875
                else
3876
                  my = h263_decode_motion(s, pred_y, 1);
3877
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3878
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3879
                mot_val[0] = mx;
3880
                mot_val[1] = my;
3881
            }
3882
        }
3883
    }
3884
end:
3885

    
3886
    for(i=0; i<4; i++)
3887
        s->block_index[i]-= 2;
3888
    for(i=4; i<6; i++)
3889
        s->block_index[i]-= 1;
3890
    s->mb_x--;
3891

    
3892
    s->gb= gb;
3893
}
3894

    
3895
static void h263_decode_dquant(MpegEncContext *s){
3896
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3897

    
3898
    if(s->modified_quant){
3899
        if(get_bits1(&s->gb))
3900
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3901
        else
3902
            s->qscale= get_bits(&s->gb, 5);
3903
    }else
3904
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
3905
    ff_set_qscale(s, s->qscale);
3906
}
3907

    
3908
int ff_h263_decode_mb(MpegEncContext *s,
3909
                      DCTELEM block[6][64])
3910
{
3911
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3912
    int16_t *mot_val;
3913
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3914

    
3915
    assert(!s->h263_pred);
3916

    
3917
    if (s->pict_type == FF_P_TYPE) {
3918
        do{
3919
            if (get_bits1(&s->gb)) {
3920
                /* skip mb */
3921
                s->mb_intra = 0;
3922
                for(i=0;i<6;i++)
3923
                    s->block_last_index[i] = -1;
3924
                s->mv_dir = MV_DIR_FORWARD;
3925
                s->mv_type = MV_TYPE_16X16;
3926
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3927
                s->mv[0][0][0] = 0;
3928
                s->mv[0][0][1] = 0;
3929
                s->mb_skipped = !(s->obmc | s->loop_filter);
3930
                goto end;
3931
            }
3932
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3933
            //fprintf(stderr, "\tCBPC: %d", cbpc);
3934
            if (cbpc < 0){
3935
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3936
                return -1;
3937
            }
3938
        }while(cbpc == 20);
3939

    
3940
        s->dsp.clear_blocks(s->block[0]);
3941

    
3942
        dquant = cbpc & 8;
3943
        s->mb_intra = ((cbpc & 4) != 0);
3944
        if (s->mb_intra) goto intra;
3945

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

    
3948
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3949
            cbpy ^= 0xF;
3950

    
3951
        cbp = (cbpc & 3) | (cbpy << 2);
3952
        if (dquant) {
3953
            h263_decode_dquant(s);
3954
        }
3955

    
3956
        s->mv_dir = MV_DIR_FORWARD;
3957
        if ((cbpc & 16) == 0) {
3958
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3959
            /* 16x16 motion prediction */
3960
            s->mv_type = MV_TYPE_16X16;
3961
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3962
            if (s->umvplus)
3963
               mx = h263p_decode_umotion(s, pred_x);
3964
            else
3965
               mx = h263_decode_motion(s, pred_x, 1);
3966

    
3967
            if (mx >= 0xffff)
3968
                return -1;
3969

    
3970
            if (s->umvplus)
3971
               my = h263p_decode_umotion(s, pred_y);
3972
            else
3973
               my = h263_decode_motion(s, pred_y, 1);
3974

    
3975
            if (my >= 0xffff)
3976
                return -1;
3977
            s->mv[0][0][0] = mx;
3978
            s->mv[0][0][1] = my;
3979

    
3980
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3981
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3982
        } else {
3983
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3984
            s->mv_type = MV_TYPE_8X8;
3985
            for(i=0;i<4;i++) {
3986
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3987
                if (s->umvplus)
3988
                  mx = h263p_decode_umotion(s, pred_x);
3989
                else
3990
                  mx = h263_decode_motion(s, pred_x, 1);
3991
                if (mx >= 0xffff)
3992
                    return -1;
3993

    
3994
                if (s->umvplus)
3995
                  my = h263p_decode_umotion(s, pred_y);
3996
                else
3997
                  my = h263_decode_motion(s, pred_y, 1);
3998
                if (my >= 0xffff)
3999
                    return -1;
4000
                s->mv[0][i][0] = mx;
4001
                s->mv[0][i][1] = my;
4002
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4003
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4004
                mot_val[0] = mx;
4005
                mot_val[1] = my;
4006
            }
4007
        }
4008

    
4009
        /* decode each block */
4010
        for (i = 0; i < 6; i++) {
4011
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4012
                return -1;
4013
            cbp+=cbp;
4014
        }
4015

    
4016
        if(s->obmc){
4017
            if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4018
                preview_obmc(s);
4019
        }
4020
    } else if(s->pict_type==FF_B_TYPE) {
4021
        int mb_type;
4022
        const int stride= s->b8_stride;
4023
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4024
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4025
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4026

    
4027
        //FIXME ugly
4028
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4029
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4030
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4031
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4032

    
4033
        do{
4034
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4035
            if (mb_type < 0){
4036
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4037
                return -1;
4038
            }
4039

    
4040
            mb_type= h263_mb_type_b_map[ mb_type ];
4041
        }while(!mb_type);
4042

    
4043
        s->mb_intra = IS_INTRA(mb_type);
4044
        if(HAS_CBP(mb_type)){
4045
            s->dsp.clear_blocks(s->block[0]);
4046
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4047
            if(s->mb_intra){
4048
                dquant = IS_QUANT(mb_type);
4049
                goto intra;
4050
            }
4051

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

    
4054
            if (cbpy < 0){
4055
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4056
                return -1;
4057
            }
4058

    
4059
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4060
                cbpy ^= 0xF;
4061

    
4062
            cbp = (cbpc & 3) | (cbpy << 2);
4063
        }else
4064
            cbp=0;
4065

    
4066
        assert(!s->mb_intra);
4067

    
4068
        if(IS_QUANT(mb_type)){
4069
            h263_decode_dquant(s);
4070
        }
4071

    
4072
        if(IS_DIRECT(mb_type)){
4073
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4074
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4075
        }else{
4076
            s->mv_dir = 0;
4077
            s->mv_type= MV_TYPE_16X16;
4078
//FIXME UMV
4079

    
4080
            if(USES_LIST(mb_type, 0)){
4081
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4082
                s->mv_dir = MV_DIR_FORWARD;
4083

    
4084
                mx = h263_decode_motion(s, mx, 1);
4085
                my = h263_decode_motion(s, my, 1);
4086

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

    
4093
            if(USES_LIST(mb_type, 1)){
4094
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4095
                s->mv_dir |= MV_DIR_BACKWARD;
4096

    
4097
                mx = h263_decode_motion(s, mx, 1);
4098
                my = h263_decode_motion(s, my, 1);
4099

    
4100
                s->mv[1][0][0] = mx;
4101
                s->mv[1][0][1] = my;
4102
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4103
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4104
            }
4105
        }
4106

    
4107
        s->current_picture.mb_type[xy]= mb_type;
4108

    
4109
        /* decode each block */
4110
        for (i = 0; i < 6; i++) {
4111
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4112
                return -1;
4113
            cbp+=cbp;
4114
        }
4115
    } else { /* I-Frame */
4116
        do{
4117
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4118
            if (cbpc < 0){
4119
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4120
                return -1;
4121
            }
4122
        }while(cbpc == 8);
4123

    
4124
        s->dsp.clear_blocks(s->block[0]);
4125

    
4126
        dquant = cbpc & 4;
4127
        s->mb_intra = 1;
4128
intra:
4129
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4130
        if (s->h263_aic) {
4131
            s->ac_pred = get_bits1(&s->gb);
4132
            if(s->ac_pred){
4133
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4134

    
4135
                s->h263_aic_dir = get_bits1(&s->gb);
4136
            }
4137
        }else
4138
            s->ac_pred = 0;
4139

    
4140
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4141
        if(cbpy<0){
4142
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4143
            return -1;
4144
        }
4145
        cbp = (cbpc & 3) | (cbpy << 2);
4146
        if (dquant) {
4147
            h263_decode_dquant(s);
4148
        }
4149

    
4150
        /* decode each block */
4151
        for (i = 0; i < 6; i++) {
4152
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4153
                return -1;
4154
            cbp+=cbp;
4155
        }
4156
    }
4157
end:
4158

    
4159
        /* per-MB end of slice check */
4160
    {
4161
        int v= show_bits(&s->gb, 16);
4162

    
4163
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4164
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4165
        }
4166

    
4167
        if(v==0)
4168
            return SLICE_END;
4169
    }
4170

    
4171
    return SLICE_OK;
4172
}
4173

    
4174
int ff_mpeg4_decode_mb(MpegEncContext *s,
4175
                      DCTELEM block[6][64])
4176
{
4177
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4178
    int16_t *mot_val;
4179
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4180
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4181

    
4182
    assert(s->h263_pred);
4183

    
4184
    if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
4185
        do{
4186
            if (get_bits1(&s->gb)) {
4187
                /* skip mb */
4188
                s->mb_intra = 0;
4189
                for(i=0;i<6;i++)
4190
                    s->block_last_index[i] = -1;
4191
                s->mv_dir = MV_DIR_FORWARD;
4192
                s->mv_type = MV_TYPE_16X16;
4193
                if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4194
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4195
                    s->mcsel=1;
4196
                    s->mv[0][0][0]= get_amv(s, 0);
4197
                    s->mv[0][0][1]= get_amv(s, 1);
4198

    
4199
                    s->mb_skipped = 0;
4200
                }else{
4201
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4202
                    s->mcsel=0;
4203
                    s->mv[0][0][0] = 0;
4204
                    s->mv[0][0][1] = 0;
4205
                    s->mb_skipped = 1;
4206
                }
4207
                goto end;
4208
            }
4209
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4210
            //fprintf(stderr, "\tCBPC: %d", cbpc);
4211
            if (cbpc < 0){
4212
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4213
                return -1;
4214
            }
4215
        }while(cbpc == 20);
4216

    
4217
        s->dsp.clear_blocks(s->block[0]);
4218
        dquant = cbpc & 8;
4219
        s->mb_intra = ((cbpc & 4) != 0);
4220
        if (s->mb_intra) goto intra;
4221

    
4222
        if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4223
            s->mcsel= get_bits1(&s->gb);
4224
        else s->mcsel= 0;
4225
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4226

    
4227
        cbp = (cbpc & 3) | (cbpy << 2);
4228
        if (dquant) {
4229
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4230
        }
4231
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4232
            s->interlaced_dct= get_bits1(&s->gb);
4233

    
4234
        s->mv_dir = MV_DIR_FORWARD;
4235
        if ((cbpc & 16) == 0) {
4236
            if(s->mcsel){
4237
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4238
                /* 16x16 global motion prediction */
4239
                s->mv_type = MV_TYPE_16X16;
4240
                mx= get_amv(s, 0);
4241
                my= get_amv(s, 1);
4242
                s->mv[0][0][0] = mx;
4243
                s->mv[0][0][1] = my;
4244
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4245
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4246
                /* 16x8 field motion prediction */
4247
                s->mv_type= MV_TYPE_FIELD;
4248

    
4249
                s->field_select[0][0]= get_bits1(&s->gb);
4250
                s->field_select[0][1]= get_bits1(&s->gb);
4251

    
4252
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4253

    
4254
                for(i=0; i<2; i++){
4255
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4256
                    if (mx >= 0xffff)
4257
                        return -1;
4258

    
4259
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4260
                    if (my >= 0xffff)
4261
                        return -1;
4262

    
4263
                    s->mv[0][i][0] = mx;
4264
                    s->mv[0][i][1] = my;
4265
                }
4266
            }else{
4267
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4268
                /* 16x16 motion prediction */
4269
                s->mv_type = MV_TYPE_16X16;
4270
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4271
                mx = h263_decode_motion(s, pred_x, s->f_code);
4272

    
4273
                if (mx >= 0xffff)
4274
                    return -1;
4275

    
4276
                my = h263_decode_motion(s, pred_y, s->f_code);
4277

    
4278
                if (my >= 0xffff)
4279
                    return -1;
4280
                s->mv[0][0][0] = mx;
4281
                s->mv[0][0][1] = my;
4282
            }
4283
        } else {
4284
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4285
            s->mv_type = MV_TYPE_8X8;
4286
            for(i=0;i<4;i++) {
4287
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4288
                mx = h263_decode_motion(s, pred_x, s->f_code);
4289
                if (mx >= 0xffff)
4290
                    return -1;
4291

    
4292
                my = h263_decode_motion(s, pred_y, s->f_code);
4293
                if (my >= 0xffff)
4294
                    return -1;
4295
                s->mv[0][i][0] = mx;
4296
                s->mv[0][i][1] = my;
4297
                mot_val[0] = mx;
4298
                mot_val[1] = my;
4299
            }
4300
        }
4301
    } else if(s->pict_type==FF_B_TYPE) {
4302
        int modb1; // first bit of modb
4303
        int modb2; // second bit of modb
4304
        int mb_type;
4305

    
4306
        s->mb_intra = 0; //B-frames never contain intra blocks
4307
        s->mcsel=0;      //     ...               true gmc blocks
4308

    
4309
        if(s->mb_x==0){
4310
            for(i=0; i<2; i++){
4311
                s->last_mv[i][0][0]=
4312
                s->last_mv[i][0][1]=
4313
                s->last_mv[i][1][0]=
4314
                s->last_mv[i][1][1]= 0;
4315
            }
4316
        }
4317

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

    
4321
        if(s->mb_skipped){
4322
                /* skip mb */
4323
            for(i=0;i<6;i++)
4324
                s->block_last_index[i] = -1;
4325

    
4326
            s->mv_dir = MV_DIR_FORWARD;
4327
            s->mv_type = MV_TYPE_16X16;
4328
            s->mv[0][0][0] = 0;
4329
            s->mv[0][0][1] = 0;
4330
            s->mv[1][0][0] = 0;
4331
            s->mv[1][0][1] = 0;
4332
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4333
            goto end;
4334
        }
4335

    
4336
        modb1= get_bits1(&s->gb);
4337
        if(modb1){
4338
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4339
            cbp=0;
4340
        }else{
4341
            modb2= get_bits1(&s->gb);
4342
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4343
            if(mb_type<0){
4344
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4345
                return -1;
4346
            }
4347
            mb_type= mb_type_b_map[ mb_type ];
4348
            if(modb2) cbp= 0;
4349
            else{
4350
                s->dsp.clear_blocks(s->block[0]);
4351
                cbp= get_bits(&s->gb, 6);
4352
            }
4353

    
4354
            if ((!IS_DIRECT(mb_type)) && cbp) {
4355
                if(get_bits1(&s->gb)){
4356
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4357
                }
4358
            }
4359

    
4360
            if(!s->progressive_sequence){
4361
                if(cbp)
4362
                    s->interlaced_dct= get_bits1(&s->gb);
4363

    
4364
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4365
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4366
                    mb_type &= ~MB_TYPE_16x16;
4367

    
4368
                    if(USES_LIST(mb_type, 0)){
4369
                        s->field_select[0][0]= get_bits1(&s->gb);
4370
                        s->field_select[0][1]= get_bits1(&s->gb);
4371
                    }
4372
                    if(USES_LIST(mb_type, 1)){
4373
                        s->field_select[1][0]= get_bits1(&s->gb);
4374
                        s->field_select[1][1]= get_bits1(&s->gb);
4375
                    }
4376
                }
4377
            }
4378

    
4379
            s->mv_dir = 0;
4380
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4381
                s->mv_type= MV_TYPE_16X16;
4382

    
4383
                if(USES_LIST(mb_type, 0)){
4384
                    s->mv_dir = MV_DIR_FORWARD;
4385

    
4386
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4387
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4388
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4389
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4390
                }
4391

    
4392
                if(USES_LIST(mb_type, 1)){
4393
                    s->mv_dir |= MV_DIR_BACKWARD;
4394

    
4395
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4396
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4397
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4398
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4399
                }
4400
            }else if(!IS_DIRECT(mb_type)){
4401
                s->mv_type= MV_TYPE_FIELD;
4402

    
4403
                if(USES_LIST(mb_type, 0)){
4404
                    s->mv_dir = MV_DIR_FORWARD;
4405

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

    
4414
                if(USES_LIST(mb_type, 1)){
4415
                    s->mv_dir |= MV_DIR_BACKWARD;
4416

    
4417
                    for(i=0; i<2; i++){
4418
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4419
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4420
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4421
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4422
                    }
4423
                }
4424
            }
4425
        }
4426

    
4427
        if(IS_DIRECT(mb_type)){
4428
            if(IS_SKIP(mb_type))
4429
                mx=my=0;
4430
            else{
4431
                mx = h263_decode_motion(s, 0, 1);
4432
                my = h263_decode_motion(s, 0, 1);
4433
            }
4434

    
4435
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4436
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4437
        }
4438
        s->current_picture.mb_type[xy]= mb_type;
4439
    } else { /* I-Frame */
4440
        do{
4441
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4442
            if (cbpc < 0){
4443
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4444
                return -1;
4445
            }
4446
        }while(cbpc == 8);
4447

    
4448
        dquant = cbpc & 4;
4449
        s->mb_intra = 1;
4450
intra:
4451
        s->ac_pred = get_bits1(&s->gb);
4452
        if(s->ac_pred)
4453
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4454
        else
4455
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4456

    
4457
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4458
        if(cbpy<0){
4459
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4460
            return -1;
4461
        }
4462
        cbp = (cbpc & 3) | (cbpy << 2);
4463

    
4464
        s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4465

    
4466
        if (dquant) {
4467
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4468
        }
4469

    
4470
        if(!s->progressive_sequence)
4471
            s->interlaced_dct= get_bits1(&s->gb);
4472

    
4473
        s->dsp.clear_blocks(s->block[0]);
4474
        /* decode each block */
4475
        for (i = 0; i < 6; i++) {
4476
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4477
                return -1;
4478
            cbp+=cbp;
4479
        }
4480
        goto end;
4481
    }
4482

    
4483
    /* decode each block */
4484
    for (i = 0; i < 6; i++) {
4485
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4486
            return -1;
4487
        cbp+=cbp;
4488
    }
4489
end:
4490

    
4491
        /* per-MB end of slice check */
4492
    if(s->codec_id==CODEC_ID_MPEG4){
4493
        if(mpeg4_is_resync(s)){
4494
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4495
            if(s->pict_type==FF_B_TYPE && s->next_picture.mbskip_table[xy + delta])
4496
                return SLICE_OK;
4497
            return SLICE_END;
4498
        }
4499
    }
4500

    
4501
    return SLICE_OK;
4502
}
4503

    
4504
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4505
{
4506
    int code, val, sign, shift, l;
4507
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4508

    
4509
    if (code == 0)
4510
        return pred;
4511
    if (code < 0)
4512
        return 0xffff;
4513

    
4514
    sign = get_bits1(&s->gb);
4515
    shift = f_code - 1;
4516
    val = code;
4517
    if (shift) {
4518
        val = (val - 1) << shift;
4519
        val |= get_bits(&s->gb, shift);
4520
        val++;
4521
    }
4522
    if (sign)
4523
        val = -val;
4524
    val += pred;
4525

    
4526
    /* modulo decoding */
4527
    if (!s->h263_long_vectors) {
4528
        l = INT_BIT - 5 - f_code;
4529
        val = (val<<l)>>l;
4530
    } else {
4531
        /* horrible h263 long vector mode */
4532
        if (pred < -31 && val < -63)
4533
            val += 64;
4534
        if (pred > 32 && val > 63)
4535
            val -= 64;
4536

    
4537
    }
4538
    return val;
4539
}
4540

    
4541
/* Decodes RVLC of H.263+ UMV */
4542
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4543
{
4544
   int code = 0, sign;
4545

    
4546
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4547
      return pred;
4548

    
4549
   code = 2 + get_bits1(&s->gb);
4550

    
4551
   while (get_bits1(&s->gb))
4552
   {
4553
      code <<= 1;
4554
      code += get_bits1(&s->gb);
4555
   }
4556
   sign = code & 1;
4557
   code >>= 1;
4558

    
4559
   code = (sign) ? (pred - code) : (pred + code);
4560
#ifdef DEBUG
4561
   av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4562
#endif
4563
   return code;
4564

    
4565
}
4566

    
4567
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4568
                             int n, int coded)
4569
{
4570
    int code, level, i, j, last, run;
4571
    RLTable *rl = &rl_inter;
4572
    const uint8_t *scan_table;
4573
    GetBitContext gb= s->gb;
4574

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

    
4697
/**
4698
 * decodes the dc value.
4699
 * @param n block index (0-3 are luma, 4-5 are chroma)
4700
 * @param dir_ptr the prediction direction will be stored here
4701
 * @return the quantized dc
4702
 */
4703
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4704
{
4705
    int level, code;
4706

    
4707
    if (n < 4)
4708
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4709
    else
4710
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4711
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4712
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4713
        return -1;
4714
    }
4715
    if (code == 0) {
4716
        level = 0;
4717
    } else {
4718
        if(IS_3IV1){
4719
            if(code==1)
4720
                level= 2*get_bits1(&s->gb)-1;
4721
            else{
4722
                if(get_bits1(&s->gb))
4723
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4724
                else
4725
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4726
            }
4727
        }else{
4728
            level = get_xbits(&s->gb, code);
4729
        }
4730

    
4731
        if (code > 8){
4732
            if(get_bits1(&s->gb)==0){ /* marker */
4733
                if(s->error_recognition>=2){
4734
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4735
                    return -1;
4736
                }
4737
            }
4738
        }
4739
    }
4740

    
4741
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4742
}
4743

    
4744
/**
4745
 * decodes a block.
4746
 * @return <0 if an error occurred
4747
 */
4748
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4749
                              int n, int coded, int intra, int rvlc)
4750
{
4751
    int level, i, last, run;
4752
    int dc_pred_dir;
4753
    RLTable * rl;
4754
    RL_VLC_ELEM * rl_vlc;
4755
    const uint8_t * scan_table;
4756
    int qmul, qadd;
4757

    
4758
    //Note intra & rvlc should be optimized away if this is inlined
4759

    
4760
    if(intra) {
4761
      if(s->use_intra_dc_vlc){
4762
        /* DC coef */
4763
        if(s->partitioned_frame){
4764
            level = s->dc_val[0][ s->block_index[n] ];
4765
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4766
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4767
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4768
        }else{
4769
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4770
            if (level < 0)
4771
                return -1;
4772
        }
4773
        block[0] = level;
4774
        i = 0;
4775
      }else{
4776
            i = -1;
4777
            ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4778
      }
4779
      if (!coded)
4780
          goto not_coded;
4781

    
4782
      if(rvlc){