Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 685502cf

History | View | Annotate | Download (216 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
#include "unary.h"
44

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

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

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

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

    
76
static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
77
static void mpeg4_encode_visual_object_header(MpegEncContext * s);
78
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
79

    
80
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
81
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
82

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

    
89
static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
90
static uint8_t fcode_tab[MAX_MV*2+1];
91
static uint8_t umv_fcode_tab[MAX_MV*2+1];
92

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

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

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

    
114
static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
115

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

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

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

    
141
static void show_pict_info(MpegEncContext *s){
142
    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",
143
         s->qscale, av_get_pict_type_char(s->pict_type),
144
         s->gb.size_in_bits, 1-s->no_rounding,
145
         s->obmc ? " AP" : "",
146
         s->umvplus ? " UMV" : "",
147
         s->h263_long_vectors ? " LONG" : "",
148
         s->h263_plus ? " +" : "",
149
         s->h263_aic ? " AIC" : "",
150
         s->alt_inter_vlc ? " AIV" : "",
151
         s->modified_quant ? " MQ" : "",
152
         s->loop_filter ? " LOOP" : "",
153
         s->h263_slice_structured ? " SS" : "",
154
         s->avctx->time_base.den, s->avctx->time_base.num
155
    );
156
}
157

    
158
#if CONFIG_ENCODERS
159

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

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

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

    
172
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
173
}
174

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

    
179
      align_put_bits(&s->pb);
180

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

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

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

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

    
245
    align_put_bits(&s->pb);
246

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
373
        ff_h263_encode_mba(s);
374

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

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

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

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

    
406
            last= j;
407
        }
408
    }
409

    
410
    return rate;
411
}
412

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

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

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

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

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

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

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

    
481
    return score < 0;
482
}
483

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

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

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

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

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

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

    
528
    ff_init_qscale_tab(s);
529

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

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

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

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

    
557
    ff_clean_h263_qscales(s);
558

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

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

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

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

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

    
588
#endif //CONFIG_ENCODERS
589

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

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

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

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

    
629
#undef tab_size
630
#undef tab_bias
631

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

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

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

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

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

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

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

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

    
739
#if CONFIG_ENCODERS
740

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
941
                return;
942
            }
943

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1095
                    return;
1096
                }
1097
            }
1098

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1450
        }
1451
    }
1452

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1905
    }
1906
}
1907

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

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

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

    
1924
                len_tab[index]= 100;
1925

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

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

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

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

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

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

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

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

    
2008
                len_tab[index]= 100;
2009

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

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

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

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

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

    
2043
        init_uni_dc_tab();
2044

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2224
                assert(slevel != 0);
2225

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2333
    //FIXME levels
2334

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

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

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

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

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

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

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

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

    
2358
    if (!CONFIG_MPEG4_ENCODER)  return;
2359

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

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

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

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

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

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

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

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

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

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

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

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

    
2445
    ff_mpeg4_stuffing(&s->pb);
2446

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

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

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

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

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

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

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

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

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

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

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

    
2514
#endif //CONFIG_ENCODERS
2515

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

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

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

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

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

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

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

    
2592
    return ret;
2593
}
2594

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

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

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

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

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

    
2653
}
2654

    
2655
#if CONFIG_ENCODERS
2656

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

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

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

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

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

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

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

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

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

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

    
2881
    return len;
2882
}
2883

    
2884
#endif
2885

    
2886

    
2887
/***********************************************/
2888
/* decoding */
2889

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

    
2900
/* init vlcs */
2901

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

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

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

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

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

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

    
2976
    return mb_pos;
2977
}
2978

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

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

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

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

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

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

    
3018
        ff_h263_decode_mba(s);
3019

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

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

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

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

    
3042
    return 0;
3043
}
3044

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

    
3052
#if CONFIG_ENCODERS
3053

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

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

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

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

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

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

    
3093
#endif //CONFIG_ENCODERS
3094

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

    
3109
#if CONFIG_ENCODERS
3110

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

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

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

    
3123
#endif //CONFIG_ENCODERS
3124

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

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

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

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

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

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

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

    
3163
            s->gb= gb;
3164

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3242
            //FIXME reduced res stuff here
3243

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

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

    
3262
    return 0;
3263
}
3264

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3360
    return -1;
3361
}
3362

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

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

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

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

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

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

    
3406
    return sum;
3407
}
3408

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3571
    return mb_num;
3572
}
3573

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3683
    s->mb_num_left= mb_num;
3684

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

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

    
3711
    return 0;
3712
}
3713

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3893
    s->gb= gb;
3894
}
3895

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

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

    
3909
static int h263_skip_b_part(MpegEncContext *s, int cbp)
3910
{
3911
    DECLARE_ALIGNED(16, DCTELEM, dblock[64]);
3912
    int i, mbi;
3913

    
3914
    /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly
3915
     * but real value should be restored in order to be used later (in OBMC condition)
3916
     */
3917
    mbi = s->mb_intra;
3918
    s->mb_intra = 0;
3919
    for (i = 0; i < 6; i++) {
3920
        if (h263_decode_block(s, dblock, i, cbp&32) < 0)
3921
            return -1;
3922
        cbp+=cbp;
3923
    }
3924
    s->mb_intra = mbi;
3925
    return 0;
3926
}
3927

    
3928
static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)
3929
{
3930
    int c, mv = 1;
3931

    
3932
    if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame
3933
        c = get_bits1(gb);
3934
        if (pb_frame == 2 && c)
3935
            mv = !get_bits1(gb);
3936
    } else { // h.263 Annex M improved PB-frame
3937
        mv = get_unary(gb, 0, 4) + 1;
3938
        c = mv & 1;
3939
        mv = !!(mv & 2);
3940
    }
3941
    if(c)
3942
        *cbpb = get_bits(gb, 6);
3943
    return mv;
3944
}
3945

    
3946
int ff_h263_decode_mb(MpegEncContext *s,
3947
                      DCTELEM block[6][64])
3948
{
3949
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3950
    int16_t *mot_val;
3951
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3952
    int cbpb = 0, pb_mv_count = 0;
3953

    
3954
    assert(!s->h263_pred);
3955

    
3956
    if (s->pict_type == FF_P_TYPE) {
3957
        do{
3958
            if (get_bits1(&s->gb)) {
3959
                /* skip mb */
3960
                s->mb_intra = 0;
3961
                for(i=0;i<6;i++)
3962
                    s->block_last_index[i] = -1;
3963
                s->mv_dir = MV_DIR_FORWARD;
3964
                s->mv_type = MV_TYPE_16X16;
3965
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3966
                s->mv[0][0][0] = 0;
3967
                s->mv[0][0][1] = 0;
3968
                s->mb_skipped = !(s->obmc | s->loop_filter);
3969
                goto end;
3970
            }
3971
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3972
            //fprintf(stderr, "\tCBPC: %d", cbpc);
3973
            if (cbpc < 0){
3974
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3975
                return -1;
3976
            }
3977
        }while(cbpc == 20);
3978

    
3979
        s->dsp.clear_blocks(s->block[0]);
3980

    
3981
        dquant = cbpc & 8;
3982
        s->mb_intra = ((cbpc & 4) != 0);
3983
        if (s->mb_intra) goto intra;
3984

    
3985
        if(s->pb_frame && get_bits1(&s->gb))
3986
            pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
3987
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3988

    
3989
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3990
            cbpy ^= 0xF;
3991

    
3992
        cbp = (cbpc & 3) | (cbpy << 2);
3993
        if (dquant) {
3994
            h263_decode_dquant(s);
3995
        }
3996

    
3997
        s->mv_dir = MV_DIR_FORWARD;
3998
        if ((cbpc & 16) == 0) {
3999
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4000
            /* 16x16 motion prediction */
4001
            s->mv_type = MV_TYPE_16X16;
4002
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4003
            if (s->umvplus)
4004
               mx = h263p_decode_umotion(s, pred_x);
4005
            else
4006
               mx = h263_decode_motion(s, pred_x, 1);
4007

    
4008
            if (mx >= 0xffff)
4009
                return -1;
4010

    
4011
            if (s->umvplus)
4012
               my = h263p_decode_umotion(s, pred_y);
4013
            else
4014
               my = h263_decode_motion(s, pred_y, 1);
4015

    
4016
            if (my >= 0xffff)
4017
                return -1;
4018
            s->mv[0][0][0] = mx;
4019
            s->mv[0][0][1] = my;
4020

    
4021
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4022
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4023
        } else {
4024
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4025
            s->mv_type = MV_TYPE_8X8;
4026
            for(i=0;i<4;i++) {
4027
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4028
                if (s->umvplus)
4029
                  mx = h263p_decode_umotion(s, pred_x);
4030
                else
4031
                  mx = h263_decode_motion(s, pred_x, 1);
4032
                if (mx >= 0xffff)
4033
                    return -1;
4034

    
4035
                if (s->umvplus)
4036
                  my = h263p_decode_umotion(s, pred_y);
4037
                else
4038
                  my = h263_decode_motion(s, pred_y, 1);
4039
                if (my >= 0xffff)
4040
                    return -1;
4041
                s->mv[0][i][0] = mx;
4042
                s->mv[0][i][1] = my;
4043
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4044
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4045
                mot_val[0] = mx;
4046
                mot_val[1] = my;
4047
            }
4048
        }
4049
    } else if(s->pict_type==FF_B_TYPE) {
4050
        int mb_type;
4051
        const int stride= s->b8_stride;
4052
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4053
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4054
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4055

    
4056
        //FIXME ugly
4057
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4058
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4059
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4060
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4061

    
4062
        do{
4063
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4064
            if (mb_type < 0){
4065
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4066
                return -1;
4067
            }
4068

    
4069
            mb_type= h263_mb_type_b_map[ mb_type ];
4070
        }while(!mb_type);
4071

    
4072
        s->mb_intra = IS_INTRA(mb_type);
4073
        if(HAS_CBP(mb_type)){
4074
            s->dsp.clear_blocks(s->block[0]);
4075
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4076
            if(s->mb_intra){
4077
                dquant = IS_QUANT(mb_type);
4078
                goto intra;
4079
            }
4080

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

    
4083
            if (cbpy < 0){
4084
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4085
                return -1;
4086
            }
4087

    
4088
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4089
                cbpy ^= 0xF;
4090

    
4091
            cbp = (cbpc & 3) | (cbpy << 2);
4092
        }else
4093
            cbp=0;
4094

    
4095
        assert(!s->mb_intra);
4096

    
4097
        if(IS_QUANT(mb_type)){
4098
            h263_decode_dquant(s);
4099
        }
4100

    
4101
        if(IS_DIRECT(mb_type)){
4102
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4103
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4104
        }else{
4105
            s->mv_dir = 0;
4106
            s->mv_type= MV_TYPE_16X16;
4107
//FIXME UMV
4108

    
4109
            if(USES_LIST(mb_type, 0)){
4110
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4111
                s->mv_dir = MV_DIR_FORWARD;
4112

    
4113
                mx = h263_decode_motion(s, mx, 1);
4114
                my = h263_decode_motion(s, my, 1);
4115

    
4116
                s->mv[0][0][0] = mx;
4117
                s->mv[0][0][1] = my;
4118
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4119
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4120
            }
4121

    
4122
            if(USES_LIST(mb_type, 1)){
4123
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4124
                s->mv_dir |= MV_DIR_BACKWARD;
4125

    
4126
                mx = h263_decode_motion(s, mx, 1);
4127
                my = h263_decode_motion(s, my, 1);
4128

    
4129
                s->mv[1][0][0] = mx;
4130
                s->mv[1][0][1] = my;
4131
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4132
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4133
            }
4134
        }
4135

    
4136
        s->current_picture.mb_type[xy]= mb_type;
4137
    } else { /* I-Frame */
4138
        do{
4139
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4140
            if (cbpc < 0){
4141
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4142
                return -1;
4143
            }
4144
        }while(cbpc == 8);
4145

    
4146
        s->dsp.clear_blocks(s->block[0]);
4147

    
4148
        dquant = cbpc & 4;
4149
        s->mb_intra = 1;
4150
intra:
4151
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4152
        if (s->h263_aic) {
4153
            s->ac_pred = get_bits1(&s->gb);
4154
            if(s->ac_pred){
4155
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4156

    
4157
                s->h263_aic_dir = get_bits1(&s->gb);
4158
            }
4159
        }else
4160
            s->ac_pred = 0;
4161

    
4162
        if(s->pb_frame && get_bits1(&s->gb))
4163
            pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
4164
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4165
        if(cbpy<0){
4166
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4167
            return -1;
4168
        }
4169
        cbp = (cbpc & 3) | (cbpy << 2);
4170
        if (dquant) {
4171
            h263_decode_dquant(s);
4172
        }
4173

    
4174
        pb_mv_count += !!s->pb_frame;
4175
    }
4176

    
4177
    while(pb_mv_count--){
4178
        h263_decode_motion(s, 0, 1);
4179
        h263_decode_motion(s, 0, 1);
4180
    }
4181

    
4182
    /* decode each block */
4183
    for (i = 0; i < 6; i++) {
4184
        if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4185
            return -1;
4186
        cbp+=cbp;
4187
    }
4188

    
4189
    if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0)
4190
        return -1;
4191
    if(s->obmc && !s->mb_intra){
4192
        if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4193
            preview_obmc(s);
4194
    }
4195
end:
4196

    
4197
        /* per-MB end of slice check */
4198
    {
4199
        int v= show_bits(&s->gb, 16);
4200

    
4201
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4202
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4203
        }
4204

    
4205
        if(v==0)
4206
            return SLICE_END;
4207
    }
4208

    
4209
    return SLICE_OK;
4210
}
4211

    
4212
int ff_mpeg4_decode_mb(MpegEncContext *s,
4213
                      DCTELEM block[6][64])
4214
{
4215
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4216
    int16_t *mot_val;
4217
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4218
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
4219

    
4220
    assert(s->h263_pred);
4221

    
4222
    if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
4223
        do{
4224
            if (get_bits1(&s->gb)) {
4225
                /* skip mb */
4226
                s->mb_intra = 0;
4227
                for(i=0;i<6;i++)
4228
                    s->block_last_index[i] = -1;
4229
                s->mv_dir = MV_DIR_FORWARD;
4230
                s->mv_type = MV_TYPE_16X16;
4231
                if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4232
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4233
                    s->mcsel=1;
4234
                    s->mv[0][0][0]= get_amv(s, 0);
4235
                    s->mv[0][0][1]= get_amv(s, 1);
4236

    
4237
                    s->mb_skipped = 0;
4238
                }else{
4239
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4240
                    s->mcsel=0;
4241
                    s->mv[0][0][0] = 0;
4242
                    s->mv[0][0][1] = 0;
4243
                    s->mb_skipped = 1;
4244
                }
4245
                goto end;
4246
            }
4247
            cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4248
            //fprintf(stderr, "\tCBPC: %d", cbpc);
4249
            if (cbpc < 0){
4250
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4251
                return -1;
4252
            }
4253
        }while(cbpc == 20);
4254

    
4255
        s->dsp.clear_blocks(s->block[0]);
4256
        dquant = cbpc & 8;
4257
        s->mb_intra = ((cbpc & 4) != 0);
4258
        if (s->mb_intra) goto intra;
4259

    
4260
        if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4261
            s->mcsel= get_bits1(&s->gb);
4262
        else s->mcsel= 0;
4263
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4264

    
4265
        cbp = (cbpc & 3) | (cbpy << 2);
4266
        if (dquant) {
4267
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4268
        }
4269
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4270
            s->interlaced_dct= get_bits1(&s->gb);
4271

    
4272
        s->mv_dir = MV_DIR_FORWARD;
4273
        if ((cbpc & 16) == 0) {
4274
            if(s->mcsel){
4275
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4276
                /* 16x16 global motion prediction */
4277
                s->mv_type = MV_TYPE_16X16;
4278
                mx= get_amv(s, 0);
4279
                my= get_amv(s, 1);
4280
                s->mv[0][0][0] = mx;
4281
                s->mv[0][0][1] = my;
4282
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4283
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4284
                /* 16x8 field motion prediction */
4285
                s->mv_type= MV_TYPE_FIELD;
4286

    
4287
                s->field_select[0][0]= get_bits1(&s->gb);
4288
                s->field_select[0][1]= get_bits1(&s->gb);
4289

    
4290
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4291

    
4292
                for(i=0; i<2; i++){
4293
                    mx = h263_decode_motion(s, pred_x, s->f_code);
4294
                    if (mx >= 0xffff)
4295
                        return -1;
4296

    
4297
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
4298
                    if (my >= 0xffff)
4299
                        return -1;
4300

    
4301
                    s->mv[0][i][0] = mx;
4302
                    s->mv[0][i][1] = my;
4303
                }
4304
            }else{
4305
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4306
                /* 16x16 motion prediction */
4307
                s->mv_type = MV_TYPE_16X16;
4308
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4309
                mx = h263_decode_motion(s, pred_x, s->f_code);
4310

    
4311
                if (mx >= 0xffff)
4312
                    return -1;
4313

    
4314
                my = h263_decode_motion(s, pred_y, s->f_code);
4315

    
4316
                if (my >= 0xffff)
4317
                    return -1;
4318
                s->mv[0][0][0] = mx;
4319
                s->mv[0][0][1] = my;
4320
            }
4321
        } else {
4322
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4323
            s->mv_type = MV_TYPE_8X8;
4324
            for(i=0;i<4;i++) {
4325
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4326
                mx = h263_decode_motion(s, pred_x, s->f_code);
4327
                if (mx >= 0xffff)
4328
                    return -1;
4329

    
4330
                my = h263_decode_motion(s, pred_y, s->f_code);
4331
                if (my >= 0xffff)
4332
                    return -1;
4333
                s->mv[0][i][0] = mx;
4334
                s->mv[0][i][1] = my;
4335
                mot_val[0] = mx;
4336
                mot_val[1] = my;
4337
            }
4338
        }
4339
    } else if(s->pict_type==FF_B_TYPE) {
4340
        int modb1; // first bit of modb
4341
        int modb2; // second bit of modb
4342
        int mb_type;
4343

    
4344
        s->mb_intra = 0; //B-frames never contain intra blocks
4345
        s->mcsel=0;      //     ...               true gmc blocks
4346

    
4347
        if(s->mb_x==0){
4348
            for(i=0; i<2; i++){
4349
                s->last_mv[i][0][0]=
4350
                s->last_mv[i][0][1]=
4351
                s->last_mv[i][1][0]=
4352
                s->last_mv[i][1][1]= 0;
4353
            }
4354
        }
4355

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

    
4359
        if(s->mb_skipped){
4360
                /* skip mb */
4361
            for(i=0;i<6;i++)
4362
                s->block_last_index[i] = -1;
4363

    
4364
            s->mv_dir = MV_DIR_FORWARD;
4365
            s->mv_type = MV_TYPE_16X16;
4366
            s->mv[0][0][0] = 0;
4367
            s->mv[0][0][1] = 0;
4368
            s->mv[1][0][0] = 0;
4369
            s->mv[1][0][1] = 0;
4370
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4371
            goto end;
4372
        }
4373

    
4374
        modb1= get_bits1(&s->gb);
4375
        if(modb1){
4376
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4377
            cbp=0;
4378
        }else{
4379
            modb2= get_bits1(&s->gb);
4380
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4381
            if(mb_type<0){
4382
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4383
                return -1;
4384
            }
4385
            mb_type= mb_type_b_map[ mb_type ];
4386
            if(modb2) cbp= 0;
4387
            else{
4388
                s->dsp.clear_blocks(s->block[0]);
4389
                cbp= get_bits(&s->gb, 6);
4390
            }
4391

    
4392
            if ((!IS_DIRECT(mb_type)) && cbp) {
4393
                if(get_bits1(&s->gb)){
4394
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4395
                }
4396
            }
4397

    
4398
            if(!s->progressive_sequence){
4399
                if(cbp)
4400
                    s->interlaced_dct= get_bits1(&s->gb);
4401

    
4402
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4403
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4404
                    mb_type &= ~MB_TYPE_16x16;
4405

    
4406
                    if(USES_LIST(mb_type, 0)){
4407
                        s->field_select[0][0]= get_bits1(&s->gb);
4408
                        s->field_select[0][1]= get_bits1(&s->gb);
4409
                    }
4410
                    if(USES_LIST(mb_type, 1)){
4411
                        s->field_select[1][0]= get_bits1(&s->gb);
4412
                        s->field_select[1][1]= get_bits1(&s->gb);
4413
                    }
4414
                }
4415
            }
4416

    
4417
            s->mv_dir = 0;
4418
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4419
                s->mv_type= MV_TYPE_16X16;
4420

    
4421
                if(USES_LIST(mb_type, 0)){
4422
                    s->mv_dir = MV_DIR_FORWARD;
4423

    
4424
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4425
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4426
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4427
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4428
                }
4429

    
4430
                if(USES_LIST(mb_type, 1)){
4431
                    s->mv_dir |= MV_DIR_BACKWARD;
4432

    
4433
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4434
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4435
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4436
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4437
                }
4438
            }else if(!IS_DIRECT(mb_type)){
4439
                s->mv_type= MV_TYPE_FIELD;
4440

    
4441
                if(USES_LIST(mb_type, 0)){
4442
                    s->mv_dir = MV_DIR_FORWARD;
4443

    
4444
                    for(i=0; i<2; i++){
4445
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4446
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4447
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4448
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4449
                    }
4450
                }
4451

    
4452
                if(USES_LIST(mb_type, 1)){
4453
                    s->mv_dir |= MV_DIR_BACKWARD;
4454

    
4455
                    for(i=0; i<2; i++){
4456
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4457
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4458
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4459
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4460
                    }
4461
                }
4462
            }
4463
        }
4464

    
4465
        if(IS_DIRECT(mb_type)){
4466
            if(IS_SKIP(mb_type))
4467
                mx=my=0;
4468
            else{
4469
                mx = h263_decode_motion(s, 0, 1);
4470
                my = h263_decode_motion(s, 0, 1);
4471
            }
4472

    
4473
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4474
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4475
        }
4476
        s->current_picture.mb_type[xy]= mb_type;
4477
    } else { /* I-Frame */
4478
        do{
4479
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4480
            if (cbpc < 0){
4481
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4482
                return -1;
4483
            }
4484
        }while(cbpc == 8);
4485

    
4486
        dquant = cbpc & 4;
4487
        s->mb_intra = 1;
4488
intra:
4489
        s->ac_pred = get_bits1(&s->gb);
4490
        if(s->ac_pred)
4491
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4492
        else
4493
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4494

    
4495
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4496
        if(cbpy<0){
4497
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4498
            return -1;
4499
        }
4500
        cbp = (cbpc & 3) | (cbpy << 2);
4501

    
4502
        s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4503

    
4504
        if (dquant) {
4505
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4506
        }
4507

    
4508
        if(!s->progressive_sequence)
4509
            s->interlaced_dct= get_bits1(&s->gb);
4510

    
4511
        s->dsp.clear_blocks(s->block[0]);
4512
        /* decode each block */
4513
        for (i = 0; i < 6; i++) {
4514
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4515
                return -1;
4516
            cbp+=cbp;
4517
        }
4518
        goto end;
4519
    }
4520

    
4521
    /* decode each block */
4522
    for (i = 0; i < 6; i++) {
4523
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4524
            return -1;
4525
        cbp+=cbp;
4526
    }
4527
end:
4528

    
4529
        /* per-MB end of slice check */
4530
    if(s->codec_id==CODEC_ID_MPEG4){
4531
        if(mpeg4_is_resync(s)){
4532
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4533
            if(s->pict_type==FF_B_TYPE && s->next_picture.mbskip_table[xy + delta])
4534
                return SLICE_OK;
4535
            return SLICE_END;
4536
        }
4537
    }
4538

    
4539
    return SLICE_OK;
4540
}
4541

    
4542
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4543
{
4544
    int code, val, sign, shift, l;
4545
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4546

    
4547
    if (code == 0)
4548
        return pred;
4549
    if (code < 0)
4550
        return 0xffff;
4551

    
4552
    sign = get_bits1(&s->gb);
4553
    shift = f_code - 1;
4554
    val = code;
4555
    if (shift) {
4556
        val = (val - 1) << shift;
4557
        val |= get_bits(&s->gb, shift);
4558
        val++;
4559
    }
4560
    if (sign)
4561
        val = -val;
4562
    val += pred;
4563

    
4564
    /* modulo decoding */
4565
    if (!s->h263_long_vectors) {
4566
        l = INT_BIT - 5 - f_code;
4567
        val = (val<<l)>>l;
4568
    } else {
4569
        /* horrible h263 long vector mode */
4570
        if (pred < -31 && val < -63)
4571
            val += 64;
4572
        if (pred > 32 && val > 63)
4573
            val -= 64;
4574

    
4575
    }
4576
    return val;
4577
}
4578

    
4579
/* Decodes RVLC of H.263+ UMV */
4580
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4581
{
4582
   int code = 0, sign;
4583

    
4584
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
4585
      return pred;
4586

    
4587
   code = 2 + get_bits1(&s->gb);
4588

    
4589
   while (get_bits1(&s->gb))
4590
   {
4591
      code <<= 1;
4592
      code += get_bits1(&s->gb);
4593
   }
4594
   sign = code & 1;
4595
   code >>= 1;
4596

    
4597
   code = (sign) ? (pred - code) : (pred + code);
4598
#ifdef DEBUG
4599
   av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4600
#endif
4601
   return code;
4602

    
4603
}
4604

    
4605
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4606
                             int n, int coded)
4607
{
4608
    int code, level, i, j, last, run;
4609
    RLTable *rl = &rl_inter;
4610
    const uint8_t *scan_table;
4611
    GetBitContext gb= s->gb;
4612

    
4613
    scan_table = s->intra_scantable.permutated;
4614
    if (s->h263_aic && s->mb_intra) {
4615
        rl = &rl_intra_aic;
4616
        i = 0;
4617
        if (s->ac_pred) {
4618
            if (s->h263_aic_dir)
4619
                scan_table = s->intra_v_scantable.permutated; /* left */
4620
            else
4621
                scan_table = s->intra_h_scantable.permutated; /* top */
4622
        }
4623
    } else if (s->mb_intra) {
4624
        /* DC coef */
4625
        if(s->codec_id == CODEC_ID_RV10){
4626
#if CONFIG_RV10_DECODER
4627
          if (s->rv10_version == 3 && s->pict_type == FF_I_TYPE) {
4628
            int component, diff;
4629
            component = (n <= 3 ? 0 : n - 4 + 1);
4630
            level = s->last_dc[component];
4631
            if (s->rv10_first_dc_coded[component]) {
4632
                diff = rv_decode_dc(s, n);
4633
                if (diff == 0xffff)
4634
                    return -1;
4635
                level += diff;
4636
                level = level & 0xff; /* handle wrap round */
4637
                s->last_dc[component] = level;
4638
            } else {
4639
                s->rv10_first_dc_coded[component] = 1;
4640
            }
4641
          } else {
4642
                level = get_bits(&s->gb, 8);
4643
                if (level == 255)
4644
                    level = 128;
4645
          }
4646
#endif
4647
        }else{
4648
            level = get_bits(&s->gb, 8);
4649
            if((level&0x7F) == 0){
4650
                av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4651
                if(s->error_recognition >= FF_ER_COMPLIANT)
4652
                    return -1;
4653
            }
4654
            if (level == 255)
4655
                level = 128;
4656
        }
4657
        block[0] = level;
4658
        i = 1;
4659
    } else {
4660
        i = 0;
4661
    }
4662
    if (!coded) {
4663
        if (s->mb_intra && s->h263_aic)
4664
            goto not_coded;
4665
        s->block_last_index[n] = i - 1;
4666
        return 0;
4667
    }
4668
retry:
4669
    for(;;) {
4670
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4671
        if (code < 0){
4672
            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4673
            return -1;
4674
        }
4675
        if (code == rl->n) {
4676
            /* escape */
4677
            if (s->h263_flv > 1) {
4678
                int is11 = get_bits1(&s->gb);
4679
                last = get_bits1(&s->gb);
4680
                run = get_bits(&s->gb, 6);
4681
                if(is11){
4682
                    level = get_sbits(&s->gb, 11);
4683
                } else {
4684
                    level = get_sbits(&s->gb, 7);
4685
                }
4686
            } else {
4687
                last = get_bits1(&s->gb);
4688
                run = get_bits(&s->gb, 6);
4689
                level = (int8_t)get_bits(&s->gb, 8);
4690
                if(level == -128){
4691
                    if (s->codec_id == CODEC_ID_RV10) {
4692
                        /* XXX: should patch encoder too */
4693
                        level = get_sbits(&s->gb, 12);
4694
                    }else{
4695
                        level = get_bits(&s->gb, 5);
4696
                        level |= get_sbits(&s->gb, 6)<<5;
4697
                    }
4698
                }
4699
            }
4700
        } else {
4701
            run = rl->table_run[code];
4702
            level = rl->table_level[code];
4703
            last = code >= rl->last;
4704
            if (get_bits1(&s->gb))
4705
                level = -level;
4706
        }
4707
        i += run;
4708
        if (i >= 64){
4709
            if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4710
                //Looks like a hack but no, it's the way it is supposed to work ...
4711
                rl = &rl_intra_aic;
4712
                i = 0;
4713
                s->gb= gb;
4714
                s->dsp.clear_block(block);
4715
                goto retry;
4716
            }
4717
            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4718
            return -1;
4719
        }
4720
        j = scan_table[i];
4721
        block[j] = level;
4722
        if (last)
4723
            break;
4724
        i++;
4725
    }
4726
not_coded:
4727
    if (s->mb_intra && s->h263_aic) {
4728
        h263_pred_acdc(s, block, n);
4729
        i = 63;
4730
    }
4731
    s->block_last_index[n] = i;
4732
    return 0;
4733
}
4734

    
4735
/**
4736
 * decodes the dc value.
4737
 * @param n block index (0-3 are luma, 4-5 are chroma)
4738
 * @param dir_ptr the prediction direction will be stored here
4739
 * @return the quantized dc
4740
 */
4741
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4742
{
4743
    int level, code;
4744

    
4745
    if (n < 4)
4746
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4747
    else
4748
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4749
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4750
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4751
        return -1;
4752
    }
4753
    if (code == 0) {
4754
        level = 0;
4755
    } else {
4756
        if(IS_3IV1){
4757
            if(code==1)
4758
                level= 2*get_bits1(&s->gb)-1;
4759
            else{
4760
                if(get_bits1(&s->gb))
4761
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4762
                else
4763
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4764
            }
4765
        }else{
4766
            level = get_xbits(&s->gb, code);
4767
        }
4768

    
4769
        if (code > 8){
4770
            if(get_bits1(&s->gb)==0){ /* marker */
4771
                if(s->error_recognition>=2){
4772
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4773
                    return -1;
4774
                }
4775
            }
4776
        }
4777
    }
4778

    
4779
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4780
}
4781

    
4782
/**
4783