Move 3 direct MV related functions that i left out from h263.c to mpeg4video.c.
[ffmpeg.git] / libavcodec / h263.c
1 /*
2  * H263/MPEG4 backend for ffmpeg encoder and decoder
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * H263+ support.
5  * Copyright (c) 2001 Juan J. Sierralta P
6  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7  *
8  * ac prediction encoding, B-frame support, error resilience, optimizations,
9  * qpel decoding, gmc decoding, interlaced decoding
10  * by Michael Niedermayer <michaelni@gmx.at>
11  *
12  * This file is part of FFmpeg.
13  *
14  * FFmpeg is free software; you can redistribute it and/or
15  * modify it under the terms of the GNU Lesser General Public
16  * License as published by the Free Software Foundation; either
17  * version 2.1 of the License, or (at your option) any later version.
18  *
19  * FFmpeg is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22  * Lesser General Public License for more details.
23  *
24  * You should have received a copy of the GNU Lesser General Public
25  * License along with FFmpeg; if not, write to the Free Software
26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27  */
28
29 /**
30  * @file libavcodec/h263.c
31  * h263/mpeg4 codec.
32  */
33
34 //#define DEBUG
35 #include <limits.h>
36
37 #include "dsputil.h"
38 #include "avcodec.h"
39 #include "mpegvideo.h"
40 #include "h263.h"
41 #include "h263data.h"
42 #include "mathops.h"
43 #include "unary.h"
44 #include "flv.h"
45 #include "mpeg4video.h"
46
47 //#undef NDEBUG
48 //#include <assert.h>
49
50 // The defines below define the number of bits that are read at once for
51 // reading vlc values. Changing these may improve speed and data cache needs
52 // be aware though that decreasing them may need the number of stages that is
53 // passed to get_vlc* to be increased.
54 #define MV_VLC_BITS 9
55 #define H263_MBTYPE_B_VLC_BITS 6
56 #define CBPC_B_VLC_BITS 3
57
58
59 #if CONFIG_ENCODERS
60 /**
61  * Table of number of bits a motion vector component needs.
62  */
63 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
64
65 /**
66  * Minimal fcode that a motion vector component would need.
67  */
68 static uint8_t fcode_tab[MAX_MV*2+1];
69
70 /**
71  * Minimal fcode that a motion vector component would need in umv.
72  * All entries in this table are 1.
73  */
74 static uint8_t umv_fcode_tab[MAX_MV*2+1];
75
76 //unified encoding tables for run length encoding of coefficients
77 //unified in the sense that the specification specifies the encoding in several steps.
78 static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
79 static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
80 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
81 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
82 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
83
84 #endif
85
86 static uint8_t static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3];
87
88
89 int h263_get_picture_format(int width, int height)
90 {
91     if (width == 128 && height == 96)
92         return 1;
93     else if (width == 176 && height == 144)
94         return 2;
95     else if (width == 352 && height == 288)
96         return 3;
97     else if (width == 704 && height == 576)
98         return 4;
99     else if (width == 1408 && height == 1152)
100         return 5;
101     else
102         return 7;
103 }
104
105 void ff_h263_show_pict_info(MpegEncContext *s){
106     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
107     av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
108          s->qscale, av_get_pict_type_char(s->pict_type),
109          s->gb.size_in_bits, 1-s->no_rounding,
110          s->obmc ? " AP" : "",
111          s->umvplus ? " UMV" : "",
112          s->h263_long_vectors ? " LONG" : "",
113          s->h263_plus ? " +" : "",
114          s->h263_aic ? " AIC" : "",
115          s->alt_inter_vlc ? " AIV" : "",
116          s->modified_quant ? " MQ" : "",
117          s->loop_filter ? " LOOP" : "",
118          s->h263_slice_structured ? " SS" : "",
119          s->avctx->time_base.den, s->avctx->time_base.num
120     );
121     }
122 }
123
124 #if CONFIG_ENCODERS
125
126 /**
127  * Returns the 4 bit value that specifies the given aspect ratio.
128  * This may be one of the standard aspect ratios or it specifies
129  * that the aspect will be stored explicitly later.
130  */
131 av_const int ff_h263_aspect_to_info(AVRational aspect){
132     int i;
133
134     if(aspect.num==0) aspect= (AVRational){1,1};
135
136     for(i=1; i<6; i++){
137         if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
138             return i;
139         }
140     }
141
142     return FF_ASPECT_EXTENDED;
143 }
144
145 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
146 {
147     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
148     int best_clock_code=1;
149     int best_divisor=60;
150     int best_error= INT_MAX;
151
152     if(s->h263_plus){
153         for(i=0; i<2; i++){
154             int div, error;
155             div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
156             div= av_clip(div, 1, 127);
157             error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
158             if(error < best_error){
159                 best_error= error;
160                 best_divisor= div;
161                 best_clock_code= i;
162             }
163         }
164     }
165     s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
166     coded_frame_rate= 1800000;
167     coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
168
169     align_put_bits(&s->pb);
170
171     /* Update the pointer to last GOB */
172     s->ptr_lastgob = put_bits_ptr(&s->pb);
173     put_bits(&s->pb, 22, 0x20); /* PSC */
174     temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
175                          (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
176     put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
177
178     put_bits(&s->pb, 1, 1);     /* marker */
179     put_bits(&s->pb, 1, 0);     /* h263 id */
180     put_bits(&s->pb, 1, 0);     /* split screen off */
181     put_bits(&s->pb, 1, 0);     /* camera  off */
182     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
183
184     format = h263_get_picture_format(s->width, s->height);
185     if (!s->h263_plus) {
186         /* H.263v1 */
187         put_bits(&s->pb, 3, format);
188         put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE));
189         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
190         of H.263v1 UMV implies to check the predicted MV after
191         calculation of the current MB to see if we're on the limits */
192         put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
193         put_bits(&s->pb, 1, 0);         /* SAC: off */
194         put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
195         put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
196         put_bits(&s->pb, 5, s->qscale);
197         put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
198     } else {
199         int ufep=1;
200         /* H.263v2 */
201         /* H.263 Plus PTYPE */
202
203         put_bits(&s->pb, 3, 7);
204         put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
205         if (format == 7)
206             put_bits(&s->pb,3,6); /* Custom Source Format */
207         else
208             put_bits(&s->pb, 3, format);
209
210         put_bits(&s->pb,1, s->custom_pcf);
211         put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
212         put_bits(&s->pb,1,0); /* SAC: off */
213         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
214         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
215         put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
216         put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
217         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
218         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
219         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
220         put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
221         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
222         put_bits(&s->pb,3,0); /* Reserved */
223
224         put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE);
225
226         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
227         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
228         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
229         put_bits(&s->pb,2,0); /* Reserved */
230         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
231
232         /* This should be here if PLUSPTYPE */
233         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
234
235                 if (format == 7) {
236             /* Custom Picture Format (CPFMT) */
237             s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
238
239             put_bits(&s->pb,4,s->aspect_ratio_info);
240             put_bits(&s->pb,9,(s->width >> 2) - 1);
241             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
242             put_bits(&s->pb,9,(s->height >> 2));
243             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
244                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
245                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
246             }
247         }
248         if(s->custom_pcf){
249             if(ufep){
250                 put_bits(&s->pb, 1, best_clock_code);
251                 put_bits(&s->pb, 7, best_divisor);
252             }
253             put_sbits(&s->pb, 2, temp_ref>>8);
254         }
255
256         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
257         if (s->umvplus)
258 //            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
259 //FIXME check actual requested range
260             put_bits(&s->pb,2,1); /* unlimited */
261         if(s->h263_slice_structured)
262             put_bits(&s->pb,2,0); /* no weird submodes */
263
264         put_bits(&s->pb, 5, s->qscale);
265     }
266
267     put_bits(&s->pb, 1, 0);     /* no PEI */
268
269     if(s->h263_slice_structured){
270         put_bits(&s->pb, 1, 1);
271
272         assert(s->mb_x == 0 && s->mb_y == 0);
273         ff_h263_encode_mba(s);
274
275         put_bits(&s->pb, 1, 1);
276     }
277
278     if(s->h263_aic){
279          s->y_dc_scale_table=
280          s->c_dc_scale_table= ff_aic_dc_scale_table;
281     }else{
282         s->y_dc_scale_table=
283         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
284     }
285 }
286
287 /**
288  * Encodes a group of blocks header.
289  */
290 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
291 {
292     put_bits(&s->pb, 17, 1); /* GBSC */
293
294     if(s->h263_slice_structured){
295         put_bits(&s->pb, 1, 1);
296
297         ff_h263_encode_mba(s);
298
299         if(s->mb_num > 1583)
300             put_bits(&s->pb, 1, 1);
301         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
302         put_bits(&s->pb, 1, 1);
303         put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
304     }else{
305         int gob_number= mb_line / s->gob_index;
306
307         put_bits(&s->pb, 5, gob_number); /* GN */
308         put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
309         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
310     }
311 }
312
313 /**
314  * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
315  */
316 void ff_clean_h263_qscales(MpegEncContext *s){
317     int i;
318     int8_t * const qscale_table= s->current_picture.qscale_table;
319
320     ff_init_qscale_tab(s);
321
322     for(i=1; i<s->mb_num; i++){
323         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
324             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
325     }
326     for(i=s->mb_num-2; i>=0; i--){
327         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
328             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
329     }
330
331     if(s->codec_id != CODEC_ID_H263P){
332         for(i=1; i<s->mb_num; i++){
333             int mb_xy= s->mb_index2xy[i];
334
335             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
336                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
337             }
338         }
339     }
340 }
341
342 #endif //CONFIG_ENCODERS
343
344 void ff_h263_update_motion_val(MpegEncContext * s){
345     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
346                //FIXME a lot of that is only needed for !low_delay
347     const int wrap = s->b8_stride;
348     const int xy = s->block_index[0];
349
350     s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
351
352     if(s->mv_type != MV_TYPE_8X8){
353         int motion_x, motion_y;
354         if (s->mb_intra) {
355             motion_x = 0;
356             motion_y = 0;
357         } else if (s->mv_type == MV_TYPE_16X16) {
358             motion_x = s->mv[0][0][0];
359             motion_y = s->mv[0][0][1];
360         } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
361             int i;
362             motion_x = s->mv[0][0][0] + s->mv[0][1][0];
363             motion_y = s->mv[0][0][1] + s->mv[0][1][1];
364             motion_x = (motion_x>>1) | (motion_x&1);
365             for(i=0; i<2; i++){
366                 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
367                 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
368             }
369             s->current_picture.ref_index[0][xy           ]=
370             s->current_picture.ref_index[0][xy        + 1]= s->field_select[0][0];
371             s->current_picture.ref_index[0][xy + wrap    ]=
372             s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
373         }
374
375         /* no update if 8X8 because it has been done during parsing */
376         s->current_picture.motion_val[0][xy][0] = motion_x;
377         s->current_picture.motion_val[0][xy][1] = motion_y;
378         s->current_picture.motion_val[0][xy + 1][0] = motion_x;
379         s->current_picture.motion_val[0][xy + 1][1] = motion_y;
380         s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
381         s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
382         s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
383         s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
384     }
385
386     if(s->encoding){ //FIXME encoding MUST be cleaned up
387         if (s->mv_type == MV_TYPE_8X8)
388             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
389         else if(s->mb_intra)
390             s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
391         else
392             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
393     }
394 }
395
396 #if CONFIG_ENCODERS
397
398 static const int dquant_code[5]= {1,0,9,2,3};
399
400 /**
401  * encodes a 8x8 block.
402  * @param block the 8x8 block
403  * @param n block index (0-3 are luma, 4-5 are chroma)
404  */
405 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
406 {
407     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
408     RLTable *rl;
409
410     rl = &ff_h263_rl_inter;
411     if (s->mb_intra && !s->h263_aic) {
412         /* DC coef */
413         level = block[0];
414         /* 255 cannot be represented, so we clamp */
415         if (level > 254) {
416             level = 254;
417             block[0] = 254;
418         }
419         /* 0 cannot be represented also */
420         else if (level < 1) {
421             level = 1;
422             block[0] = 1;
423         }
424         if (level == 128) //FIXME check rv10
425             put_bits(&s->pb, 8, 0xff);
426         else
427             put_bits(&s->pb, 8, level);
428         i = 1;
429     } else {
430         i = 0;
431         if (s->h263_aic && s->mb_intra)
432             rl = &rl_intra_aic;
433
434         if(s->alt_inter_vlc && !s->mb_intra){
435             int aic_vlc_bits=0;
436             int inter_vlc_bits=0;
437             int wrong_pos=-1;
438             int aic_code;
439
440             last_index = s->block_last_index[n];
441             last_non_zero = i - 1;
442             for (; i <= last_index; i++) {
443                 j = s->intra_scantable.permutated[i];
444                 level = block[j];
445                 if (level) {
446                     run = i - last_non_zero - 1;
447                     last = (i == last_index);
448
449                     if(level<0) level= -level;
450
451                     code = get_rl_index(rl, last, run, level);
452                     aic_code = get_rl_index(&rl_intra_aic, last, run, level);
453                     inter_vlc_bits += rl->table_vlc[code][1]+1;
454                     aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
455
456                     if (code == rl->n) {
457                         inter_vlc_bits += 1+6+8-1;
458                     }
459                     if (aic_code == rl_intra_aic.n) {
460                         aic_vlc_bits += 1+6+8-1;
461                         wrong_pos += run + 1;
462                     }else
463                         wrong_pos += wrong_run[aic_code];
464                     last_non_zero = i;
465                 }
466             }
467             i = 0;
468             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
469                 rl = &rl_intra_aic;
470         }
471     }
472
473     /* AC coefs */
474     last_index = s->block_last_index[n];
475     last_non_zero = i - 1;
476     for (; i <= last_index; i++) {
477         j = s->intra_scantable.permutated[i];
478         level = block[j];
479         if (level) {
480             run = i - last_non_zero - 1;
481             last = (i == last_index);
482             sign = 0;
483             slevel = level;
484             if (level < 0) {
485                 sign = 1;
486                 level = -level;
487             }
488             code = get_rl_index(rl, last, run, level);
489             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
490             if (code == rl->n) {
491               if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
492                 put_bits(&s->pb, 1, last);
493                 put_bits(&s->pb, 6, run);
494
495                 assert(slevel != 0);
496
497                 if(level < 128)
498                     put_sbits(&s->pb, 8, slevel);
499                 else{
500                     put_bits(&s->pb, 8, 128);
501                     put_sbits(&s->pb, 5, slevel);
502                     put_sbits(&s->pb, 6, slevel>>5);
503                 }
504               }else{
505                     ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
506               }
507             } else {
508                 put_bits(&s->pb, 1, sign);
509             }
510             last_non_zero = i;
511         }
512     }
513 }
514
515 /* Encode MV differences on H.263+ with Unrestricted MV mode */
516 static void h263p_encode_umotion(MpegEncContext * s, int val)
517 {
518     short sval = 0;
519     short i = 0;
520     short n_bits = 0;
521     short temp_val;
522     int code = 0;
523     int tcode;
524
525     if ( val == 0)
526         put_bits(&s->pb, 1, 1);
527     else if (val == 1)
528         put_bits(&s->pb, 3, 0);
529     else if (val == -1)
530         put_bits(&s->pb, 3, 2);
531     else {
532
533         sval = ((val < 0) ? (short)(-val):(short)val);
534         temp_val = sval;
535
536         while (temp_val != 0) {
537             temp_val = temp_val >> 1;
538             n_bits++;
539         }
540
541         i = n_bits - 1;
542         while (i > 0) {
543             tcode = (sval & (1 << (i-1))) >> (i-1);
544             tcode = (tcode << 1) | 1;
545             code = (code << 2) | tcode;
546             i--;
547         }
548         code = ((code << 1) | (val < 0)) << 1;
549         put_bits(&s->pb, (2*n_bits)+1, code);
550     }
551 }
552
553 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
554 {
555     int x, y, wrap, a, c, pred_dc;
556     int16_t *dc_val;
557
558     /* find prediction */
559     if (n < 4) {
560         x = 2 * s->mb_x + (n & 1);
561         y = 2 * s->mb_y + ((n & 2) >> 1);
562         wrap = s->b8_stride;
563         dc_val = s->dc_val[0];
564     } else {
565         x = s->mb_x;
566         y = s->mb_y;
567         wrap = s->mb_stride;
568         dc_val = s->dc_val[n - 4 + 1];
569     }
570     /* B C
571      * A X
572      */
573     a = dc_val[(x - 1) + (y) * wrap];
574     c = dc_val[(x) + (y - 1) * wrap];
575
576     /* No prediction outside GOB boundary */
577     if(s->first_slice_line && n!=3){
578         if(n!=2) c= 1024;
579         if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
580     }
581     /* just DC prediction */
582     if (a != 1024 && c != 1024)
583         pred_dc = (a + c) >> 1;
584     else if (a != 1024)
585         pred_dc = a;
586     else
587         pred_dc = c;
588
589     /* we assume pred is positive */
590     *dc_val_ptr = &dc_val[x + y * wrap];
591     return pred_dc;
592 }
593
594 void h263_encode_mb(MpegEncContext * s,
595                     DCTELEM block[6][64],
596                     int motion_x, int motion_y)
597 {
598     int cbpc, cbpy, i, cbp, pred_x, pred_y;
599     int16_t pred_dc;
600     int16_t rec_intradc[6];
601     int16_t *dc_ptr[6];
602     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
603
604     if (!s->mb_intra) {
605         /* compute cbp */
606         cbp= get_p_cbp(s, block, motion_x, motion_y);
607
608         if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
609             /* skip macroblock */
610             put_bits(&s->pb, 1, 1);
611             if(interleaved_stats){
612                 s->misc_bits++;
613                 s->last_bits++;
614             }
615             s->skip_count++;
616
617             return;
618         }
619         put_bits(&s->pb, 1, 0);         /* mb coded */
620
621         cbpc = cbp & 3;
622         cbpy = cbp >> 2;
623         if(s->alt_inter_vlc==0 || cbpc!=3)
624             cbpy ^= 0xF;
625         if(s->dquant) cbpc+= 8;
626         if(s->mv_type==MV_TYPE_16X16){
627             put_bits(&s->pb,
628                     ff_h263_inter_MCBPC_bits[cbpc],
629                     ff_h263_inter_MCBPC_code[cbpc]);
630
631             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
632             if(s->dquant)
633                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
634
635             if(interleaved_stats){
636                 s->misc_bits+= get_bits_diff(s);
637             }
638
639             /* motion vectors: 16x16 mode */
640             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
641
642             if (!s->umvplus) {
643                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
644                                                 motion_y - pred_y, 1);
645             }
646             else {
647                 h263p_encode_umotion(s, motion_x - pred_x);
648                 h263p_encode_umotion(s, motion_y - pred_y);
649                 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
650                     /* To prevent Start Code emulation */
651                     put_bits(&s->pb,1,1);
652             }
653         }else{
654             put_bits(&s->pb,
655                     ff_h263_inter_MCBPC_bits[cbpc+16],
656                     ff_h263_inter_MCBPC_code[cbpc+16]);
657             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
658             if(s->dquant)
659                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
660
661             if(interleaved_stats){
662                 s->misc_bits+= get_bits_diff(s);
663             }
664
665             for(i=0; i<4; i++){
666                 /* motion vectors: 8x8 mode*/
667                 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
668
669                 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
670                 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
671                 if (!s->umvplus) {
672                     ff_h263_encode_motion_vector(s, motion_x - pred_x,
673                                                     motion_y - pred_y, 1);
674                 }
675                 else {
676                     h263p_encode_umotion(s, motion_x - pred_x);
677                     h263p_encode_umotion(s, motion_y - pred_y);
678                     if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
679                         /* To prevent Start Code emulation */
680                         put_bits(&s->pb,1,1);
681                 }
682             }
683         }
684
685         if(interleaved_stats){
686             s->mv_bits+= get_bits_diff(s);
687         }
688     } else {
689         assert(s->mb_intra);
690
691         cbp = 0;
692         if (s->h263_aic) {
693             /* Predict DC */
694             for(i=0; i<6; i++) {
695                 int16_t level = block[i][0];
696                 int scale;
697
698                 if(i<4) scale= s->y_dc_scale;
699                 else    scale= s->c_dc_scale;
700
701                 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
702                 level -= pred_dc;
703                 /* Quant */
704                 if (level >= 0)
705                     level = (level + (scale>>1))/scale;
706                 else
707                     level = (level - (scale>>1))/scale;
708
709                 /* AIC can change CBP */
710                 if (level == 0 && s->block_last_index[i] == 0)
711                     s->block_last_index[i] = -1;
712
713                 if(!s->modified_quant){
714                     if (level < -127)
715                         level = -127;
716                     else if (level > 127)
717                         level = 127;
718                 }
719
720                 block[i][0] = level;
721                 /* Reconstruction */
722                 rec_intradc[i] = scale*level + pred_dc;
723                 /* Oddify */
724                 rec_intradc[i] |= 1;
725                 //if ((rec_intradc[i] % 2) == 0)
726                 //    rec_intradc[i]++;
727                 /* Clipping */
728                 if (rec_intradc[i] < 0)
729                     rec_intradc[i] = 0;
730                 else if (rec_intradc[i] > 2047)
731                     rec_intradc[i] = 2047;
732
733                 /* Update AC/DC tables */
734                 *dc_ptr[i] = rec_intradc[i];
735                 if (s->block_last_index[i] >= 0)
736                     cbp |= 1 << (5 - i);
737             }
738         }else{
739             for(i=0; i<6; i++) {
740                 /* compute cbp */
741                 if (s->block_last_index[i] >= 1)
742                     cbp |= 1 << (5 - i);
743             }
744         }
745
746         cbpc = cbp & 3;
747         if (s->pict_type == FF_I_TYPE) {
748             if(s->dquant) cbpc+=4;
749             put_bits(&s->pb,
750                 ff_h263_intra_MCBPC_bits[cbpc],
751                 ff_h263_intra_MCBPC_code[cbpc]);
752         } else {
753             if(s->dquant) cbpc+=8;
754             put_bits(&s->pb, 1, 0);     /* mb coded */
755             put_bits(&s->pb,
756                 ff_h263_inter_MCBPC_bits[cbpc + 4],
757                 ff_h263_inter_MCBPC_code[cbpc + 4]);
758         }
759         if (s->h263_aic) {
760             /* XXX: currently, we do not try to use ac prediction */
761             put_bits(&s->pb, 1, 0);     /* no AC prediction */
762         }
763         cbpy = cbp >> 2;
764         put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
765         if(s->dquant)
766             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
767
768         if(interleaved_stats){
769             s->misc_bits+= get_bits_diff(s);
770         }
771     }
772
773     for(i=0; i<6; i++) {
774         /* encode each block */
775         h263_encode_block(s, block[i], i);
776
777         /* Update INTRADC for decoding */
778         if (s->h263_aic && s->mb_intra) {
779             block[i][0] = rec_intradc[i];
780
781         }
782     }
783
784     if(interleaved_stats){
785         if (!s->mb_intra) {
786             s->p_tex_bits+= get_bits_diff(s);
787             s->f_count++;
788         }else{
789             s->i_tex_bits+= get_bits_diff(s);
790             s->i_count++;
791         }
792     }
793 }
794 #endif
795
796 void ff_h263_loop_filter(MpegEncContext * s){
797     int qp_c;
798     const int linesize  = s->linesize;
799     const int uvlinesize= s->uvlinesize;
800     const int xy = s->mb_y * s->mb_stride + s->mb_x;
801     uint8_t *dest_y = s->dest[0];
802     uint8_t *dest_cb= s->dest[1];
803     uint8_t *dest_cr= s->dest[2];
804
805 //    if(s->pict_type==FF_B_TYPE && !s->readable) return;
806
807     /*
808        Diag Top
809        Left Center
810     */
811     if(!IS_SKIP(s->current_picture.mb_type[xy])){
812         qp_c= s->qscale;
813         s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
814         s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
815     }else
816         qp_c= 0;
817
818     if(s->mb_y){
819         int qp_dt, qp_tt, qp_tc;
820
821         if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
822             qp_tt=0;
823         else
824             qp_tt= s->current_picture.qscale_table[xy-s->mb_stride];
825
826         if(qp_c)
827             qp_tc= qp_c;
828         else
829             qp_tc= qp_tt;
830
831         if(qp_tc){
832             const int chroma_qp= s->chroma_qscale_table[qp_tc];
833             s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
834             s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
835
836             s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
837             s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
838         }
839
840         if(qp_tt)
841             s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_tt);
842
843         if(s->mb_x){
844             if(qp_tt || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
845                 qp_dt= qp_tt;
846             else
847                 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
848
849             if(qp_dt){
850                 const int chroma_qp= s->chroma_qscale_table[qp_dt];
851                 s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
852                 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
853                 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
854             }
855         }
856     }
857
858     if(qp_c){
859         s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
860         if(s->mb_y + 1 == s->mb_height)
861             s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
862     }
863
864     if(s->mb_x){
865         int qp_lc;
866         if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
867             qp_lc= qp_c;
868         else
869             qp_lc= s->current_picture.qscale_table[xy-1];
870
871         if(qp_lc){
872             s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
873             if(s->mb_y + 1 == s->mb_height){
874                 const int chroma_qp= s->chroma_qscale_table[qp_lc];
875                 s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
876                 s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
877                 s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
878             }
879         }
880     }
881 }
882
883 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
884 {
885     int x, y, wrap, a, c, pred_dc, scale, i;
886     int16_t *dc_val, *ac_val, *ac_val1;
887
888     /* find prediction */
889     if (n < 4) {
890         x = 2 * s->mb_x + (n & 1);
891         y = 2 * s->mb_y + (n>> 1);
892         wrap = s->b8_stride;
893         dc_val = s->dc_val[0];
894         ac_val = s->ac_val[0][0];
895         scale = s->y_dc_scale;
896     } else {
897         x = s->mb_x;
898         y = s->mb_y;
899         wrap = s->mb_stride;
900         dc_val = s->dc_val[n - 4 + 1];
901         ac_val = s->ac_val[n - 4 + 1][0];
902         scale = s->c_dc_scale;
903     }
904
905     ac_val += ((y) * wrap + (x)) * 16;
906     ac_val1 = ac_val;
907
908     /* B C
909      * A X
910      */
911     a = dc_val[(x - 1) + (y) * wrap];
912     c = dc_val[(x) + (y - 1) * wrap];
913
914     /* No prediction outside GOB boundary */
915     if(s->first_slice_line && n!=3){
916         if(n!=2) c= 1024;
917         if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
918     }
919
920     if (s->ac_pred) {
921         pred_dc = 1024;
922         if (s->h263_aic_dir) {
923             /* left prediction */
924             if (a != 1024) {
925                 ac_val -= 16;
926                 for(i=1;i<8;i++) {
927                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
928                 }
929                 pred_dc = a;
930             }
931         } else {
932             /* top prediction */
933             if (c != 1024) {
934                 ac_val -= 16 * wrap;
935                 for(i=1;i<8;i++) {
936                     block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
937                 }
938                 pred_dc = c;
939             }
940         }
941     } else {
942         /* just DC prediction */
943         if (a != 1024 && c != 1024)
944             pred_dc = (a + c) >> 1;
945         else if (a != 1024)
946             pred_dc = a;
947         else
948             pred_dc = c;
949     }
950
951     /* we assume pred is positive */
952     block[0]=block[0]*scale + pred_dc;
953
954     if (block[0] < 0)
955         block[0] = 0;
956     else
957         block[0] |= 1;
958
959     /* Update AC/DC tables */
960     dc_val[(x) + (y) * wrap] = block[0];
961
962     /* left copy */
963     for(i=1;i<8;i++)
964         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
965     /* top copy */
966     for(i=1;i<8;i++)
967         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
968 }
969
970 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
971                         int *px, int *py)
972 {
973     int wrap;
974     int16_t *A, *B, *C, (*mot_val)[2];
975     static const int off[4]= {2, 1, 1, -1};
976
977     wrap = s->b8_stride;
978     mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
979
980     A = mot_val[ - 1];
981     /* special case for first (slice) line */
982     if (s->first_slice_line && block<3) {
983         // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
984         // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
985         if(block==0){ //most common case
986             if(s->mb_x  == s->resync_mb_x){ //rare
987                 *px= *py = 0;
988             }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
989                 C = mot_val[off[block] - wrap];
990                 if(s->mb_x==0){
991                     *px = C[0];
992                     *py = C[1];
993                 }else{
994                     *px = mid_pred(A[0], 0, C[0]);
995                     *py = mid_pred(A[1], 0, C[1]);
996                 }
997             }else{
998                 *px = A[0];
999                 *py = A[1];
1000             }
1001         }else if(block==1){
1002             if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1003                 C = mot_val[off[block] - wrap];
1004                 *px = mid_pred(A[0], 0, C[0]);
1005                 *py = mid_pred(A[1], 0, C[1]);
1006             }else{
1007                 *px = A[0];
1008                 *py = A[1];
1009             }
1010         }else{ /* block==2*/
1011             B = mot_val[ - wrap];
1012             C = mot_val[off[block] - wrap];
1013             if(s->mb_x == s->resync_mb_x) //rare
1014                 A[0]=A[1]=0;
1015
1016             *px = mid_pred(A[0], B[0], C[0]);
1017             *py = mid_pred(A[1], B[1], C[1]);
1018         }
1019     } else {
1020         B = mot_val[ - wrap];
1021         C = mot_val[off[block] - wrap];
1022         *px = mid_pred(A[0], B[0], C[0]);
1023         *py = mid_pred(A[1], B[1], C[1]);
1024     }
1025     return *mot_val;
1026 }
1027
1028 #if CONFIG_ENCODERS
1029
1030 /***************************************************/
1031 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1032 {
1033     int range, l, bit_size, sign, code, bits;
1034
1035     if (val == 0) {
1036         /* zero vector */
1037         code = 0;
1038         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1039     } else {
1040         bit_size = f_code - 1;
1041         range = 1 << bit_size;
1042         /* modulo encoding */
1043         l= INT_BIT - 6 - bit_size;
1044         val = (val<<l)>>l;
1045         sign = val>>31;
1046         val= (val^sign)-sign;
1047         sign&=1;
1048
1049         val--;
1050         code = (val >> bit_size) + 1;
1051         bits = val & (range - 1);
1052
1053         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1054         if (bit_size > 0) {
1055             put_bits(&s->pb, bit_size, bits);
1056         }
1057     }
1058 }
1059
1060 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1061 {
1062     int f_code;
1063     int mv;
1064
1065     for(f_code=1; f_code<=MAX_FCODE; f_code++){
1066         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1067             int len;
1068
1069             if(mv==0) len= mvtab[0][1];
1070             else{
1071                 int val, bit_size, code;
1072
1073                 bit_size = f_code - 1;
1074
1075                 val=mv;
1076                 if (val < 0)
1077                     val = -val;
1078                 val--;
1079                 code = (val >> bit_size) + 1;
1080                 if(code<33){
1081                     len= mvtab[code][1] + 1 + bit_size;
1082                 }else{
1083                     len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1084                 }
1085             }
1086
1087             mv_penalty[f_code][mv+MAX_MV]= len;
1088         }
1089     }
1090
1091     for(f_code=MAX_FCODE; f_code>0; f_code--){
1092         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1093             fcode_tab[mv+MAX_MV]= f_code;
1094         }
1095     }
1096
1097     for(mv=0; mv<MAX_MV*2+1; mv++){
1098         umv_fcode_tab[mv]= 1;
1099     }
1100 }
1101
1102 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1103     int slevel, run, last;
1104
1105     assert(MAX_LEVEL >= 64);
1106     assert(MAX_RUN   >= 63);
1107
1108     for(slevel=-64; slevel<64; slevel++){
1109         if(slevel==0) continue;
1110         for(run=0; run<64; run++){
1111             for(last=0; last<=1; last++){
1112                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1113                 int level= slevel < 0 ? -slevel : slevel;
1114                 int sign= slevel < 0 ? 1 : 0;
1115                 int bits, len, code;
1116
1117                 len_tab[index]= 100;
1118
1119                 /* ESC0 */
1120                 code= get_rl_index(rl, last, run, level);
1121                 bits= rl->table_vlc[code][0];
1122                 len=  rl->table_vlc[code][1];
1123                 bits=bits*2+sign; len++;
1124
1125                 if(code!=rl->n && len < len_tab[index]){
1126                     if(bits_tab) bits_tab[index]= bits;
1127                     len_tab [index]= len;
1128                 }
1129                 /* ESC */
1130                 bits= rl->table_vlc[rl->n][0];
1131                 len = rl->table_vlc[rl->n][1];
1132                 bits=bits*2+last; len++;
1133                 bits=bits*64+run; len+=6;
1134                 bits=bits*256+(level&0xff); len+=8;
1135
1136                 if(len < len_tab[index]){
1137                     if(bits_tab) bits_tab[index]= bits;
1138                     len_tab [index]= len;
1139                 }
1140             }
1141         }
1142     }
1143 }
1144
1145 void h263_encode_init(MpegEncContext *s)
1146 {
1147     static int done = 0;
1148
1149     if (!done) {
1150         done = 1;
1151
1152         init_rl(&ff_h263_rl_inter, static_rl_table_store[0]);
1153         init_rl(&rl_intra_aic, static_rl_table_store[1]);
1154
1155         init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
1156         init_uni_h263_rl_tab(&ff_h263_rl_inter    , NULL, uni_h263_inter_rl_len);
1157
1158         init_mv_penalty_and_fcode(s);
1159     }
1160     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1161
1162     s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
1163     s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
1164     if(s->h263_aic){
1165         s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
1166         s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
1167     }
1168     s->ac_esc_length= 7+1+6+8;
1169
1170     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1171     switch(s->codec_id){
1172     case CODEC_ID_MPEG4:
1173         s->fcode_tab= fcode_tab;
1174         break;
1175     case CODEC_ID_H263P:
1176         if(s->umvplus)
1177             s->fcode_tab= umv_fcode_tab;
1178         if(s->modified_quant){
1179             s->min_qcoeff= -2047;
1180             s->max_qcoeff=  2047;
1181         }else{
1182             s->min_qcoeff= -127;
1183             s->max_qcoeff=  127;
1184         }
1185         break;
1186         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1187     case CODEC_ID_FLV1:
1188         if (s->h263_flv > 1) {
1189             s->min_qcoeff= -1023;
1190             s->max_qcoeff=  1023;
1191         } else {
1192             s->min_qcoeff= -127;
1193             s->max_qcoeff=  127;
1194         }
1195         s->y_dc_scale_table=
1196         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1197         break;
1198     default: //nothing needed - default table already set in mpegvideo.c
1199         s->min_qcoeff= -127;
1200         s->max_qcoeff=  127;
1201         s->y_dc_scale_table=
1202         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1203     }
1204 }
1205 #endif //CONFIG_ENCODERS
1206
1207 /***********************************************/
1208 /* decoding */
1209
1210 VLC ff_h263_intra_MCBPC_vlc;
1211 VLC ff_h263_inter_MCBPC_vlc;
1212 VLC ff_h263_cbpy_vlc;
1213 static VLC mv_vlc;
1214 static VLC h263_mbtype_b_vlc;
1215 static VLC cbpc_b_vlc;
1216
1217 /* init vlcs */
1218
1219 /* XXX: find a better solution to handle static init */
1220 void h263_decode_init_vlc(MpegEncContext *s)
1221 {
1222     static int done = 0;
1223
1224     if (!done) {
1225         done = 1;
1226
1227         INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
1228                  ff_h263_intra_MCBPC_bits, 1, 1,
1229                  ff_h263_intra_MCBPC_code, 1, 1, 72);
1230         INIT_VLC_STATIC(&ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
1231                  ff_h263_inter_MCBPC_bits, 1, 1,
1232                  ff_h263_inter_MCBPC_code, 1, 1, 198);
1233         INIT_VLC_STATIC(&ff_h263_cbpy_vlc, CBPY_VLC_BITS, 16,
1234                  &ff_h263_cbpy_tab[0][1], 2, 1,
1235                  &ff_h263_cbpy_tab[0][0], 2, 1, 64);
1236         INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33,
1237                  &mvtab[0][1], 2, 1,
1238                  &mvtab[0][0], 2, 1, 538);
1239         init_rl(&ff_h263_rl_inter, static_rl_table_store[0]);
1240         init_rl(&rl_intra_aic, static_rl_table_store[1]);
1241         INIT_VLC_RL(ff_h263_rl_inter, 554);
1242         INIT_VLC_RL(rl_intra_aic, 554);
1243         INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
1244                  &h263_mbtype_b_tab[0][1], 2, 1,
1245                  &h263_mbtype_b_tab[0][0], 2, 1, 80);
1246         INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
1247                  &cbpc_b_tab[0][1], 2, 1,
1248                  &cbpc_b_tab[0][0], 2, 1, 8);
1249     }
1250 }
1251
1252 /**
1253  * Get the GOB height based on picture height.
1254  */
1255 int ff_h263_get_gob_height(MpegEncContext *s){
1256     if (s->height <= 400)
1257         return 1;
1258     else if (s->height <= 800)
1259         return  2;
1260     else
1261         return 4;
1262 }
1263
1264 int ff_h263_decode_mba(MpegEncContext *s)
1265 {
1266     int i, mb_pos;
1267
1268     for(i=0; i<6; i++){
1269         if(s->mb_num-1 <= ff_mba_max[i]) break;
1270     }
1271     mb_pos= get_bits(&s->gb, ff_mba_length[i]);
1272     s->mb_x= mb_pos % s->mb_width;
1273     s->mb_y= mb_pos / s->mb_width;
1274
1275     return mb_pos;
1276 }
1277
1278 void ff_h263_encode_mba(MpegEncContext *s)
1279 {
1280     int i, mb_pos;
1281
1282     for(i=0; i<6; i++){
1283         if(s->mb_num-1 <= ff_mba_max[i]) break;
1284     }
1285     mb_pos= s->mb_x + s->mb_width*s->mb_y;
1286     put_bits(&s->pb, ff_mba_length[i], mb_pos);
1287 }
1288
1289 /**
1290  * decodes the group of blocks header or slice header.
1291  * @return <0 if an error occurred
1292  */
1293 static int h263_decode_gob_header(MpegEncContext *s)
1294 {
1295     unsigned int val, gfid, gob_number;
1296     int left;
1297
1298     /* Check for GOB Start Code */
1299     val = show_bits(&s->gb, 16);
1300     if(val)
1301         return -1;
1302
1303         /* We have a GBSC probably with GSTUFF */
1304     skip_bits(&s->gb, 16); /* Drop the zeros */
1305     left= get_bits_left(&s->gb);
1306     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
1307     for(;left>13; left--){
1308         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
1309     }
1310     if(left<=13)
1311         return -1;
1312
1313     if(s->h263_slice_structured){
1314         if(get_bits1(&s->gb)==0)
1315             return -1;
1316
1317         ff_h263_decode_mba(s);
1318
1319         if(s->mb_num > 1583)
1320             if(get_bits1(&s->gb)==0)
1321                 return -1;
1322
1323         s->qscale = get_bits(&s->gb, 5); /* SQUANT */
1324         if(get_bits1(&s->gb)==0)
1325             return -1;
1326         gfid = get_bits(&s->gb, 2); /* GFID */
1327     }else{
1328         gob_number = get_bits(&s->gb, 5); /* GN */
1329         s->mb_x= 0;
1330         s->mb_y= s->gob_index* gob_number;
1331         gfid = get_bits(&s->gb, 2); /* GFID */
1332         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1333     }
1334
1335     if(s->mb_y >= s->mb_height)
1336         return -1;
1337
1338     if(s->qscale==0)
1339         return -1;
1340
1341     return 0;
1342 }
1343
1344 static inline void memsetw(short *tab, int val, int n)
1345 {
1346     int i;
1347     for(i=0;i<n;i++)
1348         tab[i] = val;
1349 }
1350
1351 /**
1352  * finds the next resync_marker
1353  * @param p pointer to buffer to scan
1354  * @param end pointer to the end of the buffer
1355  * @return pointer to the next resync_marker, or end if none was found
1356  */
1357 const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end)
1358 {
1359     assert(p < end);
1360
1361     end-=2;
1362     p++;
1363     for(;p<end; p+=2){
1364         if(!*p){
1365             if     (!p[-1] && p[1]) return p - 1;
1366             else if(!p[ 1] && p[2]) return p;
1367         }
1368     }
1369     return end+2;
1370 }
1371
1372 /**
1373  * decodes the group of blocks / video packet header.
1374  * @return bit position of the resync_marker, or <0 if none was found
1375  */
1376 int ff_h263_resync(MpegEncContext *s){
1377     int left, pos, ret;
1378
1379     if(s->codec_id==CODEC_ID_MPEG4){
1380         skip_bits1(&s->gb);
1381         align_get_bits(&s->gb);
1382     }
1383
1384     if(show_bits(&s->gb, 16)==0){
1385         pos= get_bits_count(&s->gb);
1386         if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4)
1387             ret= mpeg4_decode_video_packet_header(s);
1388         else
1389             ret= h263_decode_gob_header(s);
1390         if(ret>=0)
1391             return pos;
1392     }
1393     //OK, it's not where it is supposed to be ...
1394     s->gb= s->last_resync_gb;
1395     align_get_bits(&s->gb);
1396     left= get_bits_left(&s->gb);
1397
1398     for(;left>16+1+5+5; left-=8){
1399         if(show_bits(&s->gb, 16)==0){
1400             GetBitContext bak= s->gb;
1401
1402             pos= get_bits_count(&s->gb);
1403             if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4)
1404                 ret= mpeg4_decode_video_packet_header(s);
1405             else
1406                 ret= h263_decode_gob_header(s);
1407             if(ret>=0)
1408                 return pos;
1409
1410             s->gb= bak;
1411         }
1412         skip_bits(&s->gb, 8);
1413     }
1414
1415     return -1;
1416 }
1417
1418 int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
1419 {
1420     int code, val, sign, shift, l;
1421     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
1422
1423     if (code == 0)
1424         return pred;
1425     if (code < 0)
1426         return 0xffff;
1427
1428     sign = get_bits1(&s->gb);
1429     shift = f_code - 1;
1430     val = code;
1431     if (shift) {
1432         val = (val - 1) << shift;
1433         val |= get_bits(&s->gb, shift);
1434         val++;
1435     }
1436     if (sign)
1437         val = -val;
1438     val += pred;
1439
1440     /* modulo decoding */
1441     if (!s->h263_long_vectors) {
1442         l = INT_BIT - 5 - f_code;
1443         val = (val<<l)>>l;
1444     } else {
1445         /* horrible h263 long vector mode */
1446         if (pred < -31 && val < -63)
1447             val += 64;
1448         if (pred > 32 && val > 63)
1449             val -= 64;
1450
1451     }
1452     return val;
1453 }
1454
1455
1456 /* Decodes RVLC of H.263+ UMV */
1457 static int h263p_decode_umotion(MpegEncContext * s, int pred)
1458 {
1459    int code = 0, sign;
1460
1461    if (get_bits1(&s->gb)) /* Motion difference = 0 */
1462       return pred;
1463
1464    code = 2 + get_bits1(&s->gb);
1465
1466    while (get_bits1(&s->gb))
1467    {
1468       code <<= 1;
1469       code += get_bits1(&s->gb);
1470    }
1471    sign = code & 1;
1472    code >>= 1;
1473
1474    code = (sign) ? (pred - code) : (pred + code);
1475    dprintf(s->avctx,"H.263+ UMV Motion = %d\n", code);
1476    return code;
1477
1478 }
1479
1480 /**
1481  * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
1482  */
1483 static void preview_obmc(MpegEncContext *s){
1484     GetBitContext gb= s->gb;
1485
1486     int cbpc, i, pred_x, pred_y, mx, my;
1487     int16_t *mot_val;
1488     const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
1489     const int stride= s->b8_stride*2;
1490
1491     for(i=0; i<4; i++)
1492         s->block_index[i]+= 2;
1493     for(i=4; i<6; i++)
1494         s->block_index[i]+= 1;
1495     s->mb_x++;
1496
1497     assert(s->pict_type == FF_P_TYPE);
1498
1499     do{
1500         if (get_bits1(&s->gb)) {
1501             /* skip mb */
1502             mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
1503             mot_val[0       ]= mot_val[2       ]=
1504             mot_val[0+stride]= mot_val[2+stride]= 0;
1505             mot_val[1       ]= mot_val[3       ]=
1506             mot_val[1+stride]= mot_val[3+stride]= 0;
1507
1508             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
1509             goto end;
1510         }
1511         cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1512     }while(cbpc == 20);
1513
1514     if(cbpc & 4){
1515         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
1516     }else{
1517         get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1518         if (cbpc & 8) {
1519             if(s->modified_quant){
1520                 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
1521                 else                  skip_bits(&s->gb, 5);
1522             }else
1523                 skip_bits(&s->gb, 2);
1524         }
1525
1526         if ((cbpc & 16) == 0) {
1527                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
1528                 /* 16x16 motion prediction */
1529                 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1530                 if (s->umvplus)
1531                    mx = h263p_decode_umotion(s, pred_x);
1532                 else
1533                    mx = h263_decode_motion(s, pred_x, 1);
1534
1535                 if (s->umvplus)
1536                    my = h263p_decode_umotion(s, pred_y);
1537                 else
1538                    my = h263_decode_motion(s, pred_y, 1);
1539
1540                 mot_val[0       ]= mot_val[2       ]=
1541                 mot_val[0+stride]= mot_val[2+stride]= mx;
1542                 mot_val[1       ]= mot_val[3       ]=
1543                 mot_val[1+stride]= mot_val[3+stride]= my;
1544         } else {
1545             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
1546             for(i=0;i<4;i++) {
1547                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1548                 if (s->umvplus)
1549                   mx = h263p_decode_umotion(s, pred_x);
1550                 else
1551                   mx = h263_decode_motion(s, pred_x, 1);
1552
1553                 if (s->umvplus)
1554                   my = h263p_decode_umotion(s, pred_y);
1555                 else
1556                   my = h263_decode_motion(s, pred_y, 1);
1557                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
1558                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1559                 mot_val[0] = mx;
1560                 mot_val[1] = my;
1561             }
1562         }
1563     }
1564 end:
1565
1566     for(i=0; i<4; i++)
1567         s->block_index[i]-= 2;
1568     for(i=4; i<6; i++)
1569         s->block_index[i]-= 1;
1570     s->mb_x--;
1571
1572     s->gb= gb;
1573 }
1574
1575 static void h263_decode_dquant(MpegEncContext *s){
1576     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
1577
1578     if(s->modified_quant){
1579         if(get_bits1(&s->gb))
1580             s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
1581         else
1582             s->qscale= get_bits(&s->gb, 5);
1583     }else
1584         s->qscale += quant_tab[get_bits(&s->gb, 2)];
1585     ff_set_qscale(s, s->qscale);
1586 }
1587
1588 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
1589                              int n, int coded)
1590 {
1591     int code, level, i, j, last, run;
1592     RLTable *rl = &ff_h263_rl_inter;
1593     const uint8_t *scan_table;
1594     GetBitContext gb= s->gb;
1595
1596     scan_table = s->intra_scantable.permutated;
1597     if (s->h263_aic && s->mb_intra) {
1598         rl = &rl_intra_aic;
1599         i = 0;
1600         if (s->ac_pred) {
1601             if (s->h263_aic_dir)
1602                 scan_table = s->intra_v_scantable.permutated; /* left */
1603             else
1604                 scan_table = s->intra_h_scantable.permutated; /* top */
1605         }
1606     } else if (s->mb_intra) {
1607         /* DC coef */
1608         if(s->codec_id == CODEC_ID_RV10){
1609 #if CONFIG_RV10_DECODER
1610           if (s->rv10_version == 3 && s->pict_type == FF_I_TYPE) {
1611             int component, diff;
1612             component = (n <= 3 ? 0 : n - 4 + 1);
1613             level = s->last_dc[component];
1614             if (s->rv10_first_dc_coded[component]) {
1615                 diff = rv_decode_dc(s, n);
1616                 if (diff == 0xffff)
1617                     return -1;
1618                 level += diff;
1619                 level = level & 0xff; /* handle wrap round */
1620                 s->last_dc[component] = level;
1621             } else {
1622                 s->rv10_first_dc_coded[component] = 1;
1623             }
1624           } else {
1625                 level = get_bits(&s->gb, 8);
1626                 if (level == 255)
1627                     level = 128;
1628           }
1629 #endif
1630         }else{
1631             level = get_bits(&s->gb, 8);
1632             if((level&0x7F) == 0){
1633                 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
1634                 if(s->error_recognition >= FF_ER_COMPLIANT)
1635                     return -1;
1636             }
1637             if (level == 255)
1638                 level = 128;
1639         }
1640         block[0] = level;
1641         i = 1;
1642     } else {
1643         i = 0;
1644     }
1645     if (!coded) {
1646         if (s->mb_intra && s->h263_aic)
1647             goto not_coded;
1648         s->block_last_index[n] = i - 1;
1649         return 0;
1650     }
1651 retry:
1652     for(;;) {
1653         code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
1654         if (code < 0){
1655             av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
1656             return -1;
1657         }
1658         if (code == rl->n) {
1659             /* escape */
1660             if (CONFIG_FLV_DECODER && s->h263_flv > 1) {
1661                 ff_flv2_decode_ac_esc(&s->gb, &level, &run, &last);
1662             } else {
1663                 last = get_bits1(&s->gb);
1664                 run = get_bits(&s->gb, 6);
1665                 level = (int8_t)get_bits(&s->gb, 8);
1666                 if(level == -128){
1667                     if (s->codec_id == CODEC_ID_RV10) {
1668                         /* XXX: should patch encoder too */
1669                         level = get_sbits(&s->gb, 12);
1670                     }else{
1671                         level = get_bits(&s->gb, 5);
1672                         level |= get_sbits(&s->gb, 6)<<5;
1673                     }
1674                 }
1675             }
1676         } else {
1677             run = rl->table_run[code];
1678             level = rl->table_level[code];
1679             last = code >= rl->last;
1680             if (get_bits1(&s->gb))
1681                 level = -level;
1682         }
1683         i += run;
1684         if (i >= 64){
1685             if(s->alt_inter_vlc && rl == &ff_h263_rl_inter && !s->mb_intra){
1686                 //Looks like a hack but no, it's the way it is supposed to work ...
1687                 rl = &rl_intra_aic;
1688                 i = 0;
1689                 s->gb= gb;
1690                 s->dsp.clear_block(block);
1691                 goto retry;
1692             }
1693             av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
1694             return -1;
1695         }
1696         j = scan_table[i];
1697         block[j] = level;
1698         if (last)
1699             break;
1700         i++;
1701     }
1702 not_coded:
1703     if (s->mb_intra && s->h263_aic) {
1704         h263_pred_acdc(s, block, n);
1705         i = 63;
1706     }
1707     s->block_last_index[n] = i;
1708     return 0;
1709 }
1710
1711 static int h263_skip_b_part(MpegEncContext *s, int cbp)
1712 {
1713     DECLARE_ALIGNED(16, DCTELEM, dblock[64]);
1714     int i, mbi;
1715
1716     /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly
1717      * but real value should be restored in order to be used later (in OBMC condition)
1718      */
1719     mbi = s->mb_intra;
1720     s->mb_intra = 0;
1721     for (i = 0; i < 6; i++) {
1722         if (h263_decode_block(s, dblock, i, cbp&32) < 0)
1723             return -1;
1724         cbp+=cbp;
1725     }
1726     s->mb_intra = mbi;
1727     return 0;
1728 }
1729
1730 static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)
1731 {
1732     int c, mv = 1;
1733
1734     if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame
1735         c = get_bits1(gb);
1736         if (pb_frame == 2 && c)
1737             mv = !get_bits1(gb);
1738     } else { // h.263 Annex M improved PB-frame
1739         mv = get_unary(gb, 0, 4) + 1;
1740         c = mv & 1;
1741         mv = !!(mv & 2);
1742     }
1743     if(c)
1744         *cbpb = get_bits(gb, 6);
1745     return mv;
1746 }
1747
1748 int ff_h263_decode_mb(MpegEncContext *s,
1749                       DCTELEM block[6][64])
1750 {
1751     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1752     int16_t *mot_val;
1753     const int xy= s->mb_x + s->mb_y * s->mb_stride;
1754     int cbpb = 0, pb_mv_count = 0;
1755
1756     assert(!s->h263_pred);
1757
1758     if (s->pict_type == FF_P_TYPE) {
1759         do{
1760             if (get_bits1(&s->gb)) {
1761                 /* skip mb */
1762                 s->mb_intra = 0;
1763                 for(i=0;i<6;i++)
1764                     s->block_last_index[i] = -1;
1765                 s->mv_dir = MV_DIR_FORWARD;
1766                 s->mv_type = MV_TYPE_16X16;
1767                 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
1768                 s->mv[0][0][0] = 0;
1769                 s->mv[0][0][1] = 0;
1770                 s->mb_skipped = !(s->obmc | s->loop_filter);
1771                 goto end;
1772             }
1773             cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1774             if (cbpc < 0){
1775                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1776                 return -1;
1777             }
1778         }while(cbpc == 20);
1779
1780         s->dsp.clear_blocks(s->block[0]);
1781
1782         dquant = cbpc & 8;
1783         s->mb_intra = ((cbpc & 4) != 0);
1784         if (s->mb_intra) goto intra;
1785
1786         if(s->pb_frame && get_bits1(&s->gb))
1787             pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
1788         cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1789
1790         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
1791             cbpy ^= 0xF;
1792
1793         cbp = (cbpc & 3) | (cbpy << 2);
1794         if (dquant) {
1795             h263_decode_dquant(s);
1796         }
1797
1798         s->mv_dir = MV_DIR_FORWARD;
1799         if ((cbpc & 16) == 0) {
1800             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
1801             /* 16x16 motion prediction */
1802             s->mv_type = MV_TYPE_16X16;
1803             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1804             if (s->umvplus)
1805                mx = h263p_decode_umotion(s, pred_x);
1806             else
1807                mx = h263_decode_motion(s, pred_x, 1);
1808
1809             if (mx >= 0xffff)
1810                 return -1;
1811
1812             if (s->umvplus)
1813                my = h263p_decode_umotion(s, pred_y);
1814             else
1815                my = h263_decode_motion(s, pred_y, 1);
1816
1817             if (my >= 0xffff)
1818                 return -1;
1819             s->mv[0][0][0] = mx;
1820             s->mv[0][0][1] = my;
1821
1822             if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
1823                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1824         } else {
1825             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
1826             s->mv_type = MV_TYPE_8X8;
1827             for(i=0;i<4;i++) {
1828                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1829                 if (s->umvplus)
1830                   mx = h263p_decode_umotion(s, pred_x);
1831                 else
1832                   mx = h263_decode_motion(s, pred_x, 1);
1833                 if (mx >= 0xffff)
1834                     return -1;
1835
1836                 if (s->umvplus)
1837                   my = h263p_decode_umotion(s, pred_y);
1838                 else
1839                   my = h263_decode_motion(s, pred_y, 1);
1840                 if (my >= 0xffff)
1841                     return -1;
1842                 s->mv[0][i][0] = mx;
1843                 s->mv[0][i][1] = my;
1844                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
1845                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1846                 mot_val[0] = mx;
1847                 mot_val[1] = my;
1848             }
1849         }
1850     } else if(s->pict_type==FF_B_TYPE) {
1851         int mb_type;
1852         const int stride= s->b8_stride;
1853         int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
1854         int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
1855 //        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
1856
1857         //FIXME ugly
1858         mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
1859         mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
1860         mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
1861         mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
1862
1863         do{
1864             mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
1865             if (mb_type < 0){
1866                 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
1867                 return -1;
1868             }
1869
1870             mb_type= h263_mb_type_b_map[ mb_type ];
1871         }while(!mb_type);
1872
1873         s->mb_intra = IS_INTRA(mb_type);
1874         if(HAS_CBP(mb_type)){
1875             s->dsp.clear_blocks(s->block[0]);
1876             cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
1877             if(s->mb_intra){
1878                 dquant = IS_QUANT(mb_type);
1879                 goto intra;
1880             }
1881
1882             cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1883
1884             if (cbpy < 0){
1885                 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1886                 return -1;
1887             }
1888
1889             if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
1890                 cbpy ^= 0xF;
1891
1892             cbp = (cbpc & 3) | (cbpy << 2);
1893         }else
1894             cbp=0;
1895
1896         assert(!s->mb_intra);
1897
1898         if(IS_QUANT(mb_type)){
1899             h263_decode_dquant(s);
1900         }
1901
1902         if(IS_DIRECT(mb_type)){
1903             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1904             mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
1905         }else{
1906             s->mv_dir = 0;
1907             s->mv_type= MV_TYPE_16X16;
1908 //FIXME UMV
1909
1910             if(USES_LIST(mb_type, 0)){
1911                 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
1912                 s->mv_dir = MV_DIR_FORWARD;
1913
1914                 mx = h263_decode_motion(s, mx, 1);
1915                 my = h263_decode_motion(s, my, 1);
1916
1917                 s->mv[0][0][0] = mx;
1918                 s->mv[0][0][1] = my;
1919                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
1920                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
1921             }
1922
1923             if(USES_LIST(mb_type, 1)){
1924                 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
1925                 s->mv_dir |= MV_DIR_BACKWARD;
1926
1927                 mx = h263_decode_motion(s, mx, 1);
1928                 my = h263_decode_motion(s, my, 1);
1929
1930                 s->mv[1][0][0] = mx;
1931                 s->mv[1][0][1] = my;
1932                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
1933                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
1934             }
1935         }
1936
1937         s->current_picture.mb_type[xy]= mb_type;
1938     } else { /* I-Frame */
1939         do{
1940             cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
1941             if (cbpc < 0){
1942                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1943                 return -1;
1944             }
1945         }while(cbpc == 8);
1946
1947         s->dsp.clear_blocks(s->block[0]);
1948
1949         dquant = cbpc & 4;
1950         s->mb_intra = 1;
1951 intra:
1952         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
1953         if (s->h263_aic) {
1954             s->ac_pred = get_bits1(&s->gb);
1955             if(s->ac_pred){
1956                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
1957
1958                 s->h263_aic_dir = get_bits1(&s->gb);
1959             }
1960         }else
1961             s->ac_pred = 0;
1962
1963         if(s->pb_frame && get_bits1(&s->gb))
1964             pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
1965         cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1966         if(cbpy<0){
1967             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1968             return -1;
1969         }
1970         cbp = (cbpc & 3) | (cbpy << 2);
1971         if (dquant) {
1972             h263_decode_dquant(s);
1973         }
1974
1975         pb_mv_count += !!s->pb_frame;
1976     }
1977
1978     while(pb_mv_count--){
1979         h263_decode_motion(s, 0, 1);
1980         h263_decode_motion(s, 0, 1);
1981     }
1982
1983     /* decode each block */
1984     for (i = 0; i < 6; i++) {
1985         if (h263_decode_block(s, block[i], i, cbp&32) < 0)
1986             return -1;
1987         cbp+=cbp;
1988     }
1989
1990     if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0)
1991         return -1;
1992     if(s->obmc && !s->mb_intra){
1993         if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
1994             preview_obmc(s);
1995     }
1996 end:
1997
1998         /* per-MB end of slice check */
1999     {
2000         int v= show_bits(&s->gb, 16);
2001
2002         if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
2003             v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
2004         }
2005
2006         if(v==0)
2007             return SLICE_END;
2008     }
2009
2010     return SLICE_OK;
2011 }
2012
2013 /* most is hardcoded. should extend to handle all h263 streams */
2014 int h263_decode_picture_header(MpegEncContext *s)
2015 {
2016     int format, width, height, i;
2017     uint32_t startcode;
2018
2019     align_get_bits(&s->gb);
2020
2021     startcode= get_bits(&s->gb, 22-8);
2022
2023     for(i= get_bits_left(&s->gb); i>24; i-=8) {
2024         startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
2025
2026         if(startcode == 0x20)
2027             break;
2028     }
2029
2030     if (startcode != 0x20) {
2031         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
2032         return -1;
2033     }
2034     /* temporal reference */
2035     i = get_bits(&s->gb, 8); /* picture timestamp */
2036     if( (s->picture_number&~0xFF)+i < s->picture_number)
2037         i+= 256;
2038     s->current_picture_ptr->pts=
2039     s->picture_number= (s->picture_number&~0xFF) + i;
2040
2041     /* PTYPE starts here */
2042     if (get_bits1(&s->gb) != 1) {
2043         /* marker */
2044         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
2045         return -1;
2046     }
2047     if (get_bits1(&s->gb) != 0) {
2048         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
2049         return -1;      /* h263 id */
2050     }
2051     skip_bits1(&s->gb);         /* split screen off */
2052     skip_bits1(&s->gb);         /* camera  off */
2053     skip_bits1(&s->gb);         /* freeze picture release off */
2054
2055     format = get_bits(&s->gb, 3);
2056     /*
2057         0    forbidden
2058         1    sub-QCIF
2059         10   QCIF
2060         7       extended PTYPE (PLUSPTYPE)
2061     */
2062
2063     if (format != 7 && format != 6) {
2064         s->h263_plus = 0;
2065         /* H.263v1 */
2066         width = h263_format[format][0];
2067         height = h263_format[format][1];
2068         if (!width)
2069             return -1;
2070
2071         s->pict_type = FF_I_TYPE + get_bits1(&s->gb);
2072
2073         s->h263_long_vectors = get_bits1(&s->gb);
2074
2075         if (get_bits1(&s->gb) != 0) {
2076             av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
2077             return -1; /* SAC: off */
2078         }
2079         s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
2080         s->unrestricted_mv = s->h263_long_vectors || s->obmc;
2081
2082         s->pb_frame = get_bits1(&s->gb);
2083         s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
2084         skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
2085
2086         s->width = width;
2087         s->height = height;
2088         s->avctx->sample_aspect_ratio= (AVRational){12,11};
2089         s->avctx->time_base= (AVRational){1001, 30000};
2090     } else {
2091         int ufep;
2092
2093         /* H.263v2 */
2094         s->h263_plus = 1;
2095         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
2096
2097         /* ufep other than 0 and 1 are reserved */
2098         if (ufep == 1) {
2099             /* OPPTYPE */
2100             format = get_bits(&s->gb, 3);
2101             dprintf(s->avctx, "ufep=1, format: %d\n", format);
2102             s->custom_pcf= get_bits1(&s->gb);
2103             s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
2104             if (get_bits1(&s->gb) != 0) {
2105                 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
2106             }
2107             s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
2108             s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
2109             s->loop_filter= get_bits1(&s->gb);
2110             s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
2111
2112             s->h263_slice_structured= get_bits1(&s->gb);
2113             if (get_bits1(&s->gb) != 0) {
2114                 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
2115             }
2116             if (get_bits1(&s->gb) != 0) {
2117                 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
2118             }
2119             s->alt_inter_vlc= get_bits1(&s->gb);
2120             s->modified_quant= get_bits1(&s->gb);
2121             if(s->modified_quant)
2122                 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
2123
2124             skip_bits(&s->gb, 1); /* Prevent start code emulation */
2125
2126             skip_bits(&s->gb, 3); /* Reserved */
2127         } else if (ufep != 0) {
2128             av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
2129             return -1;
2130         }
2131
2132         /* MPPTYPE */
2133         s->pict_type = get_bits(&s->gb, 3);
2134         switch(s->pict_type){
2135         case 0: s->pict_type= FF_I_TYPE;break;
2136         case 1: s->pict_type= FF_P_TYPE;break;
2137         case 2: s->pict_type= FF_P_TYPE;s->pb_frame = 3;break;
2138         case 3: s->pict_type= FF_B_TYPE;break;
2139         case 7: s->pict_type= FF_I_TYPE;break; //ZYGO
2140         default:
2141             return -1;
2142         }
2143         skip_bits(&s->gb, 2);
2144         s->no_rounding = get_bits1(&s->gb);
2145         skip_bits(&s->gb, 4);
2146
2147         /* Get the picture dimensions */
2148         if (ufep) {
2149             if (format == 6) {
2150                 /* Custom Picture Format (CPFMT) */
2151                 s->aspect_ratio_info = get_bits(&s->gb, 4);
2152                 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
2153                 /* aspect ratios:
2154                 0 - forbidden
2155                 1 - 1:1
2156                 2 - 12:11 (CIF 4:3)
2157                 3 - 10:11 (525-type 4:3)
2158                 4 - 16:11 (CIF 16:9)
2159                 5 - 40:33 (525-type 16:9)
2160                 6-14 - reserved
2161                 */
2162                 width = (get_bits(&s->gb, 9) + 1) * 4;
2163                 skip_bits1(&s->gb);
2164                 height = get_bits(&s->gb, 9) * 4;
2165                 dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
2166                 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
2167                     /* aspected dimensions */
2168                     s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
2169                     s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
2170                 }else{
2171                     s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info];
2172                 }
2173             } else {
2174                 width = h263_format[format][0];
2175                 height = h263_format[format][1];
2176                 s->avctx->sample_aspect_ratio= (AVRational){12,11};
2177             }
2178             if ((width == 0) || (height == 0))
2179                 return -1;
2180             s->width = width;
2181             s->height = height;
2182
2183             if(s->custom_pcf){
2184                 int gcd;
2185                 s->avctx->time_base.den= 1800000;
2186                 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
2187                 s->avctx->time_base.num*= get_bits(&s->gb, 7);
2188                 if(s->avctx->time_base.num == 0){
2189                     av_log(s, AV_LOG_ERROR, "zero framerate\n");
2190                     return -1;
2191                 }
2192                 gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
2193                 s->avctx->time_base.den /= gcd;
2194                 s->avctx->time_base.num /= gcd;
2195             }else{
2196                 s->avctx->time_base= (AVRational){1001, 30000};
2197             }
2198         }
2199
2200         if(s->custom_pcf){
2201             skip_bits(&s->gb, 2); //extended Temporal reference
2202         }
2203
2204         if (ufep) {
2205             if (s->umvplus) {
2206                 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
2207                     skip_bits1(&s->gb);
2208             }
2209             if(s->h263_slice_structured){
2210                 if (get_bits1(&s->gb) != 0) {
2211                     av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
2212                 }
2213                 if (get_bits1(&s->gb) != 0) {
2214                     av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
2215                 }
2216             }
2217         }
2218
2219         s->qscale = get_bits(&s->gb, 5);
2220     }
2221
2222     s->mb_width = (s->width  + 15) / 16;
2223     s->mb_height = (s->height  + 15) / 16;
2224     s->mb_num = s->mb_width * s->mb_height;
2225
2226     if (s->pb_frame) {
2227         skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */
2228         if (s->custom_pcf)
2229             skip_bits(&s->gb, 2); //extended Temporal reference
2230         skip_bits(&s->gb, 2); /* Quantization information for B-pictures */
2231     }
2232
2233     /* PEI */
2234     while (get_bits1(&s->gb) != 0) {
2235         skip_bits(&s->gb, 8);
2236     }
2237
2238     if(s->h263_slice_structured){
2239         if (get_bits1(&s->gb) != 1) {
2240             av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
2241             return -1;
2242         }
2243
2244         ff_h263_decode_mba(s);
2245
2246         if (get_bits1(&s->gb) != 1) {
2247             av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
2248             return -1;
2249         }
2250     }
2251     s->f_code = 1;
2252
2253     if(s->h263_aic){
2254          s->y_dc_scale_table=
2255          s->c_dc_scale_table= ff_aic_dc_scale_table;
2256     }else{
2257         s->y_dc_scale_table=
2258         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2259     }
2260
2261         ff_h263_show_pict_info(s);
2262     if (s->pict_type == FF_I_TYPE && s->codec_tag == AV_RL32("ZYGO")){
2263         int i,j;
2264         for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
2265         av_log(s->avctx, AV_LOG_DEBUG, "\n");
2266         for(i=0; i<13; i++){
2267             for(j=0; j<3; j++){
2268                 int v= get_bits(&s->gb, 8);
2269                 v |= get_sbits(&s->gb, 8)<<8;
2270                 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
2271             }
2272             av_log(s->avctx, AV_LOG_DEBUG, "\n");
2273         }
2274         for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
2275     }
2276
2277     return 0;
2278 }
2279
2280