Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ e1f03acc

History | View | Annotate | Download (190 KB)

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

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

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

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

    
44
#define INTRA_MCBPC_VLC_BITS 6
45
#define INTER_MCBPC_VLC_BITS 7
46
#define CBPY_VLC_BITS 6
47
#define MV_VLC_BITS 9
48
#define DC_VLC_BITS 9
49
#define SPRITE_TRAJ_VLC_BITS 6
50
#define MB_TYPE_B_VLC_BITS 4
51
#define TEX_VLC_BITS 9
52

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

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

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

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

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

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

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

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

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

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

    
132
#ifdef CONFIG_ENCODERS
133

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

    
137
    if(aspect.num==0) aspect= (AVRational){1,1};
138

    
139
    for(i=1; i<6; i++){
140
        if(av_cmp_q(pixel_aspect[i], aspect) == 0){
141
            s->aspect_ratio_info=i;
142
            return;
143
        }
144
    }
145
    
146
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
147
}
148

    
149
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
150
{
151
      int format;
152

    
153
      align_put_bits(&s->pb);
154

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

    
186
      if(s->h263_aic){
187
        s->y_dc_scale_table= 
188
          s->c_dc_scale_table= ff_aic_dc_scale_table;
189
      }else{
190
        s->y_dc_scale_table=
191
          s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
192
      }
193
}
194

    
195
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
196
{
197
    int format;
198

    
199
    align_put_bits(&s->pb);
200

    
201
    /* Update the pointer to last GOB */
202
    s->ptr_lastgob = pbBufPtr(&s->pb);
203
    s->gob_number = 0;
204

    
205
    put_bits(&s->pb, 22, 0x20); /* PSC */
206
    put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / 
207
                         s->avctx->frame_rate) & 0xff);
208

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

    
268
            put_bits(&s->pb,4,s->aspect_ratio_info);
269
            put_bits(&s->pb,9,(s->width >> 2) - 1);
270
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
271
            put_bits(&s->pb,9,(s->height >> 2));
272
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
273
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
274
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
275
            }
276
        }
277
        
278
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
279
        if (s->umvplus)
280
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
281
//FIXME check actual requested range
282
            put_bits(&s->pb,2,1); /* unlimited */
283

    
284
        put_bits(&s->pb, 5, s->qscale);
285
    }
286

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

    
289
    if(s->h263_aic){
290
         s->y_dc_scale_table= 
291
         s->c_dc_scale_table= ff_aic_dc_scale_table;
292
    }else{
293
        s->y_dc_scale_table=
294
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
295
    }
296
}
297

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

    
319
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
320
    int last=0;
321
    int j;
322
    int rate=0;
323

    
324
    for(j=1; j<=block_last_index; j++){
325
        const int index= scantable[j];
326
        int level= block[index];
327
        if(level){
328
            level+= 64;
329
            if((level&(~127)) == 0){
330
                if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
331
                else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
332
            }else
333
                rate += s->ac_esc_length;
334
            level-= 64;
335

    
336
            last= j;
337
        }
338
    }
339
    
340
    return rate;
341
}
342

    
343
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
344
{
345
    int score= 0;
346
    int i, n;
347
    int8_t * const qscale_table= s->current_picture.qscale_table;
348

    
349
    memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
350
    
351
    for(n=0; n<6; n++){
352
        int16_t *ac_val, *ac_val1;
353
        
354
        score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
355

    
356
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
357
        ac_val1= ac_val;
358
        if(dir[n]){
359
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
360
            /* top prediction */
361
            ac_val-= s->block_wrap[n]*16;
362
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
363
                /* same qscale */
364
                for(i=1; i<8; i++){
365
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
366
                    block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
367
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
368
                    ac_val1[i+8]= level;
369
                }
370
            }else{
371
                /* different qscale, we must rescale */
372
                for(i=1; i<8; i++){
373
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
374
                    block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
375
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
376
                    ac_val1[i+8]= level;
377
                }
378
            }
379
            st[n]= s->intra_h_scantable.permutated;
380
        }else{
381
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
382
            /* left prediction */
383
            ac_val-= 16;
384
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
385
                /* same qscale */
386
                for(i=1; i<8; i++){
387
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
388
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
389
                    ac_val1[i  ]= level;
390
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
391
                }
392
            }else{
393
                /* different qscale, we must rescale */
394
                for(i=1; i<8; i++){
395
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
396
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
397
                    ac_val1[i  ]= level;
398
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
399
                }
400
            }
401
            st[n]= s->intra_v_scantable.permutated;
402
        }
403

    
404
        for(i=63; i>0; i--) //FIXME optimize
405
            if(block[n][ st[n][i] ]) break;
406
        s->block_last_index[n]= i;
407

    
408
        score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
409
    }
410

    
411
    return score < 0;
412
}
413

    
414
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
415
{
416
    int i, n;
417
    memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
418

    
419
    for(n=0; n<6; n++){
420
        int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
421

    
422
        st[n]= s->intra_scantable.permutated;
423
        if(dir[n]){
424
            /* top prediction */
425
            for(i=1; i<8; i++){
426
                block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
427
            }
428
        }else{
429
            /* left prediction */
430
            for(i=1; i<8; i++){
431
                block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
432
            }
433
        }
434
    }
435
}
436

    
437
/**
438
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
439
 */
440
void ff_clean_h263_qscales(MpegEncContext *s){
441
    int i;
442
    int8_t * const qscale_table= s->current_picture.qscale_table;
443
    
444
    for(i=1; i<s->mb_num; i++){
445
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
446
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
447
    }
448
    for(i=s->mb_num-2; i>=0; i--){
449
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
450
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
451
    }
452
}
453

    
454
/**
455
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
456
 */
457
void ff_clean_mpeg4_qscales(MpegEncContext *s){
458
    int i;
459
    int8_t * const qscale_table= s->current_picture.qscale_table;
460

    
461
    ff_clean_h263_qscales(s);
462
    
463
    for(i=1; i<s->mb_num; i++){
464
        int mb_xy= s->mb_index2xy[i];
465
    
466
        if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){
467
            s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V;
468
            s->mb_type[mb_xy]|= MB_TYPE_INTER;
469
        }
470
    }
471

    
472
    if(s->pict_type== B_TYPE){
473
        int odd=0;
474
        /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
475
           for the actual adaptive quantization */
476
        
477
        for(i=0; i<s->mb_num; i++){
478
            int mb_xy= s->mb_index2xy[i];
479
            odd += qscale_table[mb_xy]&1;
480
        }
481
        
482
        if(2*odd > s->mb_num) odd=1;
483
        else                  odd=0;
484
        
485
        for(i=0; i<s->mb_num; i++){
486
            int mb_xy= s->mb_index2xy[i];
487
            if((qscale_table[mb_xy]&1) != odd)
488
                qscale_table[mb_xy]++;
489
            if(qscale_table[mb_xy] > 31)
490
                qscale_table[mb_xy]= 31;
491
        }            
492
    
493
        for(i=1; i<s->mb_num; i++){
494
            int mb_xy= s->mb_index2xy[i];
495
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){
496
                s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT;
497
                s->mb_type[mb_xy]|= MB_TYPE_BIDIR;
498
            }
499
        }
500
    }
501
}
502

    
503
#endif //CONFIG_ENCODERS
504
/**
505
 *
506
 * @return the mb_type
507
 */
508
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
509
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
510
    const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next?
511
    int xy= s->block_index[0];
512
    uint16_t time_pp= s->pp_time;
513
    uint16_t time_pb= s->pb_time;
514
    int i;
515
    
516
    //FIXME avoid divides
517
    
518
    if(IS_8X8(colocated_mb_type)){
519
        s->mv_type = MV_TYPE_8X8;
520
        for(i=0; i<4; i++){
521
            xy= s->block_index[i];
522
            s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
523
            s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
524
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
525
                                : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
526
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1] 
527
                                : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
528
        }
529
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
530
    } else if(IS_INTERLACED(colocated_mb_type)){
531
        s->mv_type = MV_TYPE_FIELD;
532
        for(i=0; i<2; i++){
533
            if(s->top_field_first){
534
                time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
535
                time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
536
            }else{
537
                time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
538
                time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
539
            }
540
            s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
541
            s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
542
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
543
                                : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
544
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] 
545
                                : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
546
        }
547
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
548
    }else{
549
        s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
550
        s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
551
        s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
552
                            : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
553
        s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
554
                            : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
555
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
556
            s->mv_type= MV_TYPE_16X16;
557
        else
558
            s->mv_type= MV_TYPE_8X8;
559
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
560
    }
561
}
562

    
563
void ff_h263_update_motion_val(MpegEncContext * s){
564
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
565
               //FIXME a lot of thet is only needed for !low_delay
566
    const int wrap = s->block_wrap[0];
567
    const int xy = s->block_index[0];
568
    
569
    s->current_picture.mbskip_table[mb_xy]= s->mb_skiped; 
570

    
571
    if(s->mv_type != MV_TYPE_8X8){
572
        int motion_x, motion_y;
573
        if (s->mb_intra) {
574
            motion_x = 0;
575
            motion_y = 0;
576
        } else if (s->mv_type == MV_TYPE_16X16) {
577
            motion_x = s->mv[0][0][0];
578
            motion_y = s->mv[0][0][1];
579
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
580
            int i;
581
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
582
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
583
            motion_x = (motion_x>>1) | (motion_x&1);
584
            for(i=0; i<2; i++){
585
                s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
586
                s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
587
                s->field_select_table[mb_xy][i]= s->field_select[0][i];
588
            }
589
        }
590
        
591
        /* no update if 8X8 because it has been done during parsing */
592
        s->motion_val[xy][0] = motion_x;
593
        s->motion_val[xy][1] = motion_y;
594
        s->motion_val[xy + 1][0] = motion_x;
595
        s->motion_val[xy + 1][1] = motion_y;
596
        s->motion_val[xy + wrap][0] = motion_x;
597
        s->motion_val[xy + wrap][1] = motion_y;
598
        s->motion_val[xy + 1 + wrap][0] = motion_x;
599
        s->motion_val[xy + 1 + wrap][1] = motion_y;
600
    }
601

    
602
    if(s->encoding){ //FIXME encoding MUST be cleaned up
603
        if (s->mv_type == MV_TYPE_8X8) 
604
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
605
        else if(s->mb_intra)
606
            s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
607
        else
608
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
609
    }
610
}
611

    
612
#ifdef CONFIG_ENCODERS
613

    
614
static inline int get_p_cbp(MpegEncContext * s,
615
                      DCTELEM block[6][64],
616
                      int motion_x, int motion_y){
617
    int cbp, i;
618

    
619
    if(s->flags & CODEC_FLAG_CBP_RD){
620
        int best_cbpy_score= INT_MAX;
621
        int best_cbpc_score= INT_MAX;
622
        int cbpc = (-1), cbpy= (-1);
623
        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
624
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
625

    
626
        for(i=0; i<4; i++){
627
            int score= inter_MCBPC_bits[i + offset] * lambda;
628
            if(i&1) score += s->coded_score[5];
629
            if(i&2) score += s->coded_score[4];
630

    
631
            if(score < best_cbpc_score){
632
                best_cbpc_score= score;
633
                cbpc= i;
634
            }
635
        }
636

    
637
        for(i=0; i<16; i++){
638
            int score= cbpy_tab[i ^ 0xF][1] * lambda;
639
            if(i&1) score += s->coded_score[3];
640
            if(i&2) score += s->coded_score[2];
641
            if(i&4) score += s->coded_score[1];
642
            if(i&8) score += s->coded_score[0];
643

    
644
            if(score < best_cbpy_score){
645
                best_cbpy_score= score;
646
                cbpy= i;
647
            }
648
        }
649
        cbp= cbpc + 4*cbpy;
650
        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
651
            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
652
                cbp= 0;
653
        }
654

    
655
        for (i = 0; i < 6; i++) {
656
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
657
                s->block_last_index[i]= -1;
658
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
659
            }
660
        }
661
    }else{
662
        cbp= 0;
663
        for (i = 0; i < 6; i++) {
664
            if (s->block_last_index[i] >= 0)
665
                cbp |= 1 << (5 - i);
666
        }
667
    }
668
    return cbp;
669
}
670

    
671
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
672
                            int motion_x, int motion_y, int mb_type){
673
    int cbp=0, i;
674

    
675
    if(s->flags & CODEC_FLAG_CBP_RD){
676
        int score=0;
677
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
678
        
679
        for(i=0; i<6; i++){
680
            if(s->coded_score[i] < 0){
681
                score += s->coded_score[i];
682
                cbp |= 1 << (5 - i);
683
            }
684
        }
685
        
686
        if(cbp){
687
            int zero_score= -6;
688
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
689
                zero_score-= 4; //2*MV + mb_type + cbp bit
690
            }
691

    
692
            zero_score*= lambda;
693
            if(zero_score <= score){
694
                cbp=0;
695
            }
696
        }
697

    
698
        for (i = 0; i < 6; i++) {
699
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
700
                s->block_last_index[i]= -1;
701
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
702
            }
703
        }
704
    }else{
705
        for (i = 0; i < 6; i++) {
706
            if (s->block_last_index[i] >= 0)
707
                cbp |= 1 << (5 - i);
708
        }
709
    }
710
    return cbp;
711
}
712

    
713
void mpeg4_encode_mb(MpegEncContext * s,
714
                    DCTELEM block[6][64],
715
                    int motion_x, int motion_y)
716
{
717
    int cbpc, cbpy, pred_x, pred_y;
718
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
719
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
720
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
721
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
722
    const int dquant_code[5]= {1,0,9,2,3};
723
    
724
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
725
    if (!s->mb_intra) {
726
        /* compute cbp */
727
        int i, cbp;
728
        
729
        if(s->pict_type==B_TYPE){
730
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
731
            int mb_type=  mb_type_table[s->mv_dir];
732
            
733
            if(s->mb_x==0){
734
                s->last_mv[0][0][0]= 
735
                s->last_mv[0][0][1]= 
736
                s->last_mv[1][0][0]= 
737
                s->last_mv[1][0][1]= 0;
738
            }
739
            
740
            assert(s->dquant>=-2 && s->dquant<=2);
741
            assert((s->dquant&1)==0);
742
            assert(mb_type>=0);
743

    
744
            /* nothing to do if this MB was skiped in the next P Frame */
745
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
746
                s->skip_count++;
747
                s->mv[0][0][0]= 
748
                s->mv[0][0][1]= 
749
                s->mv[1][0][0]= 
750
                s->mv[1][0][1]= 0;
751
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
752
                s->qscale -= s->dquant;
753
//                s->mb_skiped=1;
754

    
755
                return;
756
            }
757
            
758
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
759
            
760
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
761
                /* direct MB with MV={0,0} */
762
                assert(s->dquant==0);
763
                
764
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
765

    
766
                if(interleaved_stats){
767
                    s->misc_bits++;
768
                    s->last_bits++;
769
                }
770
                s->skip_count++;
771
                return;
772
            }
773
            
774
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
775
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
776
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
777
            if(cbp) put_bits(&s->pb, 6, cbp);
778
            
779
            if(cbp && mb_type){
780
                if(s->dquant)
781
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
782
                else
783
                    put_bits(&s->pb, 1, 0);
784
            }else
785
                s->qscale -= s->dquant;
786
            
787
            if(!s->progressive_sequence){
788
                if(cbp)
789
                    put_bits(&s->pb, 1, s->interlaced_dct);
790
                if(mb_type) // not diect mode
791
                    put_bits(&s->pb, 1, 0); // no interlaced ME yet
792
            }
793

    
794
            if(interleaved_stats){
795
                s->misc_bits+= get_bits_diff(s);
796
            }
797

    
798
            switch(mb_type)
799
            {
800
            case 0: /* direct */
801
                h263_encode_motion(s, motion_x, 1);
802
                h263_encode_motion(s, motion_y, 1);                
803
                s->b_count++;
804
                s->f_count++;
805
                break;
806
            case 1: /* bidir */
807
                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
808
                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
809
                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
810
                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
811
                s->last_mv[0][0][0]= s->mv[0][0][0];
812
                s->last_mv[0][0][1]= s->mv[0][0][1];
813
                s->last_mv[1][0][0]= s->mv[1][0][0];
814
                s->last_mv[1][0][1]= s->mv[1][0][1];
815
                s->b_count++;
816
                s->f_count++;
817
                break;
818
            case 2: /* backward */
819
                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
820
                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
821
                s->last_mv[1][0][0]= motion_x;
822
                s->last_mv[1][0][1]= motion_y;
823
                s->b_count++;
824
                break;
825
            case 3: /* forward */
826
                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
827
                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
828
                s->last_mv[0][0][0]= motion_x;
829
                s->last_mv[0][0][1]= motion_y;
830
                s->f_count++;
831
                break;
832
            default:
833
                av_log(s->avctx, AV_LOG_ERROR, "unknown mb type\n");
834
                return;
835
            }
836

    
837
            if(interleaved_stats){
838
                s->mv_bits+= get_bits_diff(s);
839
            }
840

    
841
            /* encode each block */
842
            for (i = 0; i < 6; i++) {
843
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
844
            }
845

    
846
            if(interleaved_stats){
847
                s->p_tex_bits+= get_bits_diff(s);
848
            }
849
        }else{ /* s->pict_type==B_TYPE */
850
            cbp= get_p_cbp(s, block, motion_x, motion_y);
851
        
852
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
853
                /* check if the B frames can skip it too, as we must skip it if we skip here 
854
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
855
                if(s->max_b_frames>0){
856
                    int i;
857
                    int x,y, offset;
858
                    uint8_t *p_pic;
859

    
860
                    x= s->mb_x*16;
861
                    y= s->mb_y*16;
862
                    if(x+16 > s->width)  x= s->width-16;
863
                    if(y+16 > s->height) y= s->height-16;
864

    
865
                    offset= x + y*s->linesize;
866
                    p_pic= s->new_picture.data[0] + offset;
867
                    
868
                    s->mb_skiped=1;
869
                    for(i=0; i<s->max_b_frames; i++){
870
                        uint8_t *b_pic;
871
                        int diff;
872
                        Picture *pic= s->reordered_input_picture[i+1];
873

    
874
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
875

    
876
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
877
                        diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
878
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
879
                            s->mb_skiped=0;
880
                            break;
881
                        }
882
                    }
883
                }else
884
                    s->mb_skiped=1; 
885

    
886
                if(s->mb_skiped==1){
887
                    /* skip macroblock */
888
                    put_bits(&s->pb, 1, 1);
889

    
890
                    if(interleaved_stats){
891
                        s->misc_bits++;
892
                        s->last_bits++;
893
                    }
894
                    s->skip_count++;
895
                    
896
                    return;
897
                }
898
            }
899

    
900
            put_bits(&s->pb, 1, 0);        /* mb coded */
901
            cbpc = cbp & 3;
902
            cbpy = cbp >> 2;
903
            cbpy ^= 0xf;
904
            if(s->mv_type==MV_TYPE_16X16){
905
                if(s->dquant) cbpc+= 8;
906
                put_bits(&s->pb,
907
                        inter_MCBPC_bits[cbpc],
908
                        inter_MCBPC_code[cbpc]);
909

    
910
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
911
                if(s->dquant)
912
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
913

    
914
                if(!s->progressive_sequence){
915
                    if(cbp)
916
                        put_bits(pb2, 1, s->interlaced_dct);
917
                    put_bits(pb2, 1, 0); // no interlaced ME yet
918
                }
919
                    
920
                if(interleaved_stats){
921
                    s->misc_bits+= get_bits_diff(s);
922
                }
923

    
924
                /* motion vectors: 16x16 mode */
925
                h263_pred_motion(s, 0, &pred_x, &pred_y);
926
            
927
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
928
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
929
            }else{
930
                put_bits(&s->pb,
931
                        inter_MCBPC_bits[cbpc+16],
932
                        inter_MCBPC_code[cbpc+16]);
933
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
934

    
935
                if(!s->progressive_sequence){
936
                    if(cbp)
937
                        put_bits(pb2, 1, s->interlaced_dct);
938
                }
939
    
940
                if(interleaved_stats){
941
                    s->misc_bits+= get_bits_diff(s);
942
                }
943

    
944
                for(i=0; i<4; i++){
945
                    /* motion vectors: 8x8 mode*/
946
                    h263_pred_motion(s, i, &pred_x, &pred_y);
947

    
948
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
949
                    h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
950
                }
951
            }
952

    
953
            if(interleaved_stats){ 
954
                s->mv_bits+= get_bits_diff(s);
955
            }
956

    
957
            /* encode each block */
958
            for (i = 0; i < 6; i++) {
959
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
960
            }
961

    
962
            if(interleaved_stats){
963
                s->p_tex_bits+= get_bits_diff(s);
964
            }
965
            s->f_count++;
966
        }
967
    } else {
968
        int cbp;
969
        int dc_diff[6];   //dc values with the dc prediction subtracted 
970
        int dir[6];  //prediction direction
971
        int zigzag_last_index[6];
972
        uint8_t *scan_table[6];
973
        int i;
974

    
975
        for(i=0; i<6; i++){
976
            const int level= block[i][0];
977
            uint16_t *dc_ptr;
978

    
979
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
980
            if (i < 4) {
981
                *dc_ptr = level * s->y_dc_scale;
982
            } else {
983
                *dc_ptr = level * s->c_dc_scale;
984
            }
985
        }
986

    
987
        if(s->flags & CODEC_FLAG_AC_PRED){
988
            s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
989
            if(!s->ac_pred)
990
                restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
991
        }else{
992
            for(i=0; i<6; i++)
993
                scan_table[i]= s->intra_scantable.permutated;
994
        }
995

    
996
        /* compute cbp */
997
        cbp = 0;
998
        for (i = 0; i < 6; i++) {
999
            if (s->block_last_index[i] >= 1)
1000
                cbp |= 1 << (5 - i);
1001
        }
1002

    
1003
        cbpc = cbp & 3;
1004
        if (s->pict_type == I_TYPE) {
1005
            if(s->dquant) cbpc+=4;
1006
            put_bits(&s->pb,
1007
                intra_MCBPC_bits[cbpc],
1008
                intra_MCBPC_code[cbpc]);
1009
        } else {
1010
            if(s->dquant) cbpc+=8;
1011
            put_bits(&s->pb, 1, 0);        /* mb coded */
1012
            put_bits(&s->pb,
1013
                inter_MCBPC_bits[cbpc + 4],
1014
                inter_MCBPC_code[cbpc + 4]);
1015
        }
1016
        put_bits(pb2, 1, s->ac_pred);
1017
        cbpy = cbp >> 2;
1018
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1019
        if(s->dquant)
1020
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1021

    
1022
        if(!s->progressive_sequence){
1023
            put_bits(dc_pb, 1, s->interlaced_dct);
1024
        }
1025

    
1026
        if(interleaved_stats){
1027
            s->misc_bits+= get_bits_diff(s);
1028
        }
1029

    
1030
        /* encode each block */
1031
        for (i = 0; i < 6; i++) {
1032
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
1033
        }
1034

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

    
1040
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1041
        if(s->ac_pred)
1042
            restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1043
    }
1044
}
1045

    
1046
void h263_encode_mb(MpegEncContext * s,
1047
                    DCTELEM block[6][64],
1048
                    int motion_x, int motion_y)
1049
{
1050
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
1051
    int16_t pred_dc;
1052
    int16_t rec_intradc[6];
1053
    uint16_t *dc_ptr[6];
1054
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1055
    const int dquant_code[5]= {1,0,9,2,3};
1056
           
1057
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1058
    if (!s->mb_intra) {
1059
        /* compute cbp */
1060
        cbp= get_p_cbp(s, block, motion_x, motion_y);
1061

    
1062
        if ((cbp | motion_x | motion_y | s->dquant) == 0) {
1063
            /* skip macroblock */
1064
            put_bits(&s->pb, 1, 1);
1065
            if(interleaved_stats){
1066
                s->misc_bits++;
1067
                s->last_bits++;
1068
            }
1069
            return;
1070
        }
1071
        put_bits(&s->pb, 1, 0);        /* mb coded */
1072
        
1073
        cbpc = cbp & 3;
1074
        cbpy = cbp >> 2;
1075
        if(s->alt_inter_vlc==0 || cbpc!=3)
1076
            cbpy ^= 0xF;
1077
        if(s->dquant) cbpc+= 8;
1078
        if(s->mv_type==MV_TYPE_16X16){
1079
            put_bits(&s->pb,
1080
                    inter_MCBPC_bits[cbpc],
1081
                    inter_MCBPC_code[cbpc]);
1082

    
1083
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1084
            if(s->dquant)
1085
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1086
                
1087
            if(interleaved_stats){
1088
                s->misc_bits+= get_bits_diff(s);
1089
            }
1090

    
1091
            /* motion vectors: 16x16 mode */
1092
            h263_pred_motion(s, 0, &pred_x, &pred_y);
1093
            
1094
            if (!s->umvplus) {  
1095
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
1096
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
1097
            }
1098
            else {
1099
                h263p_encode_umotion(s, motion_x - pred_x);
1100
                h263p_encode_umotion(s, motion_y - pred_y);
1101
                if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1102
                    /* To prevent Start Code emulation */
1103
                    put_bits(&s->pb,1,1);
1104
            }
1105
        }else{
1106
            put_bits(&s->pb,
1107
                    inter_MCBPC_bits[cbpc+16],
1108
                    inter_MCBPC_code[cbpc+16]);
1109
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1110
            if(s->dquant)
1111
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1112

    
1113
            if(interleaved_stats){
1114
                s->misc_bits+= get_bits_diff(s);
1115
            }
1116

    
1117
            for(i=0; i<4; i++){
1118
                /* motion vectors: 8x8 mode*/
1119
                h263_pred_motion(s, i, &pred_x, &pred_y);
1120

    
1121
                motion_x= s->motion_val[ s->block_index[i] ][0];
1122
                motion_y= s->motion_val[ s->block_index[i] ][1];
1123
                if (!s->umvplus) {  
1124
                    h263_encode_motion(s, motion_x - pred_x, s->f_code);
1125
                    h263_encode_motion(s, motion_y - pred_y, s->f_code);
1126
                }
1127
                else {
1128
                    h263p_encode_umotion(s, motion_x - pred_x);
1129
                    h263p_encode_umotion(s, motion_y - pred_y);
1130
                    if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1131
                        /* To prevent Start Code emulation */
1132
                        put_bits(&s->pb,1,1);
1133
                }
1134
            }
1135
        }
1136

    
1137
        if(interleaved_stats){
1138
            s->mv_bits+= get_bits_diff(s);
1139
        }
1140
    } else {
1141
        int li = s->h263_aic ? 0 : 1;
1142
        assert(s->mb_intra);
1143
        
1144
        cbp = 0;
1145
        for(i=0; i<6; i++) {
1146
            /* Predict DC */
1147
            if (s->h263_aic) {
1148
                int16_t level = block[i][0];
1149
            
1150
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1151
                level -= pred_dc;
1152
                /* Quant */
1153
                if (level < 0)
1154
                    level = (level + (s->qscale >> 1))/(s->y_dc_scale);
1155
                else
1156
                    level = (level - (s->qscale >> 1))/(s->y_dc_scale);
1157
                    
1158
                /* AIC can change CBP */
1159
                if (level == 0 && s->block_last_index[i] == 0)
1160
                    s->block_last_index[i] = -1;
1161
                else if (level < -127)
1162
                    level = -127;
1163
                else if (level > 127)
1164
                    level = 127;
1165
                
1166
                block[i][0] = level;
1167
                /* Reconstruction */ 
1168
                rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
1169
                /* Oddify */
1170
                rec_intradc[i] |= 1;
1171
                //if ((rec_intradc[i] % 2) == 0)
1172
                //    rec_intradc[i]++;
1173
                /* Clipping */
1174
                if (rec_intradc[i] < 0)
1175
                    rec_intradc[i] = 0;
1176
                else if (rec_intradc[i] > 2047)
1177
                    rec_intradc[i] = 2047;
1178
                                
1179
                /* Update AC/DC tables */
1180
                *dc_ptr[i] = rec_intradc[i];
1181
            }
1182
            /* compute cbp */
1183
            if (s->block_last_index[i] >= li)
1184
                cbp |= 1 << (5 - i);
1185
        }
1186

    
1187
        cbpc = cbp & 3;
1188
        if (s->pict_type == I_TYPE) {
1189
            if(s->dquant) cbpc+=4;
1190
            put_bits(&s->pb,
1191
                intra_MCBPC_bits[cbpc],
1192
                intra_MCBPC_code[cbpc]);
1193
        } else {
1194
            if(s->dquant) cbpc+=8;
1195
            put_bits(&s->pb, 1, 0);        /* mb coded */
1196
            put_bits(&s->pb,
1197
                inter_MCBPC_bits[cbpc + 4],
1198
                inter_MCBPC_code[cbpc + 4]);
1199
        }
1200
        if (s->h263_aic) {
1201
            /* XXX: currently, we do not try to use ac prediction */
1202
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
1203
        }
1204
        cbpy = cbp >> 2;
1205
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1206
        if(s->dquant)
1207
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1208

    
1209
        if(interleaved_stats){
1210
            s->misc_bits+= get_bits_diff(s);
1211
        }
1212
    }
1213

    
1214
    for(i=0; i<6; i++) {
1215
        /* encode each block */
1216
        h263_encode_block(s, block[i], i);
1217
    
1218
        /* Update INTRADC for decoding */
1219
        if (s->h263_aic && s->mb_intra) {
1220
            block[i][0] = rec_intradc[i];
1221
            
1222
        }
1223
    }
1224

    
1225
    if(interleaved_stats){
1226
        if (!s->mb_intra) {
1227
            s->p_tex_bits+= get_bits_diff(s);
1228
            s->f_count++;
1229
        }else{
1230
            s->i_tex_bits+= get_bits_diff(s);
1231
            s->i_count++;
1232
        }
1233
    }
1234
}
1235
#endif
1236

    
1237
int ff_h263_loop_filter(MpegEncContext * s){
1238
    int qp_c;
1239
    const int linesize  = s->linesize;
1240
    const int uvlinesize= s->uvlinesize;
1241
    const int xy = s->mb_y * s->mb_stride + s->mb_x;
1242
    uint8_t *dest_y = s->dest[0];
1243
    uint8_t *dest_cb= s->dest[1];
1244
    uint8_t *dest_cr= s->dest[2];
1245
    
1246
//    if(s->pict_type==B_TYPE && !s->readable) return;
1247

    
1248
    /*
1249
       Diag Top
1250
       Left Center
1251
    */
1252
    if(!IS_SKIP(s->current_picture.mb_type[xy])){
1253
        qp_c= s->qscale;
1254
        s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1255
        s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1256
    }else
1257
        qp_c= 0;
1258

    
1259
    if(s->mb_y){
1260
        int qp_dt, qp_t, qp_tc;
1261

    
1262
        if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1263
            qp_t=0;
1264
        else 
1265
            qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1266

    
1267
        if(qp_c) 
1268
            qp_tc= qp_c;
1269
        else
1270
            qp_tc= qp_t;
1271
            
1272
        if(qp_tc){
1273
            const int chroma_qp= s->chroma_qscale_table[qp_tc];
1274
            s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
1275
            s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
1276
        
1277
            s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1278
            s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1279
        }
1280
        
1281
        if(qp_t)
1282
            s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_t);
1283
        
1284
        if(s->mb_x){
1285
            if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1286
                qp_dt= qp_t;
1287
            else
1288
                qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1289
            
1290
            if(qp_dt){
1291
                const int chroma_qp= s->chroma_qscale_table[qp_dt];
1292
                s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
1293
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1294
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1295
            }
1296
        }
1297
    }
1298

    
1299
    if(qp_c){
1300
        s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1301
        if(s->mb_y + 1 == s->mb_height)
1302
            s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1303
    }
1304
    
1305
    if(s->mb_x){
1306
        int qp_lc;
1307
        if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1308
            qp_lc= qp_c;
1309
        else
1310
            qp_lc= s->current_picture.qscale_table[xy-1];
1311
        
1312
        if(qp_lc){
1313
            s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1314
            if(s->mb_y + 1 == s->mb_height){
1315
                const int chroma_qp= s->chroma_qscale_table[qp_lc];
1316
                s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1317
                s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1318
                s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1319
            }
1320
        }
1321
    }
1322
}
1323

    
1324
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1325
{
1326
    int x, y, wrap, a, c, pred_dc, scale;
1327
    int16_t *dc_val, *ac_val;
1328

    
1329
    /* find prediction */
1330
    if (n < 4) {
1331
        x = 2 * s->mb_x + 1 + (n & 1);
1332
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1333
        wrap = s->mb_width * 2 + 2;
1334
        dc_val = s->dc_val[0];
1335
        ac_val = s->ac_val[0][0];
1336
        scale = s->y_dc_scale;
1337
    } else {
1338
        x = s->mb_x + 1;
1339
        y = s->mb_y + 1;
1340
        wrap = s->mb_width + 2;
1341
        dc_val = s->dc_val[n - 4 + 1];
1342
        ac_val = s->ac_val[n - 4 + 1][0];
1343
        scale = s->c_dc_scale;
1344
    }
1345
    /* B C
1346
     * A X 
1347
     */
1348
    a = dc_val[(x - 1) + (y) * wrap];
1349
    c = dc_val[(x) + (y - 1) * wrap];
1350
    
1351
    /* No prediction outside GOB boundary */
1352
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1353
        c = 1024;
1354
    pred_dc = 1024;
1355
    /* just DC prediction */
1356
    if (a != 1024 && c != 1024)
1357
        pred_dc = (a + c) >> 1;
1358
    else if (a != 1024)
1359
        pred_dc = a;
1360
    else
1361
        pred_dc = c;
1362
    
1363
    /* we assume pred is positive */
1364
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1365
    *dc_val_ptr = &dc_val[x + y * wrap];
1366
    return pred_dc;
1367
}
1368

    
1369
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1370
{
1371
    int x, y, wrap, a, c, pred_dc, scale, i;
1372
    int16_t *dc_val, *ac_val, *ac_val1;
1373

    
1374
    /* find prediction */
1375
    if (n < 4) {
1376
        x = 2 * s->mb_x + 1 + (n & 1);
1377
        y = 2 * s->mb_y + 1 + (n>> 1);
1378
        wrap = s->mb_width * 2 + 2;
1379
        dc_val = s->dc_val[0];
1380
        ac_val = s->ac_val[0][0];
1381
        scale = s->y_dc_scale;
1382
    } else {
1383
        x = s->mb_x + 1;
1384
        y = s->mb_y + 1;
1385
        wrap = s->mb_width + 2;
1386
        dc_val = s->dc_val[n - 4 + 1];
1387
        ac_val = s->ac_val[n - 4 + 1][0];
1388
        scale = s->c_dc_scale;
1389
    }
1390
    
1391
    ac_val += ((y) * wrap + (x)) * 16;
1392
    ac_val1 = ac_val;
1393
    
1394
    /* B C
1395
     * A X 
1396
     */
1397
    a = dc_val[(x - 1) + (y) * wrap];
1398
    c = dc_val[(x) + (y - 1) * wrap];
1399
    
1400
    /* No prediction outside GOB boundary */
1401
    if(s->first_slice_line && n!=3){
1402
        if(n!=2) c= 1024;
1403
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1404
    }
1405
    
1406
    if (s->ac_pred) {
1407
        pred_dc = 1024;
1408
        if (s->h263_aic_dir) {
1409
            /* left prediction */
1410
            if (a != 1024) {
1411
                ac_val -= 16;
1412
                for(i=1;i<8;i++) {
1413
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1414
                }
1415
                pred_dc = a;
1416
            }
1417
        } else {
1418
            /* top prediction */
1419
            if (c != 1024) {
1420
                ac_val -= 16 * wrap;
1421
                for(i=1;i<8;i++) {
1422
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1423
                }
1424
                pred_dc = c;
1425
            }
1426
        }
1427
    } else {
1428
        /* just DC prediction */
1429
        if (a != 1024 && c != 1024)
1430
            pred_dc = (a + c) >> 1;
1431
        else if (a != 1024)
1432
            pred_dc = a;
1433
        else
1434
            pred_dc = c;
1435
    }
1436
    
1437
    /* we assume pred is positive */
1438
    block[0]=block[0]*scale + pred_dc;
1439
    
1440
    if (block[0] < 0)
1441
        block[0] = 0;
1442
    else 
1443
        block[0] |= 1;
1444
    
1445
    /* Update AC/DC tables */
1446
    dc_val[(x) + (y) * wrap] = block[0];
1447
    
1448
    /* left copy */
1449
    for(i=1;i<8;i++)
1450
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1451
    /* top copy */
1452
    for(i=1;i<8;i++)
1453
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1454
}
1455

    
1456
int16_t *h263_pred_motion(MpegEncContext * s, int block, 
1457
                        int *px, int *py)
1458
{
1459
    int xy, wrap;
1460
    int16_t *A, *B, *C, *mot_val;
1461
    static const int off[4]= {2, 1, 1, -1};
1462

    
1463
    wrap = s->block_wrap[0];
1464
    xy = s->block_index[block];
1465

    
1466
    mot_val = s->motion_val[xy];
1467

    
1468
    A = s->motion_val[xy - 1];
1469
    /* special case for first (slice) line */
1470
    if (s->first_slice_line && block<3) {
1471
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1472
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1473
        if(block==0){ //most common case
1474
            if(s->mb_x  == s->resync_mb_x){ //rare
1475
                *px= *py = 0;
1476
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1477
                C = s->motion_val[xy + off[block] - wrap];
1478
                if(s->mb_x==0){
1479
                    *px = C[0];
1480
                    *py = C[1];
1481
                }else{
1482
                    *px = mid_pred(A[0], 0, C[0]);
1483
                    *py = mid_pred(A[1], 0, C[1]);
1484
                }
1485
            }else{
1486
                *px = A[0];
1487
                *py = A[1];
1488
            }
1489
        }else if(block==1){
1490
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1491
                C = s->motion_val[xy + off[block] - wrap];
1492
                *px = mid_pred(A[0], 0, C[0]);
1493
                *py = mid_pred(A[1], 0, C[1]);
1494
            }else{
1495
                *px = A[0];
1496
                *py = A[1];
1497
            }
1498
        }else{ /* block==2*/
1499
            B = s->motion_val[xy - wrap];
1500
            C = s->motion_val[xy + off[block] - wrap];
1501
            if(s->mb_x == s->resync_mb_x) //rare
1502
                A[0]=A[1]=0;
1503
    
1504
            *px = mid_pred(A[0], B[0], C[0]);
1505
            *py = mid_pred(A[1], B[1], C[1]);
1506
        }
1507
    } else {
1508
        B = s->motion_val[xy - wrap];
1509
        C = s->motion_val[xy + off[block] - wrap];
1510
        *px = mid_pred(A[0], B[0], C[0]);
1511
        *py = mid_pred(A[1], B[1], C[1]);
1512
    }
1513
    return mot_val;
1514
}
1515

    
1516
#ifdef CONFIG_ENCODERS
1517
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1518
{
1519
    int range, l, bit_size, sign, code, bits;
1520

    
1521
    if (val == 0) {
1522
        /* zero vector */
1523
        code = 0;
1524
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1525
    } else {
1526
        bit_size = f_code - 1;
1527
        range = 1 << bit_size;
1528
        /* modulo encoding */
1529
        l = range * 32;
1530
#if 1
1531
        val+= l;
1532
        val&= 2*l-1;
1533
        val-= l;
1534
        sign = val>>31;
1535
        val= (val^sign)-sign;
1536
        sign&=1;
1537
#else
1538
        if (val < -l) {
1539
            val += 2*l;
1540
        } else if (val >= l) {
1541
            val -= 2*l;
1542
        }
1543

    
1544
        assert(val>=-l && val<l);
1545

    
1546
        if (val >= 0) {
1547
            sign = 0;
1548
        } else {
1549
            val = -val;
1550
            sign = 1;
1551
        }
1552
#endif
1553
        val--;
1554
        code = (val >> bit_size) + 1;
1555
        bits = val & (range - 1);
1556

    
1557
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1558
        if (bit_size > 0) {
1559
            put_bits(&s->pb, bit_size, bits);
1560
        }
1561
    }
1562

    
1563
}
1564

    
1565
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1566
static void h263p_encode_umotion(MpegEncContext * s, int val)
1567
{
1568
    short sval = 0; 
1569
    short i = 0;
1570
    short n_bits = 0;
1571
    short temp_val;
1572
    int code = 0;
1573
    int tcode;
1574
    
1575
    if ( val == 0)
1576
        put_bits(&s->pb, 1, 1);
1577
    else if (val == 1)
1578
        put_bits(&s->pb, 3, 0);
1579
    else if (val == -1)
1580
        put_bits(&s->pb, 3, 2);
1581
    else {
1582
        
1583
        sval = ((val < 0) ? (short)(-val):(short)val);
1584
        temp_val = sval;
1585
        
1586
        while (temp_val != 0) {
1587
            temp_val = temp_val >> 1;
1588
            n_bits++;
1589
        }
1590
        
1591
        i = n_bits - 1;
1592
        while (i > 0) {
1593
            tcode = (sval & (1 << (i-1))) >> (i-1);
1594
            tcode = (tcode << 1) | 1;
1595
            code = (code << 2) | tcode;
1596
            i--;
1597
        }
1598
        code = ((code << 1) | (val < 0)) << 1;
1599
        put_bits(&s->pb, (2*n_bits)+1, code);
1600
        //printf("\nVal = %d\tCode = %d", sval, code);
1601
    }
1602
}
1603

    
1604
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1605
{
1606
    int f_code;
1607
    int mv;
1608
    
1609
    if(mv_penalty==NULL)
1610
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1611
    
1612
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1613
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1614
            int len;
1615

    
1616
            if(mv==0) len= mvtab[0][1];
1617
            else{
1618
                int val, bit_size, range, code;
1619

    
1620
                bit_size = s->f_code - 1;
1621
                range = 1 << bit_size;
1622

    
1623
                val=mv;
1624
                if (val < 0) 
1625
                    val = -val;
1626
                val--;
1627
                code = (val >> bit_size) + 1;
1628
                if(code<33){
1629
                    len= mvtab[code][1] + 1 + bit_size;
1630
                }else{
1631
                    len= mvtab[32][1] + 2 + bit_size;
1632
                }
1633
            }
1634

    
1635
            mv_penalty[f_code][mv+MAX_MV]= len;
1636
        }
1637
    }
1638

    
1639
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1640
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1641
            fcode_tab[mv+MAX_MV]= f_code;
1642
        }
1643
    }
1644

    
1645
    for(mv=0; mv<MAX_MV*2+1; mv++){
1646
        umv_fcode_tab[mv]= 1;
1647
    }
1648
}
1649
#endif
1650

    
1651
#ifdef CONFIG_ENCODERS
1652

    
1653
static void init_uni_dc_tab(void)
1654
{
1655
    int level, uni_code, uni_len;
1656

    
1657
    for(level=-256; level<256; level++){
1658
        int size, v, l;
1659
        /* find number of bits */
1660
        size = 0;
1661
        v = abs(level);
1662
        while (v) {
1663
            v >>= 1;
1664
            size++;
1665
        }
1666

    
1667
        if (level < 0)
1668
            l= (-level) ^ ((1 << size) - 1);
1669
        else
1670
            l= level;
1671

    
1672
        /* luminance */
1673
        uni_code= DCtab_lum[size][0];
1674
        uni_len = DCtab_lum[size][1];
1675

    
1676
        if (size > 0) {
1677
            uni_code<<=size; uni_code|=l;
1678
            uni_len+=size;
1679
            if (size > 8){
1680
                uni_code<<=1; uni_code|=1;
1681
                uni_len++;
1682
            }
1683
        }
1684
        uni_DCtab_lum_bits[level+256]= uni_code;
1685
        uni_DCtab_lum_len [level+256]= uni_len;
1686

    
1687
        /* chrominance */
1688
        uni_code= DCtab_chrom[size][0];
1689
        uni_len = DCtab_chrom[size][1];
1690
        
1691
        if (size > 0) {
1692
            uni_code<<=size; uni_code|=l;
1693
            uni_len+=size;
1694
            if (size > 8){
1695
                uni_code<<=1; uni_code|=1;
1696
                uni_len++;
1697
            }
1698
        }
1699
        uni_DCtab_chrom_bits[level+256]= uni_code;
1700
        uni_DCtab_chrom_len [level+256]= uni_len;
1701

    
1702
    }
1703
}
1704

    
1705
#endif //CONFIG_ENCODERS
1706

    
1707
#ifdef CONFIG_ENCODERS
1708
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1709
    int slevel, run, last;
1710
    
1711
    assert(MAX_LEVEL >= 64);
1712
    assert(MAX_RUN   >= 63);
1713

    
1714
    for(slevel=-64; slevel<64; slevel++){
1715
        if(slevel==0) continue;
1716
        for(run=0; run<64; run++){
1717
            for(last=0; last<=1; last++){
1718
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1719
                int level= slevel < 0 ? -slevel : slevel;
1720
                int sign= slevel < 0 ? 1 : 0;
1721
                int bits, len, code;
1722
                int level1, run1;
1723
                
1724
                len_tab[index]= 100;
1725
                     
1726
                /* ESC0 */
1727
                code= get_rl_index(rl, last, run, level);
1728
                bits= rl->table_vlc[code][0];
1729
                len=  rl->table_vlc[code][1];
1730
                bits=bits*2+sign; len++;
1731
                
1732
                if(code!=rl->n && len < len_tab[index]){
1733
                    bits_tab[index]= bits;
1734
                    len_tab [index]= len;
1735
                }
1736
#if 1
1737
                /* ESC1 */
1738
                bits= rl->table_vlc[rl->n][0];
1739
                len=  rl->table_vlc[rl->n][1];
1740
                bits=bits*2;    len++; //esc1
1741
                level1= level - rl->max_level[last][run];
1742
                if(level1>0){
1743
                    code= get_rl_index(rl, last, run, level1);
1744
                    bits<<= rl->table_vlc[code][1];
1745
                    len  += rl->table_vlc[code][1];
1746
                    bits += rl->table_vlc[code][0];
1747
                    bits=bits*2+sign; len++;
1748
                
1749
                    if(code!=rl->n && len < len_tab[index]){
1750
                        bits_tab[index]= bits;
1751
                        len_tab [index]= len;
1752
                    }
1753
                }
1754
#endif 
1755
#if 1
1756
                /* ESC2 */
1757
                bits= rl->table_vlc[rl->n][0];
1758
                len=  rl->table_vlc[rl->n][1];
1759
                bits=bits*4+2;    len+=2; //esc2
1760
                run1 = run - rl->max_run[last][level] - 1;
1761
                if(run1>=0){
1762
                    code= get_rl_index(rl, last, run1, level);
1763
                    bits<<= rl->table_vlc[code][1];
1764
                    len  += rl->table_vlc[code][1];
1765
                    bits += rl->table_vlc[code][0];
1766
                    bits=bits*2+sign; len++;
1767
                
1768
                    if(code!=rl->n && len < len_tab[index]){
1769
                        bits_tab[index]= bits;
1770
                        len_tab [index]= len;
1771
                    }
1772
                }
1773
#endif           
1774
                /* ESC3 */        
1775
                bits= rl->table_vlc[rl->n][0];
1776
                len = rl->table_vlc[rl->n][1];
1777
                bits=bits*4+3;    len+=2; //esc3
1778
                bits=bits*2+last; len++;
1779
                bits=bits*64+run; len+=6;
1780
                bits=bits*2+1;    len++;  //marker
1781
                bits=bits*4096+(slevel&0xfff); len+=12;
1782
                bits=bits*2+1;    len++;  //marker
1783
                
1784
                if(len < len_tab[index]){
1785
                    bits_tab[index]= bits;
1786
                    len_tab [index]= len;
1787
                }
1788
            }
1789
        }
1790
    }
1791
}
1792

    
1793
void h263_encode_init(MpegEncContext *s)
1794
{
1795
    static int done = 0;
1796

    
1797
    if (!done) {
1798
        done = 1;
1799

    
1800
        init_uni_dc_tab();
1801

    
1802
        init_rl(&rl_inter);
1803
        init_rl(&rl_intra);
1804
        init_rl(&rl_intra_aic);
1805
        
1806
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1807
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1808

    
1809
        init_mv_penalty_and_fcode(s);
1810
    }
1811
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1812
    
1813
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1814
    switch(s->codec_id){
1815
    case CODEC_ID_MPEG4:
1816
        s->fcode_tab= fcode_tab;
1817
        s->min_qcoeff= -2048;
1818
        s->max_qcoeff=  2047;
1819
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1820
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1821
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1822
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1823
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
1824
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1825
        s->ac_esc_length= 7+2+1+6+1+12+1;
1826
        
1827
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1828

    
1829
            s->avctx->extradata= av_malloc(1024);
1830
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
1831
            
1832
            mpeg4_encode_visual_object_header(s);
1833
            mpeg4_encode_vol_header(s, 0, 0);
1834

    
1835
//            ff_mpeg4_stuffing(&s->pb); ?
1836
            flush_put_bits(&s->pb);
1837
            s->avctx->extradata_size= (get_bit_count(&s->pb)+7)>>3;
1838
        }
1839
        
1840
        break;
1841
    case CODEC_ID_H263P:
1842
        s->fcode_tab= umv_fcode_tab;
1843
        s->min_qcoeff= -127;
1844
        s->max_qcoeff=  127;
1845
        break;
1846
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1847
    case CODEC_ID_FLV1:
1848
        if (s->h263_flv > 1) {
1849
            s->min_qcoeff= -1023;
1850
            s->max_qcoeff=  1023;
1851
        } else {
1852
            s->min_qcoeff= -127;
1853
            s->max_qcoeff=  127;
1854
        }
1855
        s->y_dc_scale_table=
1856
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1857
        break;
1858
    default: //nothing needed default table allready set in mpegvideo.c
1859
        s->min_qcoeff= -127;
1860
        s->max_qcoeff=  127;
1861
        s->y_dc_scale_table=
1862
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1863
    }
1864
}
1865

    
1866
/**
1867
 * encodes a 8x8 block.
1868
 * @param block the 8x8 block
1869
 * @param n block index (0-3 are luma, 4-5 are chroma)
1870
 */
1871
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1872
{
1873
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1874
    RLTable *rl;
1875

    
1876
    rl = &rl_inter;
1877
    if (s->mb_intra && !s->h263_aic) {
1878
        /* DC coef */
1879
        level = block[0];
1880
        /* 255 cannot be represented, so we clamp */
1881
        if (level > 254) {
1882
            level = 254;
1883
            block[0] = 254;
1884
        }
1885
        /* 0 cannot be represented also */
1886
        else if (level < 1) {
1887
            level = 1;
1888
            block[0] = 1;
1889
        }
1890
        if (level == 128) //FIXME check rv10
1891
            put_bits(&s->pb, 8, 0xff);
1892
        else
1893
            put_bits(&s->pb, 8, level & 0xff);
1894
        i = 1;
1895
    } else {
1896
        i = 0;
1897
        if (s->h263_aic && s->mb_intra)
1898
            rl = &rl_intra_aic;
1899
            
1900
        if(s->alt_inter_vlc && !s->mb_intra){
1901
            int aic_vlc_bits=0;
1902
            int inter_vlc_bits=0;
1903
            int wrong_pos=-1;
1904
            int aic_code;
1905
            
1906
            last_index = s->block_last_index[n];
1907
            last_non_zero = i - 1;
1908
            for (; i <= last_index; i++) {
1909
                j = s->intra_scantable.permutated[i];
1910
                level = block[j];
1911
                if (level) {
1912
                    run = i - last_non_zero - 1;
1913
                    last = (i == last_index);
1914
                
1915
                    code = get_rl_index(rl, last, run, level);
1916
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
1917
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
1918
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
1919

    
1920
                    if (code == rl->n) {
1921
                        inter_vlc_bits += 1+6+8;
1922
                    }                
1923
                    if (aic_code == rl_intra_aic.n) {
1924
                        aic_vlc_bits += 1+6+8;
1925
                        wrong_pos += run + 1;
1926
                    }else
1927
                        wrong_pos += wrong_run[aic_code];
1928
                    last_non_zero = i;
1929
                }    
1930
            }
1931
            i = 0;
1932
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
1933
                rl = &rl_intra_aic;
1934
        }
1935
    }
1936
   
1937
    /* AC coefs */
1938
    last_index = s->block_last_index[n];
1939
    last_non_zero = i - 1;
1940
    for (; i <= last_index; i++) {
1941
        j = s->intra_scantable.permutated[i];
1942
        level = block[j];
1943
        if (level) {
1944
            run = i - last_non_zero - 1;
1945
            last = (i == last_index);
1946
            sign = 0;
1947
            slevel = level;
1948
            if (level < 0) {
1949
                sign = 1;
1950
                level = -level;
1951
            }
1952
            code = get_rl_index(rl, last, run, level);
1953
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1954
            if (code == rl->n) {
1955
              if(s->h263_flv <= 1){
1956
                put_bits(&s->pb, 1, last);
1957
                put_bits(&s->pb, 6, run);
1958
                
1959
                assert(slevel != 0);
1960

    
1961
                if(slevel < 128 && slevel > -128) 
1962
                    put_bits(&s->pb, 8, slevel & 0xff);
1963
                else{
1964
                    put_bits(&s->pb, 8, 128);
1965
                    put_bits(&s->pb, 5, slevel & 0x1f);
1966
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
1967
                }
1968
              }else{
1969
                    if(slevel < 64 && slevel > -64) {
1970
                        /* 7-bit level */
1971
                        put_bits(&s->pb, 1, 0);
1972
                        put_bits(&s->pb, 1, last);
1973
                        put_bits(&s->pb, 6, run);
1974

    
1975
                        put_bits(&s->pb, 7, slevel & 0x7f);
1976
                    } else {
1977
                        /* 11-bit level */
1978
                        put_bits(&s->pb, 1, 1);
1979
                        put_bits(&s->pb, 1, last);
1980
                        put_bits(&s->pb, 6, run);
1981

    
1982
                        put_bits(&s->pb, 11, slevel & 0x7ff);
1983
                    }
1984
              }
1985
            } else {
1986
                put_bits(&s->pb, 1, sign);
1987
            }
1988
            last_non_zero = i;
1989
        }
1990
    }
1991
}
1992
#endif
1993

    
1994
#ifdef CONFIG_ENCODERS
1995

    
1996
/***************************************************/
1997
/**
1998
 * add mpeg4 stuffing bits (01...1)
1999
 */
2000
void ff_mpeg4_stuffing(PutBitContext * pbc)
2001
{
2002
    int length;
2003
    put_bits(pbc, 1, 0);
2004
    length= (-get_bit_count(pbc))&7;
2005
    if(length) put_bits(pbc, length, (1<<length)-1);
2006
}
2007

    
2008
/* must be called before writing the header */
2009
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2010
    int time_div, time_mod;
2011

    
2012
    if(s->current_picture_ptr->pts)
2013
        s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
2014
    else
2015
        s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
2016
    time_div= s->time/s->time_increment_resolution;
2017
    time_mod= s->time%s->time_increment_resolution;
2018

    
2019
    if(s->pict_type==B_TYPE){
2020
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2021
    }else{
2022
        s->last_time_base= s->time_base;
2023
        s->time_base= time_div;
2024
        s->pp_time= s->time - s->last_non_b_time;
2025
        s->last_non_b_time= s->time;
2026
    }
2027
}
2028

    
2029
static void mpeg4_encode_gop_header(MpegEncContext * s){
2030
    int hours, minutes, seconds;
2031
    
2032
    put_bits(&s->pb, 16, 0);
2033
    put_bits(&s->pb, 16, GOP_STARTCODE);
2034
    
2035
    seconds= s->time/s->time_increment_resolution;
2036
    minutes= seconds/60; seconds %= 60;
2037
    hours= minutes/60; minutes %= 60;
2038
    hours%=24;
2039

    
2040
    put_bits(&s->pb, 5, hours);
2041
    put_bits(&s->pb, 6, minutes);
2042
    put_bits(&s->pb, 1, 1);
2043
    put_bits(&s->pb, 6, seconds);
2044
    
2045
    put_bits(&s->pb, 1, 0); //closed gov == NO
2046
    put_bits(&s->pb, 1, 0); //broken link == NO
2047

    
2048
    ff_mpeg4_stuffing(&s->pb);
2049
}
2050

    
2051
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2052
    int profile_and_level_indication;
2053
    int vo_ver_id;
2054
    
2055
    if(s->max_b_frames || s->quarter_sample){
2056
        profile_and_level_indication= 0xF1; // adv simple level 1
2057
        vo_ver_id= 5;
2058
    }else{
2059
        profile_and_level_indication= 0x01; // simple level 1
2060
        vo_ver_id= 1;
2061
    }
2062
    //FIXME levels
2063

    
2064
    put_bits(&s->pb, 16, 0);
2065
    put_bits(&s->pb, 16, VOS_STARTCODE);
2066

    
2067
    put_bits(&s->pb, 8, profile_and_level_indication);
2068

    
2069
    put_bits(&s->pb, 16, 0);
2070
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2071
    
2072
    put_bits(&s->pb, 1, 1);
2073
        put_bits(&s->pb, 4, vo_ver_id);
2074
        put_bits(&s->pb, 3, 1); //priority
2075
 
2076
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
2077
    
2078
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2079

    
2080
    ff_mpeg4_stuffing(&s->pb);
2081
}
2082

    
2083
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2084
{
2085
    int vo_ver_id;
2086

    
2087
    if(s->max_b_frames || s->quarter_sample){
2088
        vo_ver_id= 5;
2089
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2090
    }else{
2091
        vo_ver_id= 1;
2092
        s->vo_type= SIMPLE_VO_TYPE;
2093
    }
2094

    
2095
    put_bits(&s->pb, 16, 0);
2096
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2097
    put_bits(&s->pb, 16, 0);
2098
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2099

    
2100
    put_bits(&s->pb, 1, 0);                /* random access vol */
2101
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
2102
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
2103
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
2104
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
2105
    
2106
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2107

    
2108
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2109
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2110
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2111
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2112
    }
2113

    
2114
    if(s->low_delay){
2115
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
2116
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
2117
        put_bits(&s->pb, 1, s->low_delay);
2118
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
2119
    }else{
2120
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
2121
    }
2122

    
2123
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
2124
    put_bits(&s->pb, 1, 1);                /* marker bit */
2125
    
2126
    put_bits(&s->pb, 16, s->time_increment_resolution);
2127
    if (s->time_increment_bits < 1)
2128
        s->time_increment_bits = 1;
2129
    put_bits(&s->pb, 1, 1);                /* marker bit */
2130
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
2131
    put_bits(&s->pb, 1, 1);                /* marker bit */
2132
    put_bits(&s->pb, 13, s->width);        /* vol width */
2133
    put_bits(&s->pb, 1, 1);                /* marker bit */
2134
    put_bits(&s->pb, 13, s->height);        /* vol height */
2135
    put_bits(&s->pb, 1, 1);                /* marker bit */
2136
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2137
    put_bits(&s->pb, 1, 1);                /* obmc disable */
2138
    if (vo_ver_id == 1) {
2139
        put_bits(&s->pb, 1, s->vol_sprite_usage=0);                /* sprite enable */
2140
    }else{
2141
        put_bits(&s->pb, 2, s->vol_sprite_usage=0);                /* sprite enable */
2142
    }
2143
    
2144
    s->quant_precision=5;
2145
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
2146
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
2147

    
2148
    if(s->mpeg_quant){
2149
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2150
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2151
    }
2152

    
2153
    if (vo_ver_id != 1)
2154
        put_bits(&s->pb, 1, s->quarter_sample);
2155
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
2156
    s->resync_marker= s->rtp_mode;
2157
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2158
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2159
    if(s->data_partitioning){
2160
        put_bits(&s->pb, 1, 0);                /* no rvlc */
2161
    }
2162

    
2163
    if (vo_ver_id != 1){
2164
        put_bits(&s->pb, 1, 0);                /* newpred */
2165
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
2166
    }
2167
    put_bits(&s->pb, 1, 0);                /* scalability */
2168
    
2169
    ff_mpeg4_stuffing(&s->pb);
2170

    
2171
    /* user data */
2172
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2173
        put_bits(&s->pb, 16, 0);
2174
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
2175
        put_string(&s->pb, LIBAVCODEC_IDENT);
2176
        ff_mpeg4_stuffing(&s->pb);
2177
    }
2178
}
2179

    
2180
/* write mpeg4 VOP header */
2181
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2182
{
2183
    int time_incr;
2184
    int time_div, time_mod;
2185
    
2186
    if(s->pict_type==I_TYPE){
2187
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2188
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2189
                mpeg4_encode_visual_object_header(s);
2190
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2191
                mpeg4_encode_vol_header(s, 0, 0);
2192
        }
2193
        mpeg4_encode_gop_header(s);
2194
    }
2195
    
2196
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2197

    
2198
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2199
    
2200
    put_bits(&s->pb, 16, 0);                /* vop header */
2201
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2202
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
2203

    
2204
    time_div= s->time/s->time_increment_resolution;
2205
    time_mod= s->time%s->time_increment_resolution;
2206
    time_incr= time_div - s->last_time_base;
2207
    while(time_incr--)
2208
        put_bits(&s->pb, 1, 1);
2209
        
2210
    put_bits(&s->pb, 1, 0);
2211

    
2212
    put_bits(&s->pb, 1, 1);        /* marker */
2213
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
2214
    put_bits(&s->pb, 1, 1);        /* marker */
2215
    put_bits(&s->pb, 1, 1);        /* vop coded */
2216
    if (    s->pict_type == P_TYPE 
2217
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2218
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
2219
    }
2220
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
2221
    if(!s->progressive_sequence){
2222
         put_bits(&s->pb, 1, s->top_field_first);
2223
         put_bits(&s->pb, 1, s->alternate_scan);
2224
    }
2225
    //FIXME sprite stuff
2226

    
2227
    put_bits(&s->pb, 5, s->qscale);
2228

    
2229
    if (s->pict_type != I_TYPE)
2230
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
2231
    if (s->pict_type == B_TYPE)
2232
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
2233
    //    printf("****frame %d\n", picture_number);
2234

    
2235
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
2236
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2237
}
2238

    
2239
#endif //CONFIG_ENCODERS
2240

    
2241
/**
2242
 * change qscale by given dquant and update qscale dependant variables.
2243
 */
2244
static void change_qscale(MpegEncContext * s, int dquant)
2245
{
2246
    s->qscale += dquant;
2247

    
2248
    if (s->qscale < 1)
2249
        s->qscale = 1;
2250
    else if (s->qscale > 31)
2251
        s->qscale = 31;
2252
        
2253
    s->chroma_qscale= s->chroma_qscale_table[s->qscale];
2254

    
2255
    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2256
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2257
}
2258

    
2259
/**
2260
 * predicts the dc.
2261
 * @param n block index (0-3 are luma, 4-5 are chroma)
2262
 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
2263
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2264
 * @return the quantized predicted dc
2265
 */
2266
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
2267
{
2268
    int a, b, c, wrap, pred, scale;
2269
    uint16_t *dc_val;
2270

    
2271
    /* find prediction */
2272
    if (n < 4) {
2273
        scale = s->y_dc_scale;
2274
    } else {
2275
        scale = s->c_dc_scale;
2276
    }
2277
    if(IS_3IV1)
2278
        scale= 8;
2279

    
2280
    wrap= s->block_wrap[n];
2281
    dc_val = s->dc_val[0] + s->block_index[n];
2282

    
2283
    /* B C
2284
     * A X 
2285
     */
2286
    a = dc_val[ - 1];
2287
    b = dc_val[ - 1 - wrap];
2288
    c = dc_val[ - wrap];
2289

    
2290
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2291
    if(s->first_slice_line && n!=3){
2292
        if(n!=2) b=c= 1024;
2293
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2294
    }
2295
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2296
        if(n==0 || n==4 || n==5)
2297
            b=1024;
2298
    }
2299

    
2300
    if (abs(a - b) < abs(b - c)) {
2301
        pred = c;
2302
        *dir_ptr = 1; /* top */
2303
    } else {
2304
        pred = a;
2305
        *dir_ptr = 0; /* left */
2306
    }
2307
    /* we assume pred is positive */
2308
    pred = FASTDIV((pred + (scale >> 1)), scale);
2309

    
2310
    /* prepare address for prediction update */
2311
    *dc_val_ptr = &dc_val[0];
2312

    
2313
    return pred;
2314
}
2315

    
2316
/**
2317
 * predicts the ac.
2318
 * @param n block index (0-3 are luma, 4-5 are chroma)
2319
 * @param dir the ac prediction direction
2320
 */
2321
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2322
                   int dir)
2323
{
2324
    int i;
2325
    int16_t *ac_val, *ac_val1;
2326
    int8_t * const qscale_table= s->current_picture.qscale_table;
2327

    
2328
    /* find prediction */
2329
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2330
    ac_val1 = ac_val;
2331
    if (s->ac_pred) {
2332
        if (dir == 0) {
2333
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2334
            /* left prediction */
2335
            ac_val -= 16;
2336
            
2337
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2338
                /* same qscale */
2339
                for(i=1;i<8;i++) {
2340
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2341
                }
2342
            }else{
2343
                /* different qscale, we must rescale */
2344
                for(i=1;i<8;i++) {
2345
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2346
                }
2347
            }
2348
        } else {
2349
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2350
            /* top prediction */
2351
            ac_val -= 16 * s->block_wrap[n];
2352

    
2353
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2354
                /* same qscale */
2355
                for(i=1;i<8;i++) {
2356
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2357
                }
2358
            }else{
2359
                /* different qscale, we must rescale */
2360
                for(i=1;i<8;i++) {
2361
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2362
                }
2363
            }
2364
        }
2365
    }
2366
    /* left copy */
2367
    for(i=1;i<8;i++)
2368
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2369

    
2370
    /* top copy */
2371
    for(i=1;i<8;i++)
2372
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2373

    
2374
}
2375

    
2376
#ifdef CONFIG_ENCODERS
2377

    
2378
/**
2379
 * encodes the dc value.
2380
 * @param n block index (0-3 are luma, 4-5 are chroma)
2381
 */
2382
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2383
{
2384
#if 1
2385
//    if(level<-255 || level>255) printf("dc overflow\n");
2386
    level+=256;
2387
    if (n < 4) {
2388
        /* luminance */
2389
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2390
    } else {
2391
        /* chrominance */
2392
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2393
    }
2394
#else
2395
    int size, v;
2396
    /* find number of bits */
2397
    size = 0;
2398
    v = abs(level);
2399
    while (v) {
2400
        v >>= 1;
2401
        size++;
2402
    }
2403

    
2404
    if (n < 4) {
2405
        /* luminance */
2406
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2407
    } else {
2408
        /* chrominance */
2409
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2410
    }
2411

    
2412
    /* encode remaining bits */
2413
    if (size > 0) {
2414
        if (level < 0)
2415
            level = (-level) ^ ((1 << size) - 1);
2416
        put_bits(&s->pb, size, level);
2417
        if (size > 8)
2418
            put_bits(&s->pb, 1, 1);
2419
    }
2420
#endif
2421
}
2422

    
2423
/**
2424
 * encodes a 8x8 block
2425
 * @param n block index (0-3 are luma, 4-5 are chroma)
2426
 */
2427
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2428
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2429
{
2430
    int i, last_non_zero;
2431
#if 0 //variables for the outcommented version
2432
    int code, sign, last;
2433
#endif
2434
    const RLTable *rl;
2435
    uint32_t *bits_tab;
2436
    uint8_t *len_tab;
2437
    const int last_index = s->block_last_index[n];
2438

    
2439
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2440
        /* mpeg4 based DC predictor */
2441
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2442
        if(last_index<1) return;
2443
        i = 1;
2444
        rl = &rl_intra;
2445
        bits_tab= uni_mpeg4_intra_rl_bits;
2446
        len_tab = uni_mpeg4_intra_rl_len;
2447
    } else {
2448
        if(last_index<0) return;
2449
        i = 0;
2450
        rl = &rl_inter;
2451
        bits_tab= uni_mpeg4_inter_rl_bits;
2452
        len_tab = uni_mpeg4_inter_rl_len;
2453
    }
2454

    
2455
    /* AC coefs */
2456
    last_non_zero = i - 1;
2457
#if 1
2458
    for (; i < last_index; i++) {
2459
        int level = block[ scan_table[i] ];
2460
        if (level) {
2461
            int run = i - last_non_zero - 1;
2462
            level+=64;
2463
            if((level&(~127)) == 0){
2464
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2465
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2466
            }else{ //ESC3
2467
                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);
2468
            }
2469
            last_non_zero = i;
2470
        }
2471
    }
2472
    /*if(i<=last_index)*/{
2473
        int level = block[ scan_table[i] ];
2474
        int run = i - last_non_zero - 1;
2475
        level+=64;
2476
        if((level&(~127)) == 0){
2477
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2478
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2479
        }else{ //ESC3
2480
            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);
2481
        }
2482
    }
2483
#else
2484
    for (; i <= last_index; i++) {
2485
        const int slevel = block[ scan_table[i] ];
2486
        if (slevel) {
2487
            int level;
2488
            int run = i - last_non_zero - 1;
2489
            last = (i == last_index);
2490
            sign = 0;
2491
            level = slevel;
2492
            if (level < 0) {
2493
                sign = 1;
2494
                level = -level;
2495
            }
2496
            code = get_rl_index(rl, last, run, level);
2497
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2498
            if (code == rl->n) {
2499
                int level1, run1;
2500
                level1 = level - rl->max_level[last][run];
2501
                if (level1 < 1) 
2502
                    goto esc2;
2503
                code = get_rl_index(rl, last, run, level1);
2504
                if (code == rl->n) {
2505
                esc2:
2506
                    put_bits(ac_pb, 1, 1);
2507
                    if (level > MAX_LEVEL)
2508
                        goto esc3;
2509
                    run1 = run - rl->max_run[last][level] - 1;
2510
                    if (run1 < 0)
2511
                        goto esc3;
2512
                    code = get_rl_index(rl, last, run1, level);
2513
                    if (code == rl->n) {
2514
                    esc3:
2515
                        /* third escape */
2516
                        put_bits(ac_pb, 1, 1);
2517
                        put_bits(ac_pb, 1, last);
2518
                        put_bits(ac_pb, 6, run);
2519
                        put_bits(ac_pb, 1, 1);
2520
                        put_bits(ac_pb, 12, slevel & 0xfff);
2521
                        put_bits(ac_pb, 1, 1);
2522
                    } else {
2523
                        /* second escape */
2524
                        put_bits(ac_pb, 1, 0);
2525
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2526
                        put_bits(ac_pb, 1, sign);
2527
                    }
2528
                } else {
2529
                    /* first escape */
2530
                    put_bits(ac_pb, 1, 0);
2531
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2532
                    put_bits(ac_pb, 1, sign);
2533
                }
2534
            } else {
2535
                put_bits(ac_pb, 1, sign);
2536
            }
2537
            last_non_zero = i;
2538
        }
2539
    }
2540
#endif
2541
}
2542

    
2543
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2544
                               uint8_t *scan_table)
2545
{
2546
    int i, last_non_zero;
2547
    const RLTable *rl;
2548
    uint8_t *len_tab;
2549
    const int last_index = s->block_last_index[n];
2550
    int len=0;
2551

    
2552
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2553
        /* mpeg4 based DC predictor */
2554
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2555
        if(last_index<1) return len;
2556
        i = 1;
2557
        rl = &rl_intra;
2558
        len_tab = uni_mpeg4_intra_rl_len;
2559
    } else {
2560
        if(last_index<0) return 0;
2561
        i = 0;
2562
        rl = &rl_inter;
2563
        len_tab = uni_mpeg4_inter_rl_len;
2564
    }
2565

    
2566
    /* AC coefs */
2567
    last_non_zero = i - 1;
2568
    for (; i < last_index; i++) {
2569
        int level = block[ scan_table[i] ];
2570
        if (level) {
2571
            int run = i - last_non_zero - 1;
2572
            level+=64;
2573
            if((level&(~127)) == 0){
2574
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2575
                len += len_tab[index];
2576
            }else{ //ESC3
2577
                len += 7+2+1+6+1+12+1;
2578
            }
2579
            last_non_zero = i;
2580
        }
2581
    }
2582
    /*if(i<=last_index)*/{
2583
        int level = block[ scan_table[i] ];
2584
        int run = i - last_non_zero - 1;
2585
        level+=64;
2586
        if((level&(~127)) == 0){
2587
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2588
            len += len_tab[index];
2589
        }else{ //ESC3
2590
            len += 7+2+1+6+1+12+1;
2591
        }
2592
    }
2593
    
2594
    return len;
2595
}
2596

    
2597
#endif
2598

    
2599

    
2600
/***********************************************/
2601
/* decoding */
2602

    
2603
static VLC intra_MCBPC_vlc;
2604
static VLC inter_MCBPC_vlc;
2605
static VLC cbpy_vlc;
2606
static VLC mv_vlc;
2607
static VLC dc_lum, dc_chrom;
2608
static VLC sprite_trajectory;
2609
static VLC mb_type_b_vlc;
2610

    
2611
void init_vlc_rl(RLTable *rl)
2612
{
2613
    int i, q;
2614
    
2615
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2616
             &rl->table_vlc[0][1], 4, 2,
2617
             &rl->table_vlc[0][0], 4, 2);
2618

    
2619
    
2620
    for(q=0; q<32; q++){
2621
        int qmul= q*2;
2622
        int qadd= (q-1)|1;
2623
        
2624
        if(q==0){
2625
            qmul=1;
2626
            qadd=0;
2627
        }
2628
        
2629
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2630
        for(i=0; i<rl->vlc.table_size; i++){
2631
            int code= rl->vlc.table[i][0];
2632
            int len = rl->vlc.table[i][1];
2633
            int level, run;
2634
        
2635
            if(len==0){ // illegal code
2636
                run= 66;
2637
                level= MAX_LEVEL;
2638
            }else if(len<0){ //more bits needed
2639
                run= 0;
2640
                level= code;
2641
            }else{
2642
                if(code==rl->n){ //esc
2643
                    run= 66;
2644
                    level= 0;
2645
                }else{
2646
                    run=   rl->table_run  [code] + 1;
2647
                    level= rl->table_level[code] * qmul + qadd;
2648
                    if(code >= rl->last) run+=192;
2649
                }
2650
            }
2651
            rl->rl_vlc[q][i].len= len;
2652
            rl->rl_vlc[q][i].level= level;
2653
            rl->rl_vlc[q][i].run= run;
2654
        }
2655
    }
2656
}
2657

    
2658
/* init vlcs */
2659

    
2660
/* XXX: find a better solution to handle static init */
2661
void h263_decode_init_vlc(MpegEncContext *s)
2662
{
2663
    static int done = 0;
2664

    
2665
    if (!done) {
2666
        done = 1;
2667

    
2668
        init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, 
2669
                 intra_MCBPC_bits, 1, 1,
2670
                 intra_MCBPC_code, 1, 1);
2671
        init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, 
2672
                 inter_MCBPC_bits, 1, 1,
2673
                 inter_MCBPC_code, 1, 1);
2674
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2675
                 &cbpy_tab[0][1], 2, 1,
2676
                 &cbpy_tab[0][0], 2, 1);
2677
        init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2678
                 &mvtab[0][1], 2, 1,
2679
                 &mvtab[0][0], 2, 1);
2680
        init_rl(&rl_inter);
2681
        init_rl(&rl_intra);
2682
        init_rl(&rvlc_rl_inter);
2683
        init_rl(&rvlc_rl_intra);
2684
        init_rl(&rl_intra_aic);
2685
        init_vlc_rl(&rl_inter);
2686
        init_vlc_rl(&rl_intra);
2687
        init_vlc_rl(&rvlc_rl_inter);
2688
        init_vlc_rl(&rvlc_rl_intra);
2689
        init_vlc_rl(&rl_intra_aic);
2690
        init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2691
                 &DCtab_lum[0][1], 2, 1,
2692
                 &DCtab_lum[0][0], 2, 1);
2693
        init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2694
                 &DCtab_chrom[0][1], 2, 1,
2695
                 &DCtab_chrom[0][0], 2, 1);
2696
        init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2697
                 &sprite_trajectory_tab[0][1], 4, 2,
2698
                 &sprite_trajectory_tab[0][0], 4, 2);
2699
        init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2700
                 &mb_type_b_tab[0][1], 2, 1,
2701
                 &mb_type_b_tab[0][0], 2, 1);
2702
    }
2703
}
2704

    
2705
/**
2706
 * Get the GOB height based on picture height.
2707
 */
2708
int ff_h263_get_gob_height(MpegEncContext *s){
2709
    if (s->height <= 400)
2710
        return 1;
2711
    else if (s->height <= 800)
2712
        return  2;
2713
    else
2714
        return 4;
2715
}
2716

    
2717
/**
2718
 * decodes the group of blocks header.
2719
 * @return <0 if an error occured
2720
 */
2721
static int h263_decode_gob_header(MpegEncContext *s)
2722
{
2723
    unsigned int val, gfid;
2724
    int left;
2725
    
2726
    /* Check for GOB Start Code */
2727
    val = show_bits(&s->gb, 16);
2728
    if(val)
2729
        return -1;
2730

    
2731
        /* We have a GBSC probably with GSTUFF */
2732
    skip_bits(&s->gb, 16); /* Drop the zeros */
2733
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
2734
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2735
    for(;left>13; left--){
2736
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2737
    }
2738
    if(left<=13) 
2739
        return -1;
2740

    
2741
#ifdef DEBUG
2742
    fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2743
#endif
2744
    s->gob_number = get_bits(&s->gb, 5); /* GN */
2745
    gfid = get_bits(&s->gb, 2); /* GFID */
2746
    s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2747
    if(s->qscale==0) 
2748
        return -1;
2749
    s->chroma_qscale= s->chroma_qscale_table[s->qscale];
2750

    
2751
    s->mb_x= 0;
2752
    s->mb_y= s->gob_index* s->gob_number;
2753
    if(s->mb_y >= s->mb_height) 
2754
        return -1;
2755
#ifdef DEBUG
2756
    fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2757
#endif
2758
    return 0;
2759
}
2760

    
2761
static inline void memsetw(short *tab, int val, int n)
2762
{
2763
    int i;
2764
    for(i=0;i<n;i++)
2765
        tab[i] = val;
2766
}
2767

    
2768
#ifdef CONFIG_ENCODERS
2769

    
2770
void ff_mpeg4_init_partitions(MpegEncContext *s)
2771
{
2772
    init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE);
2773
    init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE);
2774
}
2775

    
2776
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2777
{
2778
    const int pb2_len   = get_bit_count(&s->pb2   );
2779
    const int tex_pb_len= get_bit_count(&s->tex_pb);
2780
    const int bits= get_bit_count(&s->pb);
2781

    
2782
    if(s->pict_type==I_TYPE){
2783
        put_bits(&s->pb, 19, DC_MARKER);
2784
        s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2785
        s->i_tex_bits+= tex_pb_len;
2786
    }else{
2787
        put_bits(&s->pb, 17, MOTION_MARKER);
2788
        s->misc_bits+=17 + pb2_len;
2789
        s->mv_bits+= bits - s->last_bits;
2790
        s->p_tex_bits+= tex_pb_len;
2791
    }
2792

    
2793
    flush_put_bits(&s->pb2);
2794
    flush_put_bits(&s->tex_pb);
2795

    
2796
    ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2797
    ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2798
    s->last_bits= get_bit_count(&s->pb);
2799
}
2800

    
2801
#endif //CONFIG_ENCODERS
2802

    
2803
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2804
    switch(s->pict_type){
2805
        case I_TYPE:
2806
            return 16;
2807
        case P_TYPE:
2808
        case S_TYPE:
2809
            return s->f_code+15;
2810
        case B_TYPE:
2811
            return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2812
        default:
2813
            return -1;
2814
    }
2815
}
2816

    
2817
#ifdef CONFIG_ENCODERS
2818

    
2819
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2820
{
2821
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2822

    
2823
    ff_mpeg4_stuffing(&s->pb);
2824
    put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2825
    put_bits(&s->pb, 1, 1);
2826
    
2827
    put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2828
    put_bits(&s->pb, s->quant_precision, s->qscale);
2829
    put_bits(&s->pb, 1, 0); /* no HEC */
2830
}
2831

    
2832
#endif //CONFIG_ENCODERS
2833

    
2834
/**
2835
 * check if the next stuff is a resync marker or the end.
2836
 * @return 0 if not
2837
 */
2838
static inline int mpeg4_is_resync(MpegEncContext *s){
2839
    const int bits_count= get_bits_count(&s->gb);
2840
    
2841
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
2842
        return 0;
2843
    }
2844

    
2845
    if(bits_count + 8 >= s->gb.size_in_bits){
2846
        int v= show_bits(&s->gb, 8);
2847
        v|= 0x7F >> (7-(bits_count&7));
2848
                
2849
        if(v==0x7F)
2850
            return 1;
2851
    }else{
2852
        if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2853
            int len;
2854
            GetBitContext gb= s->gb;
2855
        
2856
            skip_bits(&s->gb, 1);
2857
            align_get_bits(&s->gb);
2858
        
2859
            for(len=0; len<32; len++){
2860
                if(get_bits1(&s->gb)) break;
2861
            }
2862

    
2863
            s->gb= gb;
2864

    
2865
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2866
                return 1;
2867
        }
2868
    }
2869
    return 0;
2870
}
2871

    
2872
/**
2873
 * decodes the next video packet.
2874
 * @return <0 if something went wrong
2875
 */
2876
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2877
{
2878
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2879
    int header_extension=0, mb_num, len;
2880
    
2881
    /* is there enough space left for a video packet + header */
2882
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2883

    
2884
    for(len=0; len<32; len++){
2885
        if(get_bits1(&s->gb)) break;
2886
    }
2887

    
2888
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2889
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
2890
        return -1;
2891
    }
2892
    
2893
    if(s->shape != RECT_SHAPE){
2894
        header_extension= get_bits1(&s->gb);
2895
        //FIXME more stuff here
2896
    }
2897

    
2898
    mb_num= get_bits(&s->gb, mb_num_bits);
2899
    if(mb_num>=s->mb_num){
2900
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2901
        return -1;
2902
    }
2903
    if(s->pict_type == B_TYPE){
2904
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
2905
        if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
2906
    }
2907
    
2908
    s->mb_x= mb_num % s->mb_width;
2909
    s->mb_y= mb_num / s->mb_width;
2910

    
2911
    if(s->shape != BIN_ONLY_SHAPE){
2912
        int qscale= get_bits(&s->gb, s->quant_precision); 
2913
        if(qscale)
2914
            s->chroma_qscale=s->qscale= qscale;
2915
    }
2916

    
2917
    if(s->shape == RECT_SHAPE){
2918
        header_extension= get_bits1(&s->gb);
2919
    }
2920
    if(header_extension){
2921
        int time_increment;
2922
        int time_incr=0;
2923

    
2924
        while (get_bits1(&s->gb) != 0) 
2925
            time_incr++;
2926

    
2927
        check_marker(&s->gb, "before time_increment in video packed header");
2928
        time_increment= get_bits(&s->gb, s->time_increment_bits);
2929
        check_marker(&s->gb, "before vop_coding_type in video packed header");
2930
        
2931
        skip_bits(&s->gb, 2); /* vop coding type */
2932
        //FIXME not rect stuff here
2933

    
2934
        if(s->shape != BIN_ONLY_SHAPE){
2935
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2936
//FIXME dont just ignore everything
2937
            if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2938
                mpeg4_decode_sprite_trajectory(s);
2939
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
2940
            }
2941

    
2942
            //FIXME reduced res stuff here
2943
            
2944
            if (s->pict_type != I_TYPE) {
2945
                int f_code = get_bits(&s->gb, 3);        /* fcode_for */
2946
                if(f_code==0){
2947
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
2948
                }
2949
            }
2950
            if (s->pict_type == B_TYPE) {
2951
                int b_code = get_bits(&s->gb, 3);
2952
                if(b_code==0){
2953
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
2954
                }
2955
            }       
2956
        }
2957
    }
2958
    //FIXME new-pred stuff
2959
    
2960
//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));
2961

    
2962
    return 0;
2963
}
2964

    
2965
void ff_mpeg4_clean_buffers(MpegEncContext *s)
2966
{
2967
    int c_wrap, c_xy, l_wrap, l_xy;
2968

    
2969
    l_wrap= s->block_wrap[0];
2970
    l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2971
    c_wrap= s->block_wrap[4];
2972
    c_xy= s->mb_y*c_wrap + s->mb_x;
2973

    
2974
#if 0
2975
    /* clean DC */
2976
    memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2977
    memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2978
    memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2979
#endif
2980

    
2981
    /* clean AC */
2982
    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
2983
    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2984
    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2985

    
2986
    /* clean MV */
2987
    // we cant clear the MVs as they might be needed by a b frame
2988
//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2989
//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2990
    s->last_mv[0][0][0]=
2991
    s->last_mv[0][0][1]=
2992
    s->last_mv[1][0][0]=
2993
    s->last_mv[1][0][1]= 0;
2994
}
2995

    
2996
/**
2997
 * decodes the group of blocks / video packet header.
2998
 * @return <0 if no resync found
2999
 */
3000
int ff_h263_resync(MpegEncContext *s){
3001
    int left, ret;
3002
    
3003
    if(s->codec_id==CODEC_ID_MPEG4){
3004
        skip_bits1(&s->gb);
3005
        align_get_bits(&s->gb);
3006
    }
3007

    
3008
    if(show_bits(&s->gb, 16)==0){
3009
        if(s->codec_id==CODEC_ID_MPEG4)
3010
            ret= mpeg4_decode_video_packet_header(s);
3011
        else
3012
            ret= h263_decode_gob_header(s);
3013
        if(ret>=0)
3014
            return 0;
3015
    }
3016
    //ok, its not where its supposed to be ...
3017
    s->gb= s->last_resync_gb;
3018
    align_get_bits(&s->gb);
3019
    left= s->gb.size_in_bits - get_bits_count(&s->gb);
3020
    
3021
    for(;left>16+1+5+5; left-=8){ 
3022
        if(show_bits(&s->gb, 16)==0){
3023
            GetBitContext bak= s->gb;
3024

    
3025
            if(s->codec_id==CODEC_ID_MPEG4)
3026
                ret= mpeg4_decode_video_packet_header(s);
3027
            else
3028
                ret= h263_decode_gob_header(s);
3029
            if(ret>=0)
3030
                return 0;
3031

    
3032
            s->gb= bak;
3033
        }
3034
        skip_bits(&s->gb, 8);
3035
    }
3036
    
3037
    return -1;
3038
}
3039

    
3040
/**
3041
 * gets the average motion vector for a GMC MB.
3042
 * @param n either 0 for the x component or 1 for y
3043
 * @returns the average MV for a GMC MB
3044
 */
3045
static inline int get_amv(MpegEncContext *s, int n){
3046
    int x, y, mb_v, sum, dx, dy, shift;
3047
    int len = 1 << (s->f_code + 4);
3048
    const int a= s->sprite_warping_accuracy;
3049

    
3050
    if(s->real_sprite_warping_points==1){
3051
        if(s->divx_version==500 && s->divx_build==413)
3052
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3053
        else
3054
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3055
    }else{
3056
        dx= s->sprite_delta[n][0];
3057
        dy= s->sprite_delta[n][1];
3058
        shift= s->sprite_shift[0];
3059
        if(n) dy -= 1<<(shift + a + 1);
3060
        else  dx -= 1<<(shift + a + 1);
3061
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3062

    
3063
        sum=0;
3064
        for(y=0; y<16; y++){
3065
            int v;
3066
        
3067
            v= mb_v + dy*y;
3068
            //XXX FIXME optimize
3069
            for(x=0; x<16; x++){
3070
                sum+= v>>shift;
3071
                v+= dx;
3072
            }
3073
        }
3074
        sum= RSHIFT(sum, a+8-s->quarter_sample);
3075
    }
3076

    
3077
    if      (sum < -len) sum= -len;
3078
    else if (sum >= len) sum= len-1;
3079

    
3080
    return sum;
3081
}
3082

    
3083
/**
3084
 * decodes first partition.
3085
 * @return number of MBs decoded or <0 if an error occured
3086
 */
3087
static int mpeg4_decode_partition_a(MpegEncContext *s){
3088
    int mb_num;
3089
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3090
    
3091
    /* decode first partition */
3092
    mb_num=0;
3093
    s->first_slice_line=1;
3094
    for(; s->mb_y<s->mb_height; s->mb_y++){
3095
        ff_init_block_index(s);
3096
        for(; s->mb_x<s->mb_width; s->mb_x++){
3097
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3098
            int cbpc;
3099
            int dir=0;
3100
            
3101
            mb_num++;
3102
            ff_update_block_index(s);
3103
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3104
                s->first_slice_line=0;
3105
            
3106
            if(s->pict_type==I_TYPE){
3107
                int i;
3108

    
3109
                if(show_bits_long(&s->gb, 19)==DC_MARKER){
3110
                    return mb_num-1;
3111
                }
3112

    
3113
                do{
3114
                    cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3115
                    if (cbpc < 0){
3116
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3117
                        return -1;
3118
                    }
3119
                }while(cbpc == 8);
3120

    
3121
                s->cbp_table[xy]= cbpc & 3;
3122
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3123
                s->mb_intra = 1;
3124

    
3125
                if(cbpc & 4) {
3126
                    change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3127
                }
3128
                s->current_picture.qscale_table[xy]= s->qscale;
3129

    
3130
                s->mbintra_table[xy]= 1;
3131
                for(i=0; i<6; i++){
3132
                    int dc_pred_dir;
3133
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3134
                    if(dc < 0){
3135
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3136
                        return -1;
3137
                    }
3138
                    dir<<=1;
3139
                    if(dc_pred_dir) dir|=1;
3140
                }
3141
                s->pred_dir_table[xy]= dir;
3142
            }else{ /* P/S_TYPE */
3143
                int mx, my, pred_x, pred_y, bits;
3144
                int16_t * const mot_val= s->motion_val[s->block_index[0]];
3145
                const int stride= s->block_wrap[0]*2;
3146

    
3147
//              do{ //FIXME
3148
                bits= show_bits(&s->gb, 17);
3149
                if(bits==MOTION_MARKER){
3150
                    return mb_num-1;
3151
                }
3152
                skip_bits1(&s->gb);
3153
                if(bits&0x10000){
3154
                    /* skip mb */
3155
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3156
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3157
                        mx= get_amv(s, 0);
3158
                        my= get_amv(s, 1);
3159
                    }else{
3160
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3161
                        mx=my=0;
3162
                    }
3163
                    mot_val[0       ]= mot_val[2       ]=
3164
                    mot_val[0+stride]= mot_val[2+stride]= mx;
3165
                    mot_val[1       ]= mot_val[3       ]=
3166
                    mot_val[1+stride]= mot_val[3+stride]= my;
3167

    
3168
                    if(s->mbintra_table[xy])
3169
                        ff_clean_intra_table_entries(s);
3170
                    continue;
3171
                }
3172

    
3173
                cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3174
                if (cbpc < 0){
3175
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3176
                    return -1;
3177
                }
3178
//              }while(cbpc == 20);
3179

    
3180
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3181
    
3182
                s->mb_intra = ((cbpc & 4) != 0);
3183
        
3184
                if(s->mb_intra){
3185
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3186
                    s->mbintra_table[xy]= 1;
3187
                    mot_val[0       ]= mot_val[2       ]= 
3188
                    mot_val[0+stride]= mot_val[2+stride]= 0;
3189
                    mot_val[1       ]= mot_val[3       ]=
3190
                    mot_val[1+stride]= mot_val[3+stride]= 0;
3191
                }else{
3192
                    if(s->mbintra_table[xy])
3193
                        ff_clean_intra_table_entries(s);
3194

    
3195
                    if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3196
                        s->mcsel= get_bits1(&s->gb);
3197
                    else s->mcsel= 0;
3198
        
3199
                    if ((cbpc & 16) == 0) {
3200
                        /* 16x16 motion prediction */
3201

    
3202
                        h263_pred_motion(s, 0, &pred_x, &pred_y);
3203
                        if(!s->mcsel){
3204
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3205
                            if (mx >= 0xffff)
3206
                                return -1;
3207

    
3208
                            my = h263_decode_motion(s, pred_y, s->f_code);
3209
                            if (my >= 0xffff)
3210
                                return -1;
3211
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3212
                        } else {
3213
                            mx = get_amv(s, 0);
3214
                            my = get_amv(s, 1);
3215
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3216
                        }
3217

    
3218
                        mot_val[0       ]= mot_val[2       ] =
3219
                        mot_val[0+stride]= mot_val[2+stride]= mx;
3220
                        mot_val[1       ]= mot_val[3       ]=
3221
                        mot_val[1+stride]= mot_val[3+stride]= my;
3222
                    } else {
3223
                        int i;
3224
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3225
                        for(i=0;i<4;i++) {
3226
                            int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
3227
                            mx = h263_decode_motion(s, pred_x, s->f_code);
3228
                            if (mx >= 0xffff)
3229
                                return -1;
3230
                
3231
                            my = h263_decode_motion(s, pred_y, s->f_code);
3232
                            if (my >= 0xffff)
3233
                                return -1;
3234
                            mot_val[0] = mx;
3235
                            mot_val[1] = my;
3236
                        }
3237
                    }
3238
                }
3239
            }
3240
        }
3241
        s->mb_x= 0;
3242
    }
3243

    
3244
    return mb_num;
3245
}
3246

    
3247
/**
3248
 * decode second partition.
3249
 * @return <0 if an error occured
3250
 */
3251
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3252
    int mb_num=0;
3253
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3254

    
3255
    s->mb_x= s->resync_mb_x;
3256
    s->first_slice_line=1;
3257
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3258
        ff_init_block_index(s);
3259
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3260
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
3261

    
3262
            mb_num++;
3263
            ff_update_block_index(s);
3264
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3265
                s->first_slice_line=0;
3266
            
3267
            if(s->pict_type==I_TYPE){
3268
                int ac_pred= get_bits1(&s->gb);
3269
                int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3270
                if(cbpy<0){
3271
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3272
                    return -1;
3273
                }
3274
                
3275
                s->cbp_table[xy]|= cbpy<<2;
3276
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3277
            }else{ /* P || S_TYPE */
3278
                if(IS_INTRA(s->current_picture.mb_type[xy])){          
3279
                    int dir=0,i;
3280
                    int ac_pred = get_bits1(&s->gb);
3281
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3282

    
3283
                    if(cbpy<0){
3284
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3285
                        return -1;
3286
                    }
3287
                    
3288
                    if(s->cbp_table[xy] & 8) {
3289
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3290
                    }
3291
                    s->current_picture.qscale_table[xy]= s->qscale;
3292

    
3293
                    for(i=0; i<6; i++){
3294
                        int dc_pred_dir;
3295
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3296
                        if(dc < 0){
3297
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3298
                            return -1;
3299
                        }
3300
                        dir<<=1;
3301
                        if(dc_pred_dir) dir|=1;
3302
                    }
3303
                    s->cbp_table[xy]&= 3; //remove dquant
3304
                    s->cbp_table[xy]|= cbpy<<2;
3305
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3306
                    s->pred_dir_table[xy]= dir;
3307
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3308
                    s->current_picture.qscale_table[xy]= s->qscale;
3309
                    s->cbp_table[xy]= 0;
3310
                }else{
3311
                    int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3312

    
3313
                    if(cbpy<0){
3314
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3315
                        return -1;
3316
                    }
3317
                    
3318
                    if(s->cbp_table[xy] & 8) {
3319
                        change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3320
                    }
3321
                    s->current_picture.qscale_table[xy]= s->qscale;
3322

    
3323
                    s->cbp_table[xy]&= 3; //remove dquant
3324
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
3325
                }
3326
            }
3327
        }
3328
        if(mb_num >= mb_count) return 0;
3329
        s->mb_x= 0;
3330
    }
3331
    return 0;
3332
}
3333

    
3334
/**
3335
 * decodes the first & second partition
3336
 * @return <0 if error (and sets error type in the error_status_table)
3337
 */
3338
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3339
{
3340
    int mb_num;
3341
    const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3342
    const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3343
    
3344
    mb_num= mpeg4_decode_partition_a(s);    
3345
    if(mb_num<0){
3346
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3347
        return -1;
3348
    }
3349
    
3350
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3351
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3352
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3353
        return -1;
3354
    }
3355

    
3356
    s->mb_num_left= mb_num;
3357
        
3358
    if(s->pict_type==I_TYPE){
3359
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3360
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3361
            return -1;
3362
        }
3363
    }else{
3364
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3365
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3366
            return -1;
3367
        }
3368
    }
3369
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3370
    
3371
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
3372
        if(s->pict_type==P_TYPE)
3373
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3374
        return -1;
3375
    }else{
3376
        if(s->pict_type==P_TYPE)
3377
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3378
    }
3379

    
3380
    return 0;        
3381
}
3382

    
3383
/**
3384
 * decode partition C of one MB.
3385
 * @return <0 if an error occured
3386
 */
3387
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3388
{
3389
    int cbp, mb_type;
3390
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
3391

    
3392
    mb_type= s->current_picture.mb_type[xy];
3393
    cbp = s->cbp_table[xy];
3394

    
3395
    if(s->current_picture.qscale_table[xy] != s->qscale){
3396
        s->chroma_qscale=s->qscale= s->current_picture.qscale_table[xy];
3397
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3398
        s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3399
    }
3400
    
3401
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3402
        int i;
3403
        for(i=0; i<4; i++){
3404
            s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3405
            s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3406
        }
3407
        s->mb_intra = IS_INTRA(mb_type);
3408

    
3409
        if (IS_SKIP(mb_type)) {
3410
            /* skip mb */
3411
            for(i=0;i<6;i++)
3412
                s->block_last_index[i] = -1;
3413
            s->mv_dir = MV_DIR_FORWARD;
3414
            s->mv_type = MV_TYPE_16X16;
3415
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3416
                s->mcsel=1;
3417
                s->mb_skiped = 0;
3418
            }else{
3419
                s->mcsel=0;
3420
                s->mb_skiped = 1;
3421
            }
3422
        }else if(s->mb_intra){
3423
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3424
        }else if(!s->mb_intra){
3425
//            s->mcsel= 0; //FIXME do we need to init that
3426
            
3427
            s->mv_dir = MV_DIR_FORWARD;
3428
            if (IS_8X8(mb_type)) {
3429
                s->mv_type = MV_TYPE_8X8;
3430
            } else {
3431
                s->mv_type = MV_TYPE_16X16;
3432
            }
3433
        }
3434
    } else { /* I-Frame */
3435
        s->mb_intra = 1;
3436
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3437
    }
3438

    
3439
    if (!IS_SKIP(mb_type)) {
3440
        int i;
3441
        /* decode each block */
3442
        for (i = 0; i < 6; i++) {
3443
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3444
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3445
                return -1;
3446
            }
3447
            cbp+=cbp;
3448
        }
3449
    }
3450

    
3451
    /* per-MB end of slice check */
3452

    
3453
    if(--s->mb_num_left <= 0){
3454
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3455
        if(mpeg4_is_resync(s))
3456
            return SLICE_END;
3457
        else
3458
            return SLICE_NOEND;     
3459
    }else{
3460
        if(mpeg4_is_resync(s)){
3461
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3462
            if(s->cbp_table[xy+delta])
3463
                return SLICE_END;
3464
        }
3465
        return SLICE_OK;
3466
    }
3467
}
3468

    
3469
/**
3470
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3471
 */
3472
static void preview_obmc(MpegEncContext *s){
3473
    GetBitContext gb= s->gb;
3474
    
3475
    int cbpc, i, pred_x, pred_y, mx, my;
3476
    int16_t *mot_val;
3477
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3478
    const int stride= s->block_wrap[0]*2;
3479
    
3480
    for(i=0; i<4; i++)
3481
        s->block_index[i]+= 2;
3482
    for(i=4; i<6; i++)
3483
        s->block_index[i]+= 1;
3484
    s->mb_x++;
3485
    
3486
    assert(s->pict_type == P_TYPE);
3487

    
3488
    do{
3489
        if (get_bits1(&s->gb)) {
3490
            /* skip mb */
3491
            mot_val = s->motion_val[ s->block_index[0] ];
3492
            mot_val[0       ]= mot_val[2       ]= 
3493
            mot_val[0+stride]= mot_val[2+stride]= 0;
3494
            mot_val[1       ]= mot_val[3       ]=
3495
            mot_val[1+stride]= mot_val[3+stride]= 0;
3496
            
3497
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3498
            goto end;
3499
        }
3500
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3501
    }while(cbpc == 20);
3502
    
3503
    if(cbpc & 4){
3504
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3505
    }else{
3506
        get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3507
        if (cbpc & 8) {
3508
            skip_bits(&s->gb, 2);
3509
        }
3510
        
3511
        if ((cbpc & 16) == 0) {
3512
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
3513
                /* 16x16 motion prediction */
3514
                mot_val= h263_pred_motion(s, 0, &pred_x, &pred_y);
3515
                if (s->umvplus)
3516
                   mx = h263p_decode_umotion(s, pred_x);
3517
                else
3518
                   mx = h263_decode_motion(s, pred_x, s->f_code);
3519
            
3520
                if (s->umvplus)
3521
                   my = h263p_decode_umotion(s, pred_y);
3522
                else
3523
                   my = h263_decode_motion(s, pred_y, s->f_code);
3524
            
3525
                mot_val[0       ]= mot_val[2       ]= 
3526
                mot_val[0+stride]= mot_val[2+stride]= mx;
3527
                mot_val[1       ]= mot_val[3       ]=
3528
                mot_val[1+stride]= mot_val[3+stride]= my;
3529
        } else {
3530
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3531
            for(i=0;i<4;i++) {
3532
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3533
                if (s->umvplus)
3534
                  mx = h263p_decode_umotion(s, pred_x);
3535
                else
3536
                  mx = h263_decode_motion(s, pred_x, s->f_code);
3537
                
3538
                if (s->umvplus)
3539
                  my = h263p_decode_umotion(s, pred_y);
3540
                else    
3541
                  my = h263_decode_motion(s, pred_y, s->f_code);
3542
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3543
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3544
                mot_val[0] = mx;
3545
                mot_val[1] = my;
3546
            }
3547
        }
3548
    }
3549
end:
3550
        
3551
    for(i=0; i<4; i++)
3552
        s->block_index[i]-= 2;
3553
    for(i=4; i<6; i++)
3554
        s->block_index[i]-= 1;
3555
    s->mb_x--;
3556

    
3557
    s->gb= gb;
3558
}
3559

    
3560
int ff_h263_decode_mb(MpegEncContext *s,
3561
                      DCTELEM block[6][64])
3562
{
3563
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3564
    int16_t *mot_val;
3565
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3566
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
3567
    
3568
    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3569
      do{
3570
        if (get_bits1(&s->gb)) {
3571
            /* skip mb */
3572
            s->mb_intra = 0;
3573
            for(i=0;i<6;i++)
3574
                s->block_last_index[i] = -1;
3575
            s->mv_dir = MV_DIR_FORWARD;
3576
            s->mv_type = MV_TYPE_16X16;
3577
            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3578
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3579
                s->mcsel=1;
3580
                s->mv[0][0][0]= get_amv(s, 0);
3581
                s->mv[0][0][1]= get_amv(s, 1);
3582

    
3583
                s->mb_skiped = 0;
3584
            }else{
3585
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3586
                s->mcsel=0;
3587
                s->mv[0][0][0] = 0;
3588
                s->mv[0][0][1] = 0;
3589
                s->mb_skiped = !(s->obmc | s->loop_filter);
3590
            }
3591
            goto end;
3592
        }
3593
        cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3594
        //fprintf(stderr, "\tCBPC: %d", cbpc);
3595
        if (cbpc < 0){
3596
            av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3597
            return -1;
3598
        }
3599
      }while(cbpc == 20);
3600
        
3601
        dquant = cbpc & 8;
3602
        s->mb_intra = ((cbpc & 4) != 0);
3603
        if (s->mb_intra) goto intra;
3604
        
3605
        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3606
            s->mcsel= get_bits1(&s->gb);
3607
        else s->mcsel= 0;
3608
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3609
        
3610
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3611
            cbpy ^= 0xF;
3612
        
3613
        cbp = (cbpc & 3) | (cbpy << 2);
3614
        if (dquant) {
3615
            if(s->modified_quant){
3616
                if(get_bits1(&s->gb))
3617
                    s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3618
                else
3619
                    s->qscale= get_bits(&s->gb, 5);
3620
            }else
3621
                s->qscale += quant_tab[get_bits(&s->gb, 2)];
3622
            change_qscale(s, 0);
3623
        }
3624
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
3625
            s->interlaced_dct= get_bits1(&s->gb);
3626
        
3627
        s->mv_dir = MV_DIR_FORWARD;
3628
        if ((cbpc & 16) == 0) {
3629
            if(s->mcsel){
3630
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3631
                /* 16x16 global motion prediction */
3632
                s->mv_type = MV_TYPE_16X16;
3633
                mx= get_amv(s, 0);
3634
                my= get_amv(s, 1);
3635
                s->mv[0][0][0] = mx;
3636
                s->mv[0][0][1] = my;
3637
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3638
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; 
3639
                /* 16x8 field motion prediction */
3640
                s->mv_type= MV_TYPE_FIELD;
3641

    
3642
                s->field_select[0][0]= get_bits1(&s->gb);
3643
                s->field_select[0][1]= get_bits1(&s->gb);
3644

    
3645
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3646
                
3647
                for(i=0; i<2; i++){
3648
                    mx = h263_decode_motion(s, pred_x, s->f_code);
3649
                    if (mx >= 0xffff)
3650
                        return -1;
3651
            
3652
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
3653
                    if (my >= 0xffff)
3654
                        return -1;
3655

    
3656
                    s->mv[0][i][0] = mx;
3657
                    s->mv[0][i][1] = my;
3658
                }
3659
            }else{
3660
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 
3661
                /* 16x16 motion prediction */
3662
                s->mv_type = MV_TYPE_16X16;
3663
                h263_pred_motion(s, 0, &pred_x, &pred_y);
3664
                if (s->umvplus)
3665
                   mx = h263p_decode_umotion(s, pred_x);
3666
                else
3667
                   mx = h263_decode_motion(s, pred_x, s->f_code);
3668
            
3669
                if (mx >= 0xffff)
3670
                    return -1;
3671
            
3672
                if (s->umvplus)
3673
                   my = h263p_decode_umotion(s, pred_y);
3674
                else
3675
                   my = h263_decode_motion(s, pred_y, s->f_code);
3676
            
3677
                if (my >= 0xffff)
3678
                    return -1;
3679
                s->mv[0][0][0] = mx;
3680
                s->mv[0][0][1] = my;
3681

    
3682
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3683
                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */                   
3684
            }
3685
        } else {
3686
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 
3687
            s->mv_type = MV_TYPE_8X8;
3688
            for(i=0;i<4;i++) {
3689
                mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3690
                if (s->umvplus)
3691
                  mx = h263p_decode_umotion(s, pred_x);
3692
                else
3693
                  mx = h263_decode_motion(s, pred_x, s->f_code);
3694
                if (mx >= 0xffff)
3695
                    return -1;
3696
                
3697
                if (s->umvplus)
3698
                  my = h263p_decode_umotion(s, pred_y);
3699
                else    
3700
                  my = h263_decode_motion(s, pred_y, s->f_code);
3701
                if (my >= 0xffff)
3702
                    return -1;
3703
                s->mv[0][i][0] = mx;
3704
                s->mv[0][i][1] = my;
3705
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3706
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3707
                mot_val[0] = mx;
3708
                mot_val[1] = my;
3709
            }
3710
        }
3711
    } else if(s->pict_type==B_TYPE) {
3712
        int modb1; // first bit of modb
3713
        int modb2; // second bit of modb
3714
        int mb_type;
3715

    
3716
        s->mb_intra = 0; //B-frames never contain intra blocks
3717
        s->mcsel=0;      //     ...               true gmc blocks
3718

    
3719
        if(s->mb_x==0){
3720
            for(i=0; i<2; i++){
3721
                s->last_mv[i][0][0]= 
3722
                s->last_mv[i][0][1]= 
3723
                s->last_mv[i][1][0]= 
3724
                s->last_mv[i][1][1]= 0;
3725
            }
3726
        }
3727

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

    
3731
        if(s->mb_skiped){
3732
                /* skip mb */
3733
            for(i=0;i<6;i++)
3734
                s->block_last_index[i] = -1;
3735

    
3736
            s->mv_dir = MV_DIR_FORWARD;
3737
            s->mv_type = MV_TYPE_16X16;
3738
            s->mv[0][0][0] = 0;
3739
            s->mv[0][0][1] = 0;
3740
            s->mv[1][0][0] = 0;
3741
            s->mv[1][0][1] = 0;
3742
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 
3743
            goto end;
3744
        }
3745

    
3746
        modb1= get_bits1(&s->gb); 
3747
        if(modb1){
3748
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
3749
            cbp=0;
3750
        }else{
3751
            modb2= get_bits1(&s->gb);
3752
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3753
            if(mb_type<0){
3754
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
3755
                return -1;
3756
            }
3757
            mb_type= mb_type_b_map[ mb_type ];
3758
            if(modb2) cbp= 0;
3759
            else      cbp= get_bits(&s->gb, 6);
3760

    
3761
            if ((!IS_DIRECT(mb_type)) && cbp) {
3762
                if(get_bits1(&s->gb)){
3763
                    change_qscale(s, get_bits1(&s->gb)*4 - 2);
3764
                }
3765
            }
3766

    
3767
            if(!s->progressive_sequence){
3768
                if(cbp)
3769
                    s->interlaced_dct= get_bits1(&s->gb);
3770

    
3771
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
3772
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
3773
                    mb_type &= ~MB_TYPE_16x16;
3774

    
3775
                    if(USES_LIST(mb_type, 0)){
3776
                        s->field_select[0][0]= get_bits1(&s->gb);
3777
                        s->field_select[0][1]= get_bits1(&s->gb);
3778
                    }
3779
                    if(USES_LIST(mb_type, 1)){
3780
                        s->field_select[1][0]= get_bits1(&s->gb);
3781
                        s->field_select[1][1]= get_bits1(&s->gb);
3782
                    }
3783
                }
3784
            }
3785

    
3786
            s->mv_dir = 0;
3787
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
3788
                s->mv_type= MV_TYPE_16X16;
3789

    
3790
                if(USES_LIST(mb_type, 0)){
3791
                    s->mv_dir = MV_DIR_FORWARD;
3792

    
3793
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3794
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3795
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3796
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3797
                }
3798
    
3799
                if(USES_LIST(mb_type, 1)){
3800
                    s->mv_dir |= MV_DIR_BACKWARD;
3801

    
3802
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3803
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3804
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3805
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3806
                }
3807
            }else if(!IS_DIRECT(mb_type)){
3808
                s->mv_type= MV_TYPE_FIELD;
3809

    
3810
                if(USES_LIST(mb_type, 0)){
3811
                    s->mv_dir = MV_DIR_FORWARD;
3812
                
3813
                    for(i=0; i<2; i++){
3814
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3815
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3816
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3817
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3818
                    }
3819
                }
3820
    
3821
                if(USES_LIST(mb_type, 1)){
3822
                    s->mv_dir |= MV_DIR_BACKWARD;
3823

    
3824
                    for(i=0; i<2; i++){
3825
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
3826
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3827
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
3828
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3829
                    }
3830
                }
3831
            }
3832
        }
3833
          
3834
        if(IS_DIRECT(mb_type)){
3835
            if(IS_SKIP(mb_type))
3836
                mx=my=0;
3837
            else{
3838
                mx = h263_decode_motion(s, 0, 1);
3839
                my = h263_decode_motion(s, 0, 1);
3840
            }
3841
 
3842
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3843
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
3844
        }
3845
        s->current_picture.mb_type[xy]= mb_type;
3846
    } else { /* I-Frame */
3847
        do{
3848
            cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3849
            if (cbpc < 0){
3850
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3851
                return -1;
3852
            }
3853
        }while(cbpc == 8);
3854

    
3855
        dquant = cbpc & 4;
3856
        s->mb_intra = 1;
3857
intra:
3858
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3859
        if (s->h263_pred || s->h263_aic) {
3860
            s->ac_pred = get_bits1(&s->gb);
3861
            if(s->ac_pred){
3862
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3863
            
3864
                if (s->h263_aic)
3865
                    s->h263_aic_dir = get_bits1(&s->gb);
3866
            }
3867
        }else
3868
            s->ac_pred = 0;
3869
        
3870
        cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3871
        if(cbpy<0){
3872
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3873
            return -1;
3874
        }
3875
        cbp = (cbpc & 3) | (cbpy << 2);
3876
        if (dquant) {
3877
            if(s->modified_quant){
3878
                if(get_bits1(&s->gb))
3879
                    s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3880
                else
3881
                    s->qscale= get_bits(&s->gb, 5);
3882
            }else
3883
                s->qscale += quant_tab[get_bits(&s->gb, 2)];
3884
            change_qscale(s, 0);
3885
        }
3886
        
3887
        if(!s->progressive_sequence)
3888
            s->interlaced_dct= get_bits1(&s->gb);
3889

    
3890
        /* decode each block */
3891
        if (s->h263_pred) {
3892
            for (i = 0; i < 6; i++) {
3893
                if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
3894
                    return -1;
3895
                cbp+=cbp;
3896
            }
3897
        } else {
3898
            for (i = 0; i < 6; i++) {
3899
                if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3900
                    return -1;
3901
                cbp+=cbp;
3902
            }
3903
        }
3904
        goto end;
3905
    }
3906

    
3907
    /* decode each block */
3908
    if (s->h263_pred) {
3909
        for (i = 0; i < 6; i++) {
3910
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
3911
                return -1;
3912
            cbp+=cbp;
3913
        }
3914
    } else {
3915
        for (i = 0; i < 6; i++) {
3916
            if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3917
                return -1;
3918
            cbp+=cbp;
3919
        }
3920
    }
3921
end:
3922
    if(s->obmc){
3923
        if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width)
3924
            preview_obmc(s);
3925
    }
3926

    
3927
        /* per-MB end of slice check */
3928
    if(s->codec_id==CODEC_ID_MPEG4){
3929
        if(mpeg4_is_resync(s)){
3930
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3931
            if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
3932
                return SLICE_OK;
3933
            return SLICE_END;
3934
        }
3935
    }else{
3936
        int v= show_bits(&s->gb, 16);
3937
    
3938
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3939
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3940
        }
3941

    
3942
        if(v==0)
3943
            return SLICE_END;
3944
    }
3945

    
3946
    return SLICE_OK;     
3947
}
3948

    
3949
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3950
{
3951
    int code, val, sign, shift, l;
3952
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3953

    
3954
    if (code == 0)
3955
        return pred;
3956
    if (code < 0)
3957
        return 0xffff;
3958

    
3959
    sign = get_bits1(&s->gb);
3960
    shift = f_code - 1;
3961
    val = code;
3962
    if (shift) {
3963
        val = (val - 1) << shift;
3964
        val |= get_bits(&s->gb, shift);
3965
        val++;
3966
    }
3967
    if (sign)
3968
        val = -val;
3969
    val += pred;
3970

    
3971
    /* modulo decoding */
3972
    if (!s->h263_long_vectors) {
3973
        l = 1 << (f_code + 4);
3974
        val = ((val + l)&(l*2-1)) - l;
3975
    } else {
3976
        /* horrible h263 long vector mode */
3977
        if (pred < -31 && val < -63)
3978
            val += 64;
3979
        if (pred > 32 && val > 63)
3980
            val -= 64;
3981
        
3982
    }
3983
    return val;
3984
}
3985

    
3986
/* Decodes RVLC of H.263+ UMV */
3987
static int h263p_decode_umotion(MpegEncContext * s, int pred)
3988
{
3989
   int code = 0, sign;
3990
   
3991
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
3992
      return pred;
3993
   
3994
   code = 2 + get_bits1(&s->gb);
3995
   
3996
   while (get_bits1(&s->gb))
3997
   {
3998
      code <<= 1;
3999
      code += get_bits1(&s->gb);
4000
   }
4001
   sign = code & 1;
4002
   code >>= 1;
4003
   
4004
   code = (sign) ? (pred - code) : (pred + code);
4005
#ifdef DEBUG
4006
   fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
4007
#endif
4008
   return code;   
4009

    
4010
}
4011

    
4012
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4013
                             int n, int coded)
4014
{
4015
    int code, level, i, j, last, run;
4016
    RLTable *rl = &rl_inter;
4017
    const uint8_t *scan_table;
4018
    GetBitContext gb= s->gb;
4019

    
4020
    scan_table = s->intra_scantable.permutated;
4021
    if (s->h263_aic && s->mb_intra) {
4022
        rl = &rl_intra_aic;
4023
        i = 0;
4024
        if (s->ac_pred) {
4025
            if (s->h263_aic_dir) 
4026
                scan_table = s->intra_v_scantable.permutated; /* left */
4027
            else
4028
                scan_table = s->intra_h_scantable.permutated; /* top */
4029
        }
4030
    } else if (s->mb_intra) {
4031
        /* DC coef */
4032
        if(s->codec_id == CODEC_ID_RV10){
4033
          if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4034
            int component, diff;
4035
            component = (n <= 3 ? 0 : n - 4 + 1);
4036
            level = s->last_dc[component];
4037
            if (s->rv10_first_dc_coded[component]) {
4038
                diff = rv_decode_dc(s, n);
4039
                if (diff == 0xffff)
4040
                    return -1;
4041
                level += diff;
4042
                level = level & 0xff; /* handle wrap round */
4043
                s->last_dc[component] = level;
4044
            } else {
4045
                s->rv10_first_dc_coded[component] = 1;
4046
            }
4047
          } else {
4048
                level = get_bits(&s->gb, 8);
4049
          }
4050
        }else{
4051
            level = get_bits(&s->gb, 8);
4052
            if((level&0x7F) == 0){
4053
                av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4054
                return -1;
4055
            }
4056
            if (level == 255)
4057
                level = 128;
4058
        }
4059
        block[0] = level;
4060
        i = 1;
4061
    } else {
4062
        i = 0;
4063
    }
4064
    if (!coded) {
4065
        if (s->mb_intra && s->h263_aic)
4066
            goto not_coded;
4067
        s->block_last_index[n] = i - 1;
4068
        return 0;
4069
    }
4070
retry:
4071
    for(;;) {
4072
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4073
        if (code < 0){
4074
            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4075
            return -1;
4076
        }
4077
        if (code == rl->n) {
4078
            /* escape */
4079
            if (s->h263_flv > 1) {
4080
                int is11 = get_bits1(&s->gb);
4081
                last = get_bits1(&s->gb);
4082
                run = get_bits(&s->gb, 6);
4083
                if(is11){
4084
                    level = get_sbits(&s->gb, 11);
4085
                } else {
4086
                    level = get_sbits(&s->gb, 7);
4087
                }
4088
            } else {
4089
                last = get_bits1(&s->gb);
4090
                run = get_bits(&s->gb, 6);
4091
                level = (int8_t)get_bits(&s->gb, 8);
4092
                if(level == -128){
4093
                    if (s->codec_id == CODEC_ID_RV10) {
4094
                        /* XXX: should patch encoder too */
4095
                        level = get_sbits(&s->gb, 12);
4096
                    }else{
4097
                        level = get_bits(&s->gb, 5);
4098
                        level |= get_sbits(&s->gb, 6)<<5;
4099
                    }
4100
                }
4101
            }
4102
        } else {
4103
            run = rl->table_run[code];
4104
            level = rl->table_level[code];
4105
            last = code >= rl->last;
4106
            if (get_bits1(&s->gb))
4107
                level = -level;
4108
        }
4109
        i += run;
4110
        if (i >= 64){
4111
            if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4112
                //looks like a hack but no, its the way its supposed to work ...
4113
                rl = &rl_intra_aic;
4114
                i = 0;
4115
                s->gb= gb;
4116
                memset(block, 0, sizeof(DCTELEM)*64);
4117
                goto retry;
4118
            }
4119
            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
4120
            return -1;
4121
        }
4122
        j = scan_table[i];
4123
        block[j] = level;
4124
        if (last)
4125
            break;
4126
        i++;
4127
    }
4128
not_coded:    
4129
    if (s->mb_intra && s->h263_aic) {
4130
        h263_pred_acdc(s, block, n);
4131
        i = 63;
4132
    }
4133
    s->block_last_index[n] = i;
4134
    return 0;
4135
}
4136

    
4137
/**
4138
 * decodes the dc value.
4139
 * @param n block index (0-3 are luma, 4-5 are chroma)
4140
 * @param dir_ptr the prediction direction will be stored here
4141
 * @return the quantized dc
4142
 */
4143
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4144
{
4145
    int level, pred, code;
4146
    uint16_t *dc_val;
4147

    
4148
    if (n < 4) 
4149
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4150
    else 
4151
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4152
    if (code < 0 || code > 9 /* && s->nbit<9 */){
4153
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4154
        return -1;
4155
    }
4156
    if (code == 0) {
4157
        level = 0;
4158
    } else {
4159
        if(IS_3IV1){
4160
            if(code==1)
4161
                level= 2*get_bits1(&s->gb)-1;
4162
            else{
4163
                if(get_bits1(&s->gb))
4164
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
4165
                else
4166
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4167
            }
4168
        }else{
4169
            level = get_xbits(&s->gb, code);
4170
        }
4171

    
4172
        if (code > 8){
4173
            if(get_bits1(&s->gb)==0){ /* marker */
4174
                if(s->error_resilience>=2){
4175
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4176
                    return -1;
4177
                }
4178
            }
4179
        }
4180
    }
4181
    pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
4182
    level += pred;
4183
    if (level < 0){
4184
        if(s->error_resilience>=3){
4185
            av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
4186
            return -1;
4187
        }
4188
        level = 0;
4189
    }
4190
    if (n < 4) {
4191
        *dc_val = level * s->y_dc_scale;
4192
    } else {
4193
        *dc_val = level * s->c_dc_scale;
4194
    }
4195
    if(IS_3IV1)
4196
        *dc_val = level * 8;
4197
    
4198
    if(s->error_resilience>=3){
4199
        if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
4200
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
4201
            return -1;
4202
        }
4203
    }
4204
    return level;
4205
}
4206

    
4207
/**
4208
 * decodes a block.
4209
 * @return <0 if an error occured
4210
 */
4211
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4212
                              int n, int coded, int intra, int rvlc)
4213
{
4214
    int level, i, last, run;
4215
    int dc_pred_dir;
4216
    RLTable * rl;
4217
    RL_VLC_ELEM * rl_vlc;
4218
    const uint8_t * scan_table;
4219
    int qmul, qadd;
4220

    
4221
    //Note intra & rvlc should be optimized away if this is inlined
4222
    
4223
    if(intra) {
4224
      if(s->qscale < s->intra_dc_threshold){
4225
        /* DC coef */
4226
        if(s->partitioned_frame){
4227
            level = s->dc_val[0][ s->block_index[n] ];
4228
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4229
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4230
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4231
        }else{
4232
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4233
            if (level < 0)
4234
                return -1;
4235
        }
4236
        block[0] = level;
4237
        i = 0;
4238
      }else{
4239
            i = -1;
4240
      }  
4241
        if (!coded) 
4242
            goto not_coded;
4243
        
4244
        if(rvlc){        
4245
            rl = &rvlc_rl_intra;
4246
            rl_vlc = rvlc_rl_intra.rl_vlc[0];
4247
        }else{
4248
            rl = &rl_intra;
4249
            rl_vlc = rl_intra.rl_vlc[0];
4250
        }
4251
        if (s->ac_pred) {
4252
            if (dc_pred_dir == 0) 
4253
                scan_table = s->intra_v_scantable.permutated; /* left */
4254
            else
4255
                scan_table = s->intra_h_scantable.permutated; /* top */
4256
        } else {
4257
            scan_table = s->intra_scantable.permutated;
4258
        }
4259
        qmul=1;
4260
        qadd=0;
4261
    } else {
4262
        i = -1;
4263
        if (!coded) {
4264
            s->block_last_index[n] = i;
4265
            return 0;
4266
        }
4267
        if(rvlc) rl = &rvlc_rl_inter;
4268
        else     rl = &rl_inter;
4269
   
4270
        scan_table = s->intra_scantable.permutated;
4271

    
4272
        if(s->mpeg_quant){
4273
            qmul=1;
4274
            qadd=0;
4275
            if(rvlc){        
4276
                rl_vlc = rvlc_rl_inter.rl_vlc[0];        
4277
            }else{
4278
                rl_vlc = rl_inter.rl_vlc[0];        
4279
            }
4280
        }else{
4281
            qmul = s->qscale << 1;
4282
            qadd = (s->qscale - 1) | 1;
4283
            if(rvlc){        
4284
                rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];        
4285
            }else{
4286
                rl_vlc = rl_inter.rl_vlc[s->qscale];        
4287
            }
4288
        }
4289
    }
4290
  {
4291
    OPEN_READER(re, &s->gb);
4292
    for(;;) {
4293
        UPDATE_CACHE(re, &s->gb);
4294
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4295
        if (level==0) {
4296
          /* escape */                
4297
          if(rvlc){
4298
                if(SHOW_UBITS(re, &s->gb, 1)==0){
4299
                    av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4300
                    return -1;
4301
                }; SKIP_CACHE(re, &s->gb, 1);
4302
 
4303
                last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4304
                run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4305
                SKIP_COUNTER(re, &s->gb, 1+1+6);
4306
                UPDATE_CACHE(re, &s->gb);
4307
              
4308
                if(SHOW_UBITS(re, &s->gb, 1)==0){
4309
                    av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4310
                    return -1;
4311
                }; SKIP_CACHE(re, &s->gb, 1);
4312
 
4313
                level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4314
 
4315
                if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4316
                    av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4317
                    return -1;
4318
                }; SKIP_CACHE(re, &s->gb, 5);
4319

    
4320
                level=  level * qmul + qadd;
4321
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4322
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4323

    
4324
                i+= run + 1;
4325
                if(last) i+=192;
4326
          }else{
4327
            int cache;
4328
            cache= GET_CACHE(re, &s->gb);
4329

    
4330
            if(IS_3IV1) 
4331
                cache ^= 0xC0000000;
4332

    
4333
            if (cache&0x80000000) {
4334
                if (cache&0x40000000) {
4335
                    /* third escape */
4336
                    SKIP_CACHE(re, &s->gb, 2);
4337
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4338
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4339
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
4340
                    UPDATE_CACHE(re, &s->gb);
4341

    
4342
                    if(IS_3IV1){
4343
                        level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4344
                    }else{
4345
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
4346
                            av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4347
                            return -1;
4348
                        }; SKIP_CACHE(re, &s->gb, 1);
4349

    
4350
                        level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4351

    
4352
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
4353
                            av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4354
                            return -1;
4355
                        }; LAST_SKIP_CACHE(re, &s->gb, 1);
4356

    
4357
                        SKIP_COUNTER(re, &s->gb, 1+12+1);
4358
                    }
4359
 
4360
                    if(level*s->qscale>1024 || level*s->qscale<-1024){
4361
                        av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4362
                        return -1;
4363
                    }
4364
#if 0
4365
                    if(s->error_resilience >= FF_ER_COMPLIANT){
4366
                        const int abs_level= ABS(level);
4367
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4368
                            const int run1= run - rl->max_run[last][abs_level] - 1;
4369
                            if(abs_level <= rl->max_level[last][run]){
4370
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4371
                                return -1;
4372
                            }
4373
                            if(s->error_resilience > FF_ER_COMPLIANT){
4374
                                if(abs_level <= rl->max_level[last][run]*2){
4375
                                    fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
4376
                                    return -1;
4377
                                }
4378
                                if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4379
                                    fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
4380
                                    return -1;
4381
                                }
4382
                            }
4383
                        }
4384
                    }
4385
#endif
4386
                    if (level>0) level= level * qmul + qadd;
4387
                    else         level= level * qmul - qadd;
4388

    
4389
                    i+= run + 1;
4390
                    if(last) i+=192;
4391
                } else {
4392
                    /* second escape */
4393
#if MIN_CACHE_BITS < 20
4394
                    LAST_SKIP_BITS(re, &s->gb, 2);
4395
                    UPDATE_CACHE(re, &s->gb);
4396
#else
4397
                    SKIP_BITS(re, &s->gb, 2);
4398
#endif
4399
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4400
                    i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4401
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4402
                    LAST_SKIP_BITS(re, &s->gb, 1);
4403
                }
4404
            } else {
4405
                /* first escape */
4406
#if MIN_CACHE_BITS < 19
4407
                LAST_SKIP_BITS(re, &s->gb, 1);
4408
                UPDATE_CACHE(re, &s->gb);
4409
#else
4410
                SKIP_BITS(re, &s->gb, 1);
4411
#endif
4412
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4413
                i+= run;
4414
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4415
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4416
                LAST_SKIP_BITS(re, &s->gb, 1);
4417
            }
4418
          }
4419
        } else {
4420
            i+= run;
4421
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4422
            LAST_SKIP_BITS(re, &s->gb, 1);
4423
        }
4424
        if (i > 62){
4425
            i-= 192;
4426
            if(i&(~63)){
4427
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4428
                return -1;
4429
            }
4430

    
4431
            block[scan_table[i]] = level;
4432
            break;
4433
        }
4434

    
4435
        block[scan_table[i]] = level;
4436
    }
4437
    CLOSE_READER(re, &s->gb);
4438
  }
4439
 not_coded:
4440
    if (intra) {
4441
        if(s->qscale >= s->intra_dc_threshold){
4442
            uint16_t *dc_val;
4443
            block[0] += ff_mpeg4_pred_dc(s, n, &dc_val, &dc_pred_dir);
4444
            if (n < 4) {
4445
                *dc_val = block[0] * s->y_dc_scale;
4446
            } else {
4447
                *dc_val = block[0] * s->c_dc_scale;
4448
            }
4449

    
4450
            if(i == -1) i=0;
4451
        }
4452

    
4453
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
4454
        if (s->ac_pred) {
4455
            i = 63; /* XXX: not optimal */
4456
        }
4457
    }
4458
    s->block_last_index[n] = i;
4459
    return 0;
4460
}
4461

    
4462
/* most is hardcoded. should extend to handle all h263 streams */
4463
int h263_decode_picture_header(MpegEncContext *s)
4464
{
4465
    int format, width, height, i;
4466
    uint32_t startcode;
4467
    
4468
    align_get_bits(&s->gb);
4469

    
4470
    startcode= get_bits(&s->gb, 22-8);
4471

    
4472
    for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4473
        startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4474
        
4475
        if(startcode == 0x20)
4476
            break;
4477
    }
4478
        
4479
    if (startcode != 0x20) {
4480
        av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
4481
        return -1;
4482
    }
4483
    /* temporal reference */
4484
    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4485

    
4486
    /* PTYPE starts here */    
4487
    if (get_bits1(&s->gb) != 1) {
4488
        /* marker */
4489
        av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
4490
        return -1;
4491
    }
4492
    if (get_bits1(&s->gb) != 0) {
4493
        av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
4494
        return -1;        /* h263 id */
4495
    }
4496
    skip_bits1(&s->gb);        /* split screen off */
4497
    skip_bits1(&s->gb);        /* camera  off */
4498
    skip_bits1(&s->gb);        /* freeze picture release off */
4499

    
4500
    /* Reset GOB number */
4501
    s->gob_number = 0;
4502
        
4503
    format = get_bits(&s->gb, 3);
4504
    /*
4505
        0    forbidden
4506
        1    sub-QCIF
4507
        10   QCIF
4508
        7        extended PTYPE (PLUSPTYPE)
4509
    */
4510

    
4511
    if (format != 7 && format != 6) {
4512
        s->h263_plus = 0;
4513
        /* H.263v1 */
4514
        width = h263_format[format][0];
4515
        height = h263_format[format][1];
4516
        if (!width)
4517
            return -1;
4518
        
4519
        s->pict_type = I_TYPE + get_bits1(&s->gb);
4520

    
4521
        s->h263_long_vectors = get_bits1(&s->gb); 
4522

    
4523
        if (get_bits1(&s->gb) != 0) {
4524
            av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
4525
            return -1;        /* SAC: off */
4526
        }
4527
        s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
4528
        s->unrestricted_mv = s->h263_long_vectors || s->obmc;
4529
        
4530
        if (get_bits1(&s->gb) != 0) {
4531
            av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
4532
            return -1;        /* not PB frame */
4533
        }
4534
        s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
4535
        skip_bits1(&s->gb);        /* Continuous Presence Multipoint mode: off */
4536

    
4537
        s->width = width;
4538
        s->height = height;
4539
    } else {
4540
        int ufep;
4541
        
4542
        /* H.263v2 */
4543
        s->h263_plus = 1;
4544
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
4545

    
4546
        /* ufep other than 0 and 1 are reserved */        
4547
        if (ufep == 1) {
4548
            /* OPPTYPE */       
4549
            format = get_bits(&s->gb, 3);
4550
            dprintf("ufep=1, format: %d\n", format);
4551
            skip_bits(&s->gb,1); /* Custom PCF */
4552
            s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
4553
            if (get_bits1(&s->gb) != 0) {
4554
                av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
4555
            }
4556
            s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
4557
            s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
4558
            s->loop_filter= get_bits1(&s->gb);
4559
            s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
4560
            
4561
            if (get_bits1(&s->gb) != 0) {
4562
                av_log(s->avctx, AV_LOG_ERROR, "Slice Structured not supported\n");
4563
            }
4564
            if (get_bits1(&s->gb) != 0) {
4565
                av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
4566
            }
4567
            if (get_bits1(&s->gb) != 0) {
4568
                av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
4569
            }
4570
            s->alt_inter_vlc= get_bits1(&s->gb);
4571
            s->modified_quant= get_bits1(&s->gb);
4572
            if(s->modified_quant)
4573
                s->chroma_qscale_table= ff_h263_chroma_qscale_table;
4574
            
4575
            skip_bits(&s->gb, 1); /* Prevent start code emulation */
4576

    
4577
            skip_bits(&s->gb, 3); /* Reserved */
4578
        } else if (ufep != 0) {
4579
            av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
4580
            return -1;
4581
        }
4582
            
4583
        /* MPPTYPE */
4584
        s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
4585
        if (s->pict_type == 8 && s->avctx->codec_tag == ff_get_fourcc("ZYGO"))
4586
            s->pict_type = I_TYPE;
4587
        if (s->pict_type != I_TYPE &&
4588
            s->pict_type != P_TYPE)
4589
            return -1;
4590
        skip_bits(&s->gb, 2);
4591
        s->no_rounding = get_bits1(&s->gb);
4592
        skip_bits(&s->gb, 4);
4593
        
4594
        /* Get the picture dimensions */
4595
        if (ufep) {
4596
            if (format == 6) {
4597
                /* Custom Picture Format (CPFMT) */
4598
                s->aspect_ratio_info = get_bits(&s->gb, 4);
4599
                dprintf("aspect: %d\n", s->aspect_ratio_info);
4600
                /* aspect ratios:
4601
                0 - forbidden
4602
                1 - 1:1
4603
                2 - 12:11 (CIF 4:3)
4604
                3 - 10:11 (525-type 4:3)
4605
                4 - 16:11 (CIF 16:9)
4606
                5 - 40:33 (525-type 16:9)
4607
                6-14 - reserved
4608
                */
4609
                width = (get_bits(&s->gb, 9) + 1) * 4;
4610
                skip_bits1(&s->gb);
4611
                height = get_bits(&s->gb, 9) * 4;
4612
                dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
4613
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
4614
                    /* aspected dimensions */
4615
                    s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
4616
                    s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
4617
                }else{
4618
                    s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
4619
                }
4620
            } else {
4621
                width = h263_format[format][0];
4622
                height = h263_format[format][1];
4623
            }
4624
            if ((width == 0) || (height == 0))
4625
                return -1;
4626
            s->width = width;
4627
            s->height = height;
4628
            if (s->umvplus) {
4629
                if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4630
                    skip_bits1(&s->gb); 
4631
            }
4632
        }
4633
            
4634
        s->qscale = get_bits(&s->gb, 5);
4635
        s->chroma_qscale= s->chroma_qscale_table[s->qscale];
4636
    }
4637
    /* PEI */
4638
    while (get_bits1(&s->gb) != 0) {
4639
        skip_bits(&s->gb, 8);
4640
    }
4641
    s->f_code = 1;
4642
    
4643
    if(s->h263_aic){
4644
         s->y_dc_scale_table= 
4645
         s->c_dc_scale_table= ff_aic_dc_scale_table;
4646
    }else{
4647
        s->y_dc_scale_table=
4648
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4649
    }
4650

    
4651
     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4652
         av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s\n", 
4653
         s->qscale, av_get_pict_type_char(s->pict_type),
4654
         s->gb.size_in_bits, 1-s->no_rounding,
4655
         s->obmc ? " AP" : "",
4656
         s->umvplus ? " UMV" : "",
4657
         s->h263_long_vectors ? " LONG" : "",
4658
         s->h263_plus ? " +" : "",
4659
         s->h263_aic ? " AIC" : "",
4660
         s->alt_inter_vlc ? " AIV" : "",
4661
         s->modified_quant ? " MQ" : "",
4662
         s->loop_filter ? " LOOP" : ""
4663
         ); 
4664
     }
4665
#if 1
4666
    if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
4667
        int i,j;
4668
        for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
4669
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
4670
        for(i=0; i<13; i++){
4671
            for(j=0; j<3; j++){
4672
                int v= get_bits(&s->gb, 8);
4673
                v |= get_sbits(&s->gb, 8)<<8;
4674
                av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
4675
            }
4676
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
4677
        }
4678
        for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
4679
    }
4680
#endif
4681

    
4682
    return 0;
4683
}
4684

    
4685
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4686
{
4687
    int i;
4688
    int a= 2<<s->sprite_warping_accuracy;
4689
    int rho= 3-s->sprite_warping_accuracy;
4690
    int r=16/a;
4691
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4692
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4693
    int sprite_ref[4][2];
4694
    int virtual_ref[2][2];
4695
    int w2, h2, w3, h3;
4696
    int alpha=0, beta=0;
4697
    int w= s->width;
4698
    int h= s->height;
4699
    int min_ab;
4700

    
4701
    for(i=0; i<s->num_sprite_warping_points; i++){
4702
        int length;
4703
        int x=0, y=0;
4704

    
4705
        length= get_vlc(&s->gb, &sprite_trajectory);
4706
        if(length){
4707
            x= get_xbits(&s->gb, length);
4708
        }
4709
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4710
        
4711
        length= get_vlc(&s->gb, &sprite_trajectory);
4712
        if(length){
4713
            y=get_xbits(&s->gb, length);
4714
        }
4715
        skip_bits1(&s->gb); /* marker bit */
4716
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4717
        d[i][0]= x;
4718
        d[i][1]= y;
4719
    }
4720

    
4721
    while((1<<alpha)<w) alpha++;
4722
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4723
    w2= 1<<alpha;
4724
    h2= 1<<beta;
4725

    
4726
// Note, the 4th point isnt used for GMC
4727
    if(s->divx_version==500 && s->divx_build==413){
4728
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
4729
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
4730
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
4731
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
4732
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
4733
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
4734
    } else {
4735
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
4736
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
4737
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
4738
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
4739
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
4740
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
4741
    }
4742
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
4743
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
4744
    
4745
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
4746
// perhaps it should be reordered to be more readable ...
4747
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
4748
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
4749
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
4750
        + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
4751
    virtual_ref[0][1]= 16*vop_ref[0][1] 
4752
        + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
4753
    virtual_ref[1][0]=