?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use FFABS instead of abs.
[FFMpeg-mirror/ordered_chapters.git] / libavcodec / h263.c
blobebf64fd92cb7f9496f20a33de34fffa07ddb4dcc
1 /*
2 * H263/MPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 * H263+ support.
5 * Copyright (c) 2001 Juan J. Sierralta P.
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7 *
8 * This file is part of FFmpeg.
9 *
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 *
24 * ac prediction encoding, b-frame support, error resilience, optimizations,
25 * qpel decoding, gmc decoding, interlaced decoding,
26 * by Michael Niedermayer <michaelni@gmx.at>
27 */
28
29 /**
30 * @file h263.c
31 * h263/mpeg4 codec.
32 */
33
34 //#define DEBUG
35 #include <limits.h>
36
37 #include "dsputil.h"
38 #include "avcodec.h"
39 #include "mpegvideo.h"
40 #include "h263data.h"
41 #include "mpeg4data.h"
42
43 //#undef NDEBUG
44 //#include <assert.h>
45
46 #define INTRA_MCBPC_VLC_BITS 6
47 #define INTER_MCBPC_VLC_BITS 7
48 #define CBPY_VLC_BITS 6
49 #define MV_VLC_BITS 9
50 #define DC_VLC_BITS 9
51 #define SPRITE_TRAJ_VLC_BITS 6
52 #define MB_TYPE_B_VLC_BITS 4
53 #define TEX_VLC_BITS 9
54 #define H263_MBTYPE_B_VLC_BITS 6
55 #define CBPC_B_VLC_BITS 3
56
57 #ifdef CONFIG_ENCODERS
58 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
59 int n);
60 static void h263p_encode_umotion(MpegEncContext * s, int val);
61 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
62 int n, int dc, uint8_t *scan_table,
63 PutBitContext *dc_pb, PutBitContext *ac_pb);
64 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
65 uint8_t *scan_table);
66 #endif
67
68 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
69 static int h263p_decode_umotion(MpegEncContext * s, int pred);
70 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
71 int n, int coded);
72 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
73 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
74 int n, int coded, int intra, int rvlc);
75 #ifdef CONFIG_ENCODERS
76 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
77 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
78 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
79 #endif //CONFIG_ENCODERS
80 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
81 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
82
83 #ifdef CONFIG_ENCODERS
84 static uint8_t uni_DCtab_lum_len[512];
85 static uint8_t uni_DCtab_chrom_len[512];
86 static uint16_t uni_DCtab_lum_bits[512];
87 static uint16_t uni_DCtab_chrom_bits[512];
88
89 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
90 static uint8_t fcode_tab[MAX_MV*2+1];
91 static uint8_t umv_fcode_tab[MAX_MV*2+1];
92
93 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
94 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
95 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
96 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
97 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
98 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
100 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
101 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
102
103 /* mpeg4
104 inter
105 max level: 24/6
106 max run: 53/63
107
108 intra
109 max level: 53/16
110 max run: 29/41
111 */
112 #endif
113
114 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
115
116 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
117 #define IS_3IV1 s->codec_tag == ff_get_fourcc("3IV1")
118 #else
119 #define IS_3IV1 0
120 #endif
121
122 int h263_get_picture_format(int width, int height)
123 {
124 int format;
125
126 if (width == 128 && height == 96)
127 format = 1;
128 else if (width == 176 && height == 144)
129 format = 2;
130 else if (width == 352 && height == 288)
131 format = 3;
132 else if (width == 704 && height == 576)
133 format = 4;
134 else if (width == 1408 && height == 1152)
135 format = 5;
136 else
137 format = 7;
138 return format;
139 }
140
141 #ifdef CONFIG_ENCODERS
142
143 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
144 int i;
145
146 if(aspect.num==0) aspect= (AVRational){1,1};
147
148 for(i=1; i<6; i++){
149 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
150 s->aspect_ratio_info=i;
151 return;
152 }
153 }
154
155 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
156 }
157
158 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
159 {
160 int format;
161
162 align_put_bits(&s->pb);
163
164 put_bits(&s->pb, 17, 1);
165 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
166 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
167 s->avctx->time_base.den) & 0xff); /* TemporalReference */
168 if (s->width == 352 && s->height == 288)
169 format = 2;
170 else if (s->width == 176 && s->height == 144)
171 format = 3;
172 else if (s->width == 128 && s->height == 96)
173 format = 4;
174 else if (s->width == 320 && s->height == 240)
175 format = 5;
176 else if (s->width == 160 && s->height == 120)
177 format = 6;
178 else if (s->width <= 255 && s->height <= 255)
179 format = 0; /* use 1 byte width & height */
180 else
181 format = 1; /* use 2 bytes width & height */
182 put_bits(&s->pb, 3, format); /* PictureSize */
183 if (format == 0) {
184 put_bits(&s->pb, 8, s->width);
185 put_bits(&s->pb, 8, s->height);
186 } else if (format == 1) {
187 put_bits(&s->pb, 16, s->width);
188 put_bits(&s->pb, 16, s->height);
189 }
190 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
191 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
192 put_bits(&s->pb, 5, s->qscale); /* Quantizer */
193 put_bits(&s->pb, 1, 0); /* ExtraInformation */
194
195 if(s->h263_aic){
196 s->y_dc_scale_table=
197 s->c_dc_scale_table= ff_aic_dc_scale_table;
198 }else{
199 s->y_dc_scale_table=
200 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
201 }
202 }
203
204 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
205 {
206 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
207 int best_clock_code=1;
208 int best_divisor=60;
209 int best_error= INT_MAX;
210
211 if(s->h263_plus){
212 for(i=0; i<2; i++){
213 int div, error;
214 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
215 div= av_clip(1, div, 127);
216 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
217 if(error < best_error){
218 best_error= error;
219 best_divisor= div;
220 best_clock_code= i;
221 }
222 }
223 }
224 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
225 coded_frame_rate= 1800000;
226 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
227
228 align_put_bits(&s->pb);
229
230 /* Update the pointer to last GOB */
231 s->ptr_lastgob = pbBufPtr(&s->pb);
232 put_bits(&s->pb, 22, 0x20); /* PSC */
233 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
234 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
235 put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
236
237 put_bits(&s->pb, 1, 1); /* marker */
238 put_bits(&s->pb, 1, 0); /* h263 id */
239 put_bits(&s->pb, 1, 0); /* split screen off */
240 put_bits(&s->pb, 1, 0); /* camera off */
241 put_bits(&s->pb, 1, 0); /* freeze picture release off */
242
243 format = h263_get_picture_format(s->width, s->height);
244 if (!s->h263_plus) {
245 /* H.263v1 */
246 put_bits(&s->pb, 3, format);
247 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
248 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
249 of H.263v1 UMV implies to check the predicted MV after
250 calculation of the current MB to see if we're on the limits */
251 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
252 put_bits(&s->pb, 1, 0); /* SAC: off */
253 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
254 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
255 put_bits(&s->pb, 5, s->qscale);
256 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
257 } else {
258 int ufep=1;
259 /* H.263v2 */
260 /* H.263 Plus PTYPE */
261
262 put_bits(&s->pb, 3, 7);
263 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
264 if (format == 7)
265 put_bits(&s->pb,3,6); /* Custom Source Format */
266 else
267 put_bits(&s->pb, 3, format);
268
269 put_bits(&s->pb,1, s->custom_pcf);
270 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
271 put_bits(&s->pb,1,0); /* SAC: off */
272 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
273 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
274 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
275 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
276 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
277 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
278 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
279 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
280 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
281 put_bits(&s->pb,3,0); /* Reserved */
282
283 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
284
285 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
286 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
287 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
288 put_bits(&s->pb,2,0); /* Reserved */
289 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
290
291 /* This should be here if PLUSPTYPE */
292 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
293
294 if (format == 7) {
295 /* Custom Picture Format (CPFMT) */
296 aspect_to_info(s, s->avctx->sample_aspect_ratio);
297
298 put_bits(&s->pb,4,s->aspect_ratio_info);
299 put_bits(&s->pb,9,(s->width >> 2) - 1);
300 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
301 put_bits(&s->pb,9,(s->height >> 2));
302 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
303 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
304 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
305 }
306 }
307 if(s->custom_pcf){
308 if(ufep){
309 put_bits(&s->pb, 1, best_clock_code);
310 put_bits(&s->pb, 7, best_divisor);
311 }
312 put_bits(&s->pb, 2, (temp_ref>>8)&3);
313 }
314
315 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
316 if (s->umvplus)
317 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
318 //FIXME check actual requested range
319 put_bits(&s->pb,2,1); /* unlimited */
320 if(s->h263_slice_structured)
321 put_bits(&s->pb,2,0); /* no weird submodes */
322
323 put_bits(&s->pb, 5, s->qscale);
324 }
325
326 put_bits(&s->pb, 1, 0); /* no PEI */
327
328 if(s->h263_slice_structured){
329 put_bits(&s->pb, 1, 1);
330
331 assert(s->mb_x == 0 && s->mb_y == 0);
332 ff_h263_encode_mba(s);
333
334 put_bits(&s->pb, 1, 1);
335 }
336
337 if(s->h263_aic){
338 s->y_dc_scale_table=
339 s->c_dc_scale_table= ff_aic_dc_scale_table;
340 }else{
341 s->y_dc_scale_table=
342 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
343 }
344 }
345
346 /**
347 * Encodes a group of blocks header.
348 */
349 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
350 {
351 put_bits(&s->pb, 17, 1); /* GBSC */
352
353 if(s->h263_slice_structured){
354 put_bits(&s->pb, 1, 1);
355
356 ff_h263_encode_mba(s);
357
358 if(s->mb_num > 1583)
359 put_bits(&s->pb, 1, 1);
360 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
361 put_bits(&s->pb, 1, 1);
362 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
363 }else{
364 int gob_number= mb_line / s->gob_index;
365
366 put_bits(&s->pb, 5, gob_number); /* GN */
367 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
368 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
369 }
370 }
371
372 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
373 int last=0;
374 int j;
375 int rate=0;
376
377 for(j=1; j<=block_last_index; j++){
378 const int index= scantable[j];
379 int level= block[index];
380 if(level){
381 level+= 64;
382 if((level&(~127)) == 0){
383 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
384 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
385 }else
386 rate += s->ac_esc_length;
387 level-= 64;
388
389 last= j;
390 }
391 }
392
393 return rate;
394 }
395
396 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
397 {
398 int score= 0;
399 int i, n;
400 int8_t * const qscale_table= s->current_picture.qscale_table;
401
402 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
403
404 for(n=0; n<6; n++){
405 int16_t *ac_val, *ac_val1;
406
407 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
408
409 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
410 ac_val1= ac_val;
411 if(dir[n]){
412 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
413 /* top prediction */
414 ac_val-= s->block_wrap[n]*16;
415 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
416 /* same qscale */
417 for(i=1; i<8; i++){
418 const int level= block[n][s->dsp.idct_permutation[i ]];
419 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
420 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
421 ac_val1[i+8]= level;
422 }
423 }else{
424 /* different qscale, we must rescale */
425 for(i=1; i<8; i++){
426 const int level= block[n][s->dsp.idct_permutation[i ]];
427 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
428 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
429 ac_val1[i+8]= level;
430 }
431 }
432 st[n]= s->intra_h_scantable.permutated;
433 }else{
434 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
435 /* left prediction */
436 ac_val-= 16;
437 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
438 /* same qscale */
439 for(i=1; i<8; i++){
440 const int level= block[n][s->dsp.idct_permutation[i<<3]];
441 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
442 ac_val1[i ]= level;
443 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
444 }
445 }else{
446 /* different qscale, we must rescale */
447 for(i=1; i<8; i++){
448 const int level= block[n][s->dsp.idct_permutation[i<<3]];
449 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
450 ac_val1[i ]= level;
451 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
452 }
453 }
454 st[n]= s->intra_v_scantable.permutated;
455 }
456
457 for(i=63; i>0; i--) //FIXME optimize
458 if(block[n][ st[n][i] ]) break;
459 s->block_last_index[n]= i;
460
461 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
462 }
463
464 return score < 0;
465 }
466
467 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
468 {
469 int i, n;
470 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
471
472 for(n=0; n<6; n++){
473 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
474
475 st[n]= s->intra_scantable.permutated;
476 if(dir[n]){
477 /* top prediction */
478 for(i=1; i<8; i++){
479 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
480 }
481 }else{
482 /* left prediction */
483 for(i=1; i<8; i++){
484 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
485 }
486 }
487 }
488 }
489
490 /**
491 * init s->current_picture.qscale_table from s->lambda_table
492 */
493 static void ff_init_qscale_tab(MpegEncContext *s){
494 int8_t * const qscale_table= s->current_picture.qscale_table;
495 int i;
496
497 for(i=0; i<s->mb_num; i++){
498 unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
499 int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
500 qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax);
501 }
502 }
503
504 /**
505 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
506 */
507 void ff_clean_h263_qscales(MpegEncContext *s){
508 int i;
509 int8_t * const qscale_table= s->current_picture.qscale_table;
510
511 ff_init_qscale_tab(s);
512
513 for(i=1; i<s->mb_num; i++){
514 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
515 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
516 }
517 for(i=s->mb_num-2; i>=0; i--){
518 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
519 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
520 }
521
522 if(s->codec_id != CODEC_ID_H263P){
523 for(i=1; i<s->mb_num; i++){
524 int mb_xy= s->mb_index2xy[i];
525
526 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
527 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
528 }
529 }
530 }
531 }
532
533 /**
534 * modify mb_type & qscale so that encoding is acually possible in mpeg4
535 */
536 void ff_clean_mpeg4_qscales(MpegEncContext *s){
537 int i;
538 int8_t * const qscale_table= s->current_picture.qscale_table;
539
540 ff_clean_h263_qscales(s);
541
542 if(s->pict_type== B_TYPE){
543 int odd=0;
544 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
545
546 for(i=0; i<s->mb_num; i++){
547 int mb_xy= s->mb_index2xy[i];
548 odd += qscale_table[mb_xy]&1;
549 }
550
551 if(2*odd > s->mb_num) odd=1;
552 else odd=0;
553
554 for(i=0; i<s->mb_num; i++){
555 int mb_xy= s->mb_index2xy[i];
556 if((qscale_table[mb_xy]&1) != odd)
557 qscale_table[mb_xy]++;
558 if(qscale_table[mb_xy] > 31)
559 qscale_table[mb_xy]= 31;
560 }
561
562 for(i=1; i<s->mb_num; i++){
563 int mb_xy= s->mb_index2xy[i];
564 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
565 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
566 }
567 }
568 }
569 }
570
571 #endif //CONFIG_ENCODERS
572
573 #define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
574 #define tab_bias (tab_size/2)
575
576 void ff_mpeg4_init_direct_mv(MpegEncContext *s){
577 int i;
578 for(i=0; i<tab_size; i++){
579 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
580 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
581 }
582 }
583
584 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
585 int xy= s->block_index[i];
586 uint16_t time_pp= s->pp_time;
587 uint16_t time_pb= s->pb_time;
588 int p_mx, p_my;
589
590 p_mx= s->next_picture.motion_val[0][xy][0];
591 if((unsigned)(p_mx + tab_bias) < tab_size){
592 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
593 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
594 : s->direct_scale_mv[1][p_mx + tab_bias];
595 }else{
596 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
597 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
598 : p_mx*(time_pb - time_pp)/time_pp;
599 }
600 p_my= s->next_picture.motion_val[0][xy][1];
601 if((unsigned)(p_my + tab_bias) < tab_size){
602 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
603 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
604 : s->direct_scale_mv[1][p_my + tab_bias];
605 }else{
606 s->mv[0][i][1] = p_my*time_pb/time_pp + my;
607 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
608 : p_my*(time_pb - time_pp)/time_pp;
609 }
610 }
611
612 #undef tab_size
613 #undef tab_bias
614
615 /**
616 *
617 * @return the mb_type
618 */
619 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
620 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
621 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
622 uint16_t time_pp= s->pp_time;
623 uint16_t time_pb= s->pb_time;
624 int i;
625
626 //FIXME avoid divides
627 // try special case with shifts for 1 and 3 B-frames?
628
629 if(IS_8X8(colocated_mb_type)){
630 s->mv_type = MV_TYPE_8X8;
631 for(i=0; i<4; i++){
632 ff_mpeg4_set_one_direct_mv(s, mx, my, i);
633 }
634 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
635 } else if(IS_INTERLACED(colocated_mb_type)){
636 s->mv_type = MV_TYPE_FIELD;
637 for(i=0; i<2; i++){
638 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
639 s->field_select[0][i]= field_select;
640 s->field_select[1][i]= i;
641 if(s->top_field_first){
642 time_pp= s->pp_field_time - field_select + i;
643 time_pb= s->pb_field_time - field_select + i;
644 }else{
645 time_pp= s->pp_field_time + field_select - i;
646 time_pb= s->pb_field_time + field_select - i;
647 }
648 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
649 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
650 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
651 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
652 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
653 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
654 }
655 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
656 }else{
657 ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
658 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
659 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
660 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
661 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
662 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
663 s->mv_type= MV_TYPE_16X16;
664 else
665 s->mv_type= MV_TYPE_8X8;
666 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
667 }
668 }
669
670 void ff_h263_update_motion_val(MpegEncContext * s){
671 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
672 //FIXME a lot of that is only needed for !low_delay
673 const int wrap = s->b8_stride;
674 const int xy = s->block_index[0];
675
676 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
677
678 if(s->mv_type != MV_TYPE_8X8){
679 int motion_x, motion_y;
680 if (s->mb_intra) {
681 motion_x = 0;
682 motion_y = 0;
683 } else if (s->mv_type == MV_TYPE_16X16) {
684 motion_x = s->mv[0][0][0];
685 motion_y = s->mv[0][0][1];
686 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
687 int i;
688 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
689 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
690 motion_x = (motion_x>>1) | (motion_x&1);
691 for(i=0; i<2; i++){
692 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
693 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
694 }
695 s->current_picture.ref_index[0][xy ]=
696 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
697 s->current_picture.ref_index[0][xy + wrap ]=
698 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
699 }
700
701 /* no update if 8X8 because it has been done during parsing */
702 s->current_picture.motion_val[0][xy][0] = motion_x;
703 s->current_picture.motion_val[0][xy][1] = motion_y;
704 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
705 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
706 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
707 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
708 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
709 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
710 }
711
712 if(s->encoding){ //FIXME encoding MUST be cleaned up
713 if (s->mv_type == MV_TYPE_8X8)
714 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
715 else if(s->mb_intra)
716 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
717 else
718 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
719 }
720 }
721
722 #ifdef CONFIG_ENCODERS
723
724 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
725 int l, bit_size, code;
726
727 if (val == 0) {
728 return mvtab[0][1];
729 } else {
730 bit_size = f_code - 1;
731 /* modulo encoding */
732 l= INT_BIT - 6 - bit_size;
733 val = (val<<l)>>l;
734 val--;
735 code = (val >> bit_size) + 1;
736
737 return mvtab[code][1] + 1 + bit_size;
738 }
739 }
740
741 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
742 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
743 skip_put_bits(&s->pb,
744 h263_get_motion_length(s, x, f_code)
745 +h263_get_motion_length(s, y, f_code));
746 }else{
747 ff_h263_encode_motion(s, x, f_code);
748 ff_h263_encode_motion(s, y, f_code);
749 }
750 }
751
752 static inline int get_p_cbp(MpegEncContext * s,
753 DCTELEM block[6][64],
754 int motion_x, int motion_y){
755 int cbp, i;
756
757 if(s->flags & CODEC_FLAG_CBP_RD){
758 int best_cbpy_score= INT_MAX;
759 int best_cbpc_score= INT_MAX;
760 int cbpc = (-1), cbpy= (-1);
761 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
762 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
763
764 for(i=0; i<4; i++){
765 int score= inter_MCBPC_bits[i + offset] * lambda;
766 if(i&1) score += s->coded_score[5];
767 if(i&2) score += s->coded_score[4];
768
769 if(score < best_cbpc_score){
770 best_cbpc_score= score;
771 cbpc= i;
772 }
773 }
774
775 for(i=0; i<16; i++){
776 int score= cbpy_tab[i ^ 0xF][1] * lambda;
777 if(i&1) score += s->coded_score[3];
778 if(i&2) score += s->coded_score[2];
779 if(i&4) score += s->coded_score[1];
780 if(i&8) score += s->coded_score[0];
781
782 if(score < best_cbpy_score){
783 best_cbpy_score= score;
784 cbpy= i;
785 }
786 }
787 cbp= cbpc + 4*cbpy;
788 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
789 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
790 cbp= 0;
791 }
792
793 for (i = 0; i < 6; i++) {
794 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
795 s->block_last_index[i]= -1;
796 memset(s->block[i], 0, sizeof(DCTELEM)*64);
797 }
798 }
799 }else{
800 cbp= 0;
801 for (i = 0; i < 6; i++) {
802 if (s->block_last_index[i] >= 0)
803 cbp |= 1 << (5 - i);
804 }
805 }
806 return cbp;
807 }
808
809 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
810 int motion_x, int motion_y, int mb_type){
811 int cbp=0, i;
812
813 if(s->flags & CODEC_FLAG_CBP_RD){
814 int score=0;
815 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
816
817 for(i=0; i<6; i++){
818 if(s->coded_score[i] < 0){
819 score += s->coded_score[i];
820 cbp |= 1 << (5 - i);
821 }
822 }
823
824 if(cbp){
825 int zero_score= -6;
826 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
827 zero_score-= 4; //2*MV + mb_type + cbp bit
828 }
829
830 zero_score*= lambda;
831 if(zero_score <= score){
832 cbp=0;
833 }
834 }
835
836 for (i = 0; i < 6; i++) {
837 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
838 s->block_last_index[i]= -1;
839 memset(s->block[i], 0, sizeof(DCTELEM)*64);
840 }
841 }
842 }else{
843 for (i = 0; i < 6; i++) {
844 if (s->block_last_index[i] >= 0)
845 cbp |= 1 << (5 - i);
846 }
847 }
848 return cbp;
849 }
850
851 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
852 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
853 int i;
854
855 if(scan_table){
856 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
857 for (i = 0; i < 6; i++) {
858 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
859 }
860 }else{
861 /* encode each block */
862 for (i = 0; i < 6; i++) {
863 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
864 }
865 }
866 }else{
867 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
868 for (i = 0; i < 6; i++) {
869 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
870 }
871 }else{
872 /* encode each block */
873 for (i = 0; i < 6; i++) {
874 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
875 }
876 }
877 }
878 }
879
880 void mpeg4_encode_mb(MpegEncContext * s,
881 DCTELEM block[6][64],
882 int motion_x, int motion_y)
883 {
884 int cbpc, cbpy, pred_x, pred_y;
885 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
886 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
887 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
888 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
889 const int dquant_code[5]= {1,0,9,2,3};
890
891 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
892 if (!s->mb_intra) {
893 int i, cbp;
894
895 if(s->pict_type==B_TYPE){
896 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
897 int mb_type= mb_type_table[s->mv_dir];
898
899 if(s->mb_x==0){
900 for(i=0; i<2; i++){
901 s->last_mv[i][0][0]=
902 s->last_mv[i][0][1]=
903 s->last_mv[i][1][0]=
904 s->last_mv[i][1][1]= 0;
905 }
906 }
907
908 assert(s->dquant>=-2 && s->dquant<=2);
909 assert((s->dquant&1)==0);
910 assert(mb_type>=0);
911
912 /* nothing to do if this MB was skipped in the next P Frame */
913 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
914 s->skip_count++;
915 s->mv[0][0][0]=
916 s->mv[0][0][1]=
917 s->mv[1][0][0]=
918 s->mv[1][0][1]= 0;
919 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
920 s->qscale -= s->dquant;
921 // s->mb_skipped=1;
922
923 return;
924 }
925
926 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
927
928 if ((cbp | motion_x | motion_y | mb_type) ==0) {
929 /* direct MB with MV={0,0} */
930 assert(s->dquant==0);
931
932 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
933
934 if(interleaved_stats){
935 s->misc_bits++;
936 s->last_bits++;
937 }
938 s->skip_count++;
939 return;
940 }
941
942 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
943 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
944 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
945 if(cbp) put_bits(&s->pb, 6, cbp);
946
947 if(cbp && mb_type){
948 if(s->dquant)
949 put_bits(&s->pb, 2, (s->dquant>>2)+3);
950 else
951 put_bits(&s->pb, 1, 0);
952 }else
953 s->qscale -= s->dquant;
954
955 if(!s->progressive_sequence){
956 if(cbp)
957 put_bits(&s->pb, 1, s->interlaced_dct);
958 if(mb_type) // not direct mode
959 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
960 }
961
962 if(interleaved_stats){
963 s->misc_bits+= get_bits_diff(s);
964 }
965
966 if(mb_type == 0){
967 assert(s->mv_dir & MV_DIRECT);
968 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
969 s->b_count++;
970 s->f_count++;
971 }else{
972 assert(mb_type > 0 && mb_type < 4);
973 if(s->mv_type != MV_TYPE_FIELD){
974 if(s->mv_dir & MV_DIR_FORWARD){
975 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
976 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
977 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
978 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
979 s->f_count++;
980 }
981 if(s->mv_dir & MV_DIR_BACKWARD){
982 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
983 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
984 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
985 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
986 s->b_count++;
987 }
988 }else{
989 if(s->mv_dir & MV_DIR_FORWARD){
990 put_bits(&s->pb, 1, s->field_select[0][0]);
991 put_bits(&s->pb, 1, s->field_select[0][1]);
992 }
993 if(s->mv_dir & MV_DIR_BACKWARD){
994 put_bits(&s->pb, 1, s->field_select[1][0]);
995 put_bits(&s->pb, 1, s->field_select[1][1]);
996 }
997 if(s->mv_dir & MV_DIR_FORWARD){
998 for(i=0; i<2; i++){
999 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
1000 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1001 s->last_mv[0][i][0]= s->mv[0][i][0];
1002 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1003 }
1004 s->f_count++;
1005 }
1006 if(s->mv_dir & MV_DIR_BACKWARD){
1007 for(i=0; i<2; i++){
1008 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
1009 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1010 s->last_mv[1][i][0]= s->mv[1][i][0];
1011 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1012 }
1013 s->b_count++;
1014 }
1015 }
1016 }
1017
1018 if(interleaved_stats){
1019 s->mv_bits+= get_bits_diff(s);
1020 }
1021
1022 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1023
1024 if(interleaved_stats){
1025 s->p_tex_bits+= get_bits_diff(s);
1026 }
1027
1028 }else{ /* s->pict_type==B_TYPE */
1029 cbp= get_p_cbp(s, block, motion_x, motion_y);
1030
1031 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1032 /* check if the B frames can skip it too, as we must skip it if we skip here
1033 why didn't they just compress the skip-mb bits instead of reusing them ?! */
1034 if(s->max_b_frames>0){
1035 int i;
1036 int x,y, offset;
1037 uint8_t *p_pic;
1038
1039 x= s->mb_x*16;
1040 y= s->mb_y*16;
1041 if(x+16 > s->width) x= s->width-16;
1042 if(y+16 > s->height) y= s->height-16;
1043
1044 offset= x + y*s->linesize;
1045 p_pic= s->new_picture.data[0] + offset;
1046
1047 s->mb_skipped=1;
1048 for(i=0; i<s->max_b_frames; i++){
1049 uint8_t *b_pic;
1050 int diff;
1051 Picture *pic= s->reordered_input_picture[i+1];
1052
1053 if(pic==NULL || pic->pict_type!=B_TYPE) break;
1054
1055 b_pic= pic->data[0] + offset;
1056 if(pic->type != FF_BUFFER_TYPE_SHARED)
1057 b_pic+= INPLACE_OFFSET;
1058 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1059 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1060 s->mb_skipped=0;
1061 break;
1062 }
1063 }
1064 }else
1065 s->mb_skipped=1;
1066
1067 if(s->mb_skipped==1){
1068 /* skip macroblock */
1069 put_bits(&s->pb, 1, 1);
1070
1071 if(interleaved_stats){
1072 s->misc_bits++;
1073 s->last_bits++;
1074 }
1075 s->skip_count++;
1076
1077 return;
1078 }
1079 }
1080
1081 put_bits(&s->pb, 1, 0); /* mb coded */
1082 cbpc = cbp & 3;
1083 cbpy = cbp >> 2;
1084 cbpy ^= 0xf;
1085 if(s->mv_type==MV_TYPE_16X16){
1086 if(s->dquant) cbpc+= 8;
1087 put_bits(&s->pb,
1088 inter_MCBPC_bits[cbpc],
1089 inter_MCBPC_code[cbpc]);
1090
1091 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1092 if(s->dquant)
1093 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1094
1095 if(!s->progressive_sequence){
1096 if(cbp)
1097 put_bits(pb2, 1, s->interlaced_dct);
1098 put_bits(pb2, 1, 0);
1099 }
1100
1101 if(interleaved_stats){
1102 s->misc_bits+= get_bits_diff(s);
1103 }
1104
1105 /* motion vectors: 16x16 mode */
1106 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1107
1108 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1109 motion_y - pred_y, s->f_code);
1110 }else if(s->mv_type==MV_TYPE_FIELD){
1111 if(s->dquant) cbpc+= 8;
1112 put_bits(&s->pb,
1113 inter_MCBPC_bits[cbpc],
1114 inter_MCBPC_code[cbpc]);
1115
1116 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1117 if(s->dquant)
1118 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1119
1120 assert(!s->progressive_sequence);
1121 if(cbp)
1122 put_bits(pb2, 1, s->interlaced_dct);
1123 put_bits(pb2, 1, 1);
1124
1125 if(interleaved_stats){
1126 s->misc_bits+= get_bits_diff(s);
1127 }
1128
1129 /* motion vectors: 16x8 interlaced mode */
1130 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1131 pred_y /=2;
1132
1133 put_bits(&s->pb, 1, s->field_select[0][0]);
1134 put_bits(&s->pb, 1, s->field_select[0][1]);
1135
1136 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1137 s->mv[0][0][1] - pred_y, s->f_code);
1138 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1139 s->mv[0][1][1] - pred_y, s->f_code);
1140 }else{
1141 assert(s->mv_type==MV_TYPE_8X8);
1142 put_bits(&s->pb,
1143 inter_MCBPC_bits[cbpc+16],
1144 inter_MCBPC_code[cbpc+16]);
1145 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1146
1147 if(!s->progressive_sequence){
1148 if(cbp)
1149 put_bits(pb2, 1, s->interlaced_dct);
1150 }
1151
1152 if(interleaved_stats){
1153 s->misc_bits+= get_bits_diff(s);
1154 }
1155
1156 for(i=0; i<4; i++){
1157 /* motion vectors: 8x8 mode*/
1158 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1159
1160 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1161 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1162 }
1163 }
1164
1165 if(interleaved_stats){
1166 s->mv_bits+= get_bits_diff(s);
1167 }
1168
1169 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1170
1171 if(interleaved_stats){
1172 s->p_tex_bits+= get_bits_diff(s);
1173 }
1174 s->f_count++;
1175 }
1176 } else {
1177 int cbp;
1178 int dc_diff[6]; //dc values with the dc prediction subtracted
1179 int dir[6]; //prediction direction
1180 int zigzag_last_index[6];
1181 uint8_t *scan_table[6];
1182 int i;
1183
1184 for(i=0; i<6; i++){
1185 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1186 }
1187
1188 if(s->flags & CODEC_FLAG_AC_PRED){
1189 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1190 if(!s->ac_pred)
1191 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1192 }else{
1193 for(i=0; i<6; i++)
1194 scan_table[i]= s->intra_scantable.permutated;
1195 }
1196
1197 /* compute cbp */
1198 cbp = 0;
1199 for (i = 0; i < 6; i++) {
1200 if (s->block_last_index[i] >= 1)
1201 cbp |= 1 << (5 - i);
1202 }
1203
1204 cbpc = cbp & 3;
1205 if (s->pict_type == I_TYPE) {
1206 if(s->dquant) cbpc+=4;
1207 put_bits(&s->pb,
1208 intra_MCBPC_bits[cbpc],
1209 intra_MCBPC_code[cbpc]);
1210 } else {
1211 if(s->dquant) cbpc+=8;
1212 put_bits(&s->pb, 1, 0); /* mb coded */
1213 put_bits(&s->pb,
1214 inter_MCBPC_bits[cbpc + 4],
1215 inter_MCBPC_code[cbpc + 4]);
1216 }
1217 put_bits(pb2, 1, s->ac_pred);
1218 cbpy = cbp >> 2;
1219 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1220 if(s->dquant)
1221 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1222
1223 if(!s->progressive_sequence){
1224 put_bits(dc_pb, 1, s->interlaced_dct);
1225 }
1226
1227 if(interleaved_stats){
1228 s->misc_bits+= get_bits_diff(s);
1229 }
1230
1231 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1232
1233 if(interleaved_stats){
1234 s->i_tex_bits+= get_bits_diff(s);
1235 }
1236 s->i_count++;
1237
1238 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1239 if(s->ac_pred)
1240 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1241 }
1242 }
1243
1244 void h263_encode_mb(MpegEncContext * s,
1245 DCTELEM block[6][64],
1246 int motion_x, int motion_y)
1247 {
1248 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1249 int16_t pred_dc;
1250 int16_t rec_intradc[6];
1251 int16_t *dc_ptr[6];
1252 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1253 const int dquant_code[5]= {1,0,9,2,3};
1254
1255 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1256 if (!s->mb_intra) {
1257 /* compute cbp */
1258 cbp= get_p_cbp(s, block, motion_x, motion_y);
1259
1260 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1261 /* skip macroblock */
1262 put_bits(&s->pb, 1, 1);
1263 if(interleaved_stats){
1264 s->misc_bits++;
1265 s->last_bits++;
1266 }
1267 s->skip_count++;
1268
1269 return;
1270 }
1271 put_bits(&s->pb, 1, 0); /* mb coded */
1272
1273 cbpc = cbp & 3;
1274 cbpy = cbp >> 2;
1275 if(s->alt_inter_vlc==0 || cbpc!=3)
1276 cbpy ^= 0xF;
1277 if(s->dquant) cbpc+= 8;
1278 if(s->mv_type==MV_TYPE_16X16){
1279 put_bits(&s->pb,
1280 inter_MCBPC_bits[cbpc],
1281 inter_MCBPC_code[cbpc]);
1282
1283 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1284 if(s->dquant)
1285 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1286
1287 if(interleaved_stats){
1288 s->misc_bits+= get_bits_diff(s);
1289 }
1290
1291 /* motion vectors: 16x16 mode */
1292 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1293
1294 if (!s->umvplus) {
1295 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1296 motion_y - pred_y, 1);
1297 }
1298 else {
1299 h263p_encode_umotion(s, motion_x - pred_x);
1300 h263p_encode_umotion(s, motion_y - pred_y);
1301 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1302 /* To prevent Start Code emulation */
1303 put_bits(&s->pb,1,1);
1304 }
1305 }else{
1306 put_bits(&s->pb,
1307 inter_MCBPC_bits[cbpc+16],
1308 inter_MCBPC_code[cbpc+16]);
1309 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1310 if(s->dquant)
1311 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1312
1313 if(interleaved_stats){
1314 s->misc_bits+= get_bits_diff(s);
1315 }
1316
1317 for(i=0; i<4; i++){
1318 /* motion vectors: 8x8 mode*/
1319 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1320
1321 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1322 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1323 if (!s->umvplus) {
1324 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1325 motion_y - pred_y, 1);
1326 }
1327 else {
1328 h263p_encode_umotion(s, motion_x - pred_x);
1329 h263p_encode_umotion(s, motion_y - pred_y);
1330 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1331 /* To prevent Start Code emulation */
1332 put_bits(&s->pb,1,1);
1333 }
1334 }
1335 }
1336
1337 if(interleaved_stats){
1338 s->mv_bits+= get_bits_diff(s);
1339 }
1340 } else {
1341 assert(s->mb_intra);
1342
1343 cbp = 0;
1344 if (s->h263_aic) {
1345 /* Predict DC */
1346 for(i=0; i<6; i++) {
1347 int16_t level = block[i][0];
1348 int scale;
1349
1350 if(i<4) scale= s->y_dc_scale;
1351 else scale= s->c_dc_scale;
1352
1353 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1354 level -= pred_dc;
1355 /* Quant */
1356 if (level >= 0)
1357 level = (level + (scale>>1))/scale;
1358 else
1359 level = (level - (scale>>1))/scale;
1360
1361 /* AIC can change CBP */
1362 if (level == 0 && s->block_last_index[i] == 0)
1363 s->block_last_index[i] = -1;
1364
1365 if(!s->modified_quant){
1366 if (level < -127)
1367 level = -127;
1368 else if (level > 127)
1369 level = 127;
1370 }
1371
1372 block[i][0] = level;
1373 /* Reconstruction */
1374 rec_intradc[i] = scale*level + pred_dc;
1375 /* Oddify */
1376 rec_intradc[i] |= 1;
1377 //if ((rec_intradc[i] % 2) == 0)
1378 // rec_intradc[i]++;
1379 /* Clipping */
1380 if (rec_intradc[i] < 0)
1381 rec_intradc[i] = 0;
1382 else if (rec_intradc[i] > 2047)
1383 rec_intradc[i] = 2047;
1384
1385 /* Update AC/DC tables */
1386 *dc_ptr[i] = rec_intradc[i];
1387 if (s->block_last_index[i] >= 0)
1388 cbp |= 1 << (5 - i);
1389 }
1390 }else{
1391 for(i=0; i<6; i++) {
1392 /* compute cbp */
1393 if (s->block_last_index[i] >= 1)
1394 cbp |= 1 << (5 - i);
1395 }
1396 }
1397
1398 cbpc = cbp & 3;
1399 if (s->pict_type == I_TYPE) {
1400 if(s->dquant) cbpc+=4;
1401 put_bits(&s->pb,
1402 intra_MCBPC_bits[cbpc],
1403 intra_MCBPC_code[cbpc]);
1404 } else {
1405 if(s->dquant) cbpc+=8;
1406 put_bits(&s->pb, 1, 0); /* mb coded */
1407 put_bits(&s->pb,
1408 inter_MCBPC_bits[cbpc + 4],
1409 inter_MCBPC_code[cbpc + 4]);
1410 }
1411 if (s->h263_aic) {
1412 /* XXX: currently, we do not try to use ac prediction */
1413 put_bits(&s->pb, 1, 0); /* no AC prediction */
1414 }
1415 cbpy = cbp >> 2;
1416 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1417 if(s->dquant)
1418 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1419
1420 if(interleaved_stats){
1421 s->misc_bits+= get_bits_diff(s);
1422 }
1423 }
1424
1425 for(i=0; i<6; i++) {
1426 /* encode each block */
1427 h263_encode_block(s, block[i], i);
1428
1429 /* Update INTRADC for decoding */
1430 if (s->h263_aic && s->mb_intra) {
1431 block[i][0] = rec_intradc[i];
1432
1433 }
1434 }
1435
1436 if(interleaved_stats){
1437 if (!s->mb_intra) {
1438 s->p_tex_bits+= get_bits_diff(s);
1439 s->f_count++;
1440 }else{
1441 s->i_tex_bits+= get_bits_diff(s);
1442 s->i_count++;
1443 }
1444 }
1445 }
1446 #endif
1447
1448 void ff_h263_loop_filter(MpegEncContext * s){
1449 int qp_c;
1450 const int linesize = s->linesize;
1451 const int uvlinesize= s->uvlinesize;
1452 const int xy = s->mb_y * s->mb_stride + s->mb_x;
1453 uint8_t *dest_y = s->dest[0];
1454 uint8_t *dest_cb= s->dest[1];
1455 uint8_t *dest_cr= s->dest[2];
1456
1457 // if(s->pict_type==B_TYPE && !s->readable) return;
1458
1459 /*
1460 Diag Top
1461 Left Center
1462 */
1463 if(!IS_SKIP(s->current_picture.mb_type[xy])){
1464 qp_c= s->qscale;
1465 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1466 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1467 }else
1468 qp_c= 0;
1469
1470 if(s->mb_y){
1471 int qp_dt, qp_t, qp_tc;
1472
1473 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1474 qp_t=0;
1475 else
1476 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1477
1478 if(qp_c)
1479 qp_tc= qp_c;
1480 else
1481 qp_tc= qp_t;
1482
1483 if(qp_tc){
1484 const int chroma_qp= s->chroma_qscale_table[qp_tc];
1485 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1486 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1487
1488 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1489 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1490 }
1491
1492 if(qp_t)
1493 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1494
1495 if(s->mb_x){
1496 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1497 qp_dt= qp_t;
1498 else
1499 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1500
1501 if(qp_dt){
1502 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1503 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1504 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1505 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1506 }
1507 }
1508 }
1509
1510 if(qp_c){
1511 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1512 if(s->mb_y + 1 == s->mb_height)
1513 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1514 }
1515
1516 if(s->mb_x){
1517 int qp_lc;
1518 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1519 qp_lc= qp_c;
1520 else
1521 qp_lc= s->current_picture.qscale_table[xy-1];
1522
1523 if(qp_lc){
1524 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1525 if(s->mb_y + 1 == s->mb_height){
1526 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1527 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1528 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1529 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1530 }
1531 }
1532 }
1533 }
1534
1535 #ifdef CONFIG_ENCODERS
1536 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1537 {
1538 int x, y, wrap, a, c, pred_dc, scale;
1539 int16_t *dc_val;
1540
1541 /* find prediction */
1542 if (n < 4) {
1543 x = 2 * s->mb_x + (n & 1);
1544 y = 2 * s->mb_y + ((n & 2) >> 1);
1545 wrap = s->b8_stride;
1546 dc_val = s->dc_val[0];
1547 scale = s->y_dc_scale;
1548 } else {
1549 x = s->mb_x;
1550 y = s->mb_y;
1551 wrap = s->mb_stride;
1552 dc_val = s->dc_val[n - 4 + 1];
1553 scale = s->c_dc_scale;
1554 }
1555 /* B C
1556 * A X
1557 */
1558 a = dc_val[(x - 1) + (y) * wrap];
1559 c = dc_val[(x) + (y - 1) * wrap];
1560
1561 /* No prediction outside GOB boundary */
1562 if(s->first_slice_line && n!=3){
1563 if(n!=2) c= 1024;
1564 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1565 }
1566 pred_dc = 1024;
1567 /* just DC prediction */
1568 if (a != 1024 && c != 1024)
1569 pred_dc = (a + c) >> 1;
1570 else if (a != 1024)
1571 pred_dc = a;
1572 else
1573 pred_dc = c;
1574
1575 /* we assume pred is positive */
1576 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1577 *dc_val_ptr = &dc_val[x + y * wrap];
1578 return pred_dc;
1579 }
1580 #endif /* CONFIG_ENCODERS */
1581
1582 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1583 {
1584 int x, y, wrap, a, c, pred_dc, scale, i;
1585 int16_t *dc_val, *ac_val, *ac_val1;
1586
1587 /* find prediction */
1588 if (n < 4) {
1589 x = 2 * s->mb_x + (n & 1);
1590 y = 2 * s->mb_y + (n>> 1);
1591 wrap = s->b8_stride;
1592 dc_val = s->dc_val[0];
1593 ac_val = s->ac_val[0][0];
1594 scale = s->y_dc_scale;
1595 } else {
1596 x = s->mb_x;
1597 y = s->mb_y;
1598 wrap = s->mb_stride;
1599 dc_val = s->dc_val[n - 4 + 1];
1600 ac_val = s->ac_val[n - 4 + 1][0];
1601 scale = s->c_dc_scale;
1602 }
1603
1604 ac_val += ((y) * wrap + (x)) * 16;
1605 ac_val1 = ac_val;
1606
1607 /* B C
1608 * A X
1609 */
1610 a = dc_val[(x - 1) + (y) * wrap];
1611 c = dc_val[(x) + (y - 1) * wrap];
1612
1613 /* No prediction outside GOB boundary */
1614 if(s->first_slice_line && n!=3){
1615 if(n!=2) c= 1024;
1616 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1617 }
1618
1619 if (s->ac_pred) {
1620 pred_dc = 1024;
1621 if (s->h263_aic_dir) {
1622 /* left prediction */
1623 if (a != 1024) {
1624 ac_val -= 16;
1625 for(i=1;i<8;i++) {
1626 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1627 }
1628 pred_dc = a;
1629 }
1630 } else {
1631 /* top prediction */
1632 if (c != 1024) {
1633 ac_val -= 16 * wrap;
1634 for(i=1;i<8;i++) {
1635 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1636 }
1637 pred_dc = c;
1638 }
1639 }
1640 } else {
1641 /* just DC prediction */
1642 if (a != 1024 && c != 1024)
1643 pred_dc = (a + c) >> 1;
1644 else if (a != 1024)
1645 pred_dc = a;
1646 else
1647 pred_dc = c;
1648 }
1649
1650 /* we assume pred is positive */
1651 block[0]=block[0]*scale + pred_dc;
1652
1653 if (block[0] < 0)
1654 block[0] = 0;
1655 else
1656 block[0] |= 1;
1657
1658 /* Update AC/DC tables */
1659 dc_val[(x) + (y) * wrap] = block[0];
1660
1661 /* left copy */
1662 for(i=1;i<8;i++)
1663 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1664 /* top copy */
1665 for(i=1;i<8;i++)
1666 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1667 }
1668
1669 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1670 int *px, int *py)
1671 {
1672 int wrap;
1673 int16_t *A, *B, *C, (*mot_val)[2];
1674 static const int off[4]= {2, 1, 1, -1};
1675
1676 wrap = s->b8_stride;
1677 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1678
1679 A = mot_val[ - 1];
1680 /* special case for first (slice) line */
1681 if (s->first_slice_line && block<3) {
1682 // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1683 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1684 if(block==0){ //most common case
1685 if(s->mb_x == s->resync_mb_x){ //rare
1686 *px= *py = 0;
1687 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1688 C = mot_val[off[block] - wrap];
1689 if(s->mb_x==0){
1690 *px = C[0];
1691 *py = C[1];
1692 }else{
1693 *px = mid_pred(A[0], 0, C[0]);
1694 *py = mid_pred(A[1], 0, C[1]);
1695 }
1696 }else{
1697 *px = A[0];
1698 *py = A[1];
1699 }
1700 }else if(block==1){
1701 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1702 C = mot_val[off[block] - wrap];
1703 *px = mid_pred(A[0], 0, C[0]);
1704 *py = mid_pred(A[1], 0, C[1]);
1705 }else{
1706 *px = A[0];
1707 *py = A[1];
1708 }
1709 }else{ /* block==2*/
1710 B = mot_val[ - wrap];
1711 C = mot_val[off[block] - wrap];
1712 if(s->mb_x == s->resync_mb_x) //rare
1713 A[0]=A[1]=0;
1714
1715 *px = mid_pred(A[0], B[0], C[0]);
1716 *py = mid_pred(A[1], B[1], C[1]);
1717 }
1718 } else {
1719 B = mot_val[ - wrap];
1720 C = mot_val[off[block] - wrap];
1721 *px = mid_pred(A[0], B[0], C[0]);
1722 *py = mid_pred(A[1], B[1], C[1]);
1723 }
1724 return *mot_val;
1725 }
1726
1727 #ifdef CONFIG_ENCODERS
1728 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1729 {
1730 int range, l, bit_size, sign, code, bits;
1731
1732 if (val == 0) {
1733 /* zero vector */
1734 code = 0;
1735 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1736 } else {
1737 bit_size = f_code - 1;
1738 range = 1 << bit_size;
1739 /* modulo encoding */
1740 l= INT_BIT - 6 - bit_size;
1741 val = (val<<l)>>l;
1742 sign = val>>31;
1743 val= (val^sign)-sign;
1744 sign&=1;
1745
1746 val--;
1747 code = (val >> bit_size) + 1;
1748 bits = val & (range - 1);
1749
1750 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1751 if (bit_size > 0) {
1752 put_bits(&s->pb, bit_size, bits);
1753 }
1754 }
1755 }
1756
1757 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1758 static void h263p_encode_umotion(MpegEncContext * s, int val)
1759 {
1760 short sval = 0;
1761 short i = 0;
1762 short n_bits = 0;
1763 short temp_val;
1764 int code = 0;
1765 int tcode;
1766
1767 if ( val == 0)
1768 put_bits(&s->pb, 1, 1);
1769 else if (val == 1)
1770 put_bits(&s->pb, 3, 0);
1771 else if (val == -1)
1772 put_bits(&s->pb, 3, 2);
1773 else {
1774
1775 sval = ((val < 0) ? (short)(-val):(short)val);
1776 temp_val = sval;
1777
1778 while (temp_val != 0) {
1779 temp_val = temp_val >> 1;
1780 n_bits++;
1781 }
1782
1783 i = n_bits - 1;
1784 while (i > 0) {
1785 tcode = (sval & (1 << (i-1))) >> (i-1);
1786 tcode = (tcode << 1) | 1;
1787 code = (code << 2) | tcode;
1788 i--;
1789 }
1790 code = ((code << 1) | (val < 0)) << 1;
1791 put_bits(&s->pb, (2*n_bits)+1, code);
1792 //printf("\nVal = %d\tCode = %d", sval, code);
1793 }
1794 }
1795
1796 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1797 {
1798 int f_code;
1799 int mv;
1800
1801 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1802 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1803 int len;
1804
1805 if(mv==0) len= mvtab[0][1];
1806 else{
1807 int val, bit_size, range, code;
1808
1809 bit_size = f_code - 1;
1810 range = 1 << bit_size;
1811
1812 val=mv;
1813 if (val < 0)
1814 val = -val;
1815 val--;
1816 code = (val >> bit_size) + 1;
1817 if(code<33){
1818 len= mvtab[code][1] + 1 + bit_size;
1819 }else{
1820 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1821 }
1822 }
1823
1824 mv_penalty[f_code][mv+MAX_MV]= len;
1825 }
1826 }
1827
1828 for(f_code=MAX_FCODE; f_code>0; f_code--){
1829 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1830 fcode_tab[mv+MAX_MV]= f_code;
1831 }
1832 }
1833
1834 for(mv=0; mv<MAX_MV*2+1; mv++){
1835 umv_fcode_tab[mv]= 1;
1836 }
1837 }
1838 #endif
1839
1840 #ifdef CONFIG_ENCODERS
1841
1842 static void init_uni_dc_tab(void)
1843 {
1844 int level, uni_code, uni_len;
1845
1846 for(level=-256; level<256; level++){
1847 int size, v, l;
1848 /* find number of bits */
1849 size = 0;
1850 v = abs(level);
1851 while (v) {
1852 v >>= 1;
1853 size++;
1854 }
1855
1856 if (level < 0)
1857 l= (-level) ^ ((1 << size) - 1);
1858 else
1859 l= level;
1860
1861 /* luminance */
1862 uni_code= DCtab_lum[size][0];
1863 uni_len = DCtab_lum[size][1];
1864
1865 if (size > 0) {
1866 uni_code<<=size; uni_code|=l;
1867 uni_len+=size;
1868 if (size > 8){
1869 uni_code<<=1; uni_code|=1;
1870 uni_len++;
1871 }
1872 }
1873 uni_DCtab_lum_bits[level+256]= uni_code;
1874 uni_DCtab_lum_len [level+256]= uni_len;
1875
1876 /* chrominance */
1877 uni_code= DCtab_chrom[size][0];
1878 uni_len = DCtab_chrom[size][1];
1879
1880 if (size > 0) {
1881 uni_code<<=size; uni_code|=l;
1882 uni_len+=size;
1883 if (size > 8){
1884 uni_code<<=1; uni_code|=1;
1885 uni_len++;
1886 }
1887 }
1888 uni_DCtab_chrom_bits[level+256]= uni_code;
1889 uni_DCtab_chrom_len [level+256]= uni_len;
1890
1891 }
1892 }
1893
1894 #endif //CONFIG_ENCODERS
1895
1896 #ifdef CONFIG_ENCODERS
1897 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1898 int slevel, run, last;
1899
1900 assert(MAX_LEVEL >= 64);
1901 assert(MAX_RUN >= 63);
1902
1903 for(slevel=-64; slevel<64; slevel++){
1904 if(slevel==0) continue;
1905 for(run=0; run<64; run++){
1906 for(last=0; last<=1; last++){
1907 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1908 int level= slevel < 0 ? -slevel : slevel;
1909 int sign= slevel < 0 ? 1 : 0;
1910 int bits, len, code;
1911 int level1, run1;
1912
1913 len_tab[index]= 100;
1914
1915 /* ESC0 */
1916 code= get_rl_index(rl, last, run, level);
1917 bits= rl->table_vlc[code][0];
1918 len= rl->table_vlc[code][1];
1919 bits=bits*2+sign; len++;
1920
1921 if(code!=rl->n && len < len_tab[index]){
1922 bits_tab[index]= bits;
1923 len_tab [index]= len;
1924 }
1925 #if 1
1926 /* ESC1 */
1927 bits= rl->table_vlc[rl->n][0];
1928 len= rl->table_vlc[rl->n][1];
1929 bits=bits*2; len++; //esc1
1930 level1= level - rl->max_level[last][run];
1931 if(level1>0){
1932 code= get_rl_index(rl, last, run, level1);
1933 bits<<= rl->table_vlc[code][1];
1934 len += rl->table_vlc[code][1];
1935 bits += rl->table_vlc[code][0];
1936 bits=bits*2+sign; len++;
1937
1938 if(code!=rl->n && len < len_tab[index]){
1939 bits_tab[index]= bits;
1940 len_tab [index]= len;
1941 }
1942 }
1943 #endif
1944 #if 1
1945 /* ESC2 */
1946 bits= rl->table_vlc[rl->n][0];
1947 len= rl->table_vlc[rl->n][1];
1948 bits=bits*4+2; len+=2; //esc2
1949 run1 = run - rl->max_run[last][level] - 1;
1950 if(run1>=0){
1951 code= get_rl_index(rl, last, run1, level);
1952 bits<<= rl->table_vlc[code][1];
1953 len += rl->table_vlc[code][1];
1954 bits += rl->table_vlc[code][0];
1955 bits=bits*2+sign; len++;
1956
1957 if(code!=rl->n && len < len_tab[index]){
1958 bits_tab[index]= bits;
1959 len_tab [index]= len;
1960 }
1961 }
1962 #endif
1963 /* ESC3 */
1964 bits= rl->table_vlc[rl->n][0];
1965 len = rl->table_vlc[rl->n][1];
1966 bits=bits*4+3; len+=2; //esc3
1967 bits=bits*2+last; len++;
1968 bits=bits*64+run; len+=6;
1969 bits=bits*2+1; len++; //marker
1970 bits=bits*4096+(slevel&0xfff); len+=12;
1971 bits=bits*2+1; len++; //marker
1972
1973 if(len < len_tab[index]){
1974 bits_tab[index]= bits;
1975 len_tab [index]= len;
1976 }
1977 }
1978 }
1979 }
1980 }
1981
1982 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1983 int slevel, run, last;
1984
1985 assert(MAX_LEVEL >= 64);
1986 assert(MAX_RUN >= 63);
1987
1988 for(slevel=-64; slevel<64; slevel++){
1989 if(slevel==0) continue;
1990 for(run=0; run<64; run++){
1991 for(last=0; last<=1; last++){
1992 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1993 int level= slevel < 0 ? -slevel : slevel;
1994 int sign= slevel < 0 ? 1 : 0;
1995 int bits, len, code;
1996
1997 len_tab[index]= 100;
1998
1999 /* ESC0 */
2000 code= get_rl_index(rl, last, run, level);
2001 bits= rl->table_vlc[code][0];
2002 len= rl->table_vlc[code][1];
2003 bits=bits*2+sign; len++;
2004
2005 if(code!=rl->n && len < len_tab[index]){
2006 if(bits_tab) bits_tab[index]= bits;
2007 len_tab [index]= len;
2008 }
2009 /* ESC */
2010 bits= rl->table_vlc[rl->n][0];
2011 len = rl->table_vlc[rl->n][1];
2012 bits=bits*2+last; len++;
2013 bits=bits*64+run; len+=6;
2014 bits=bits*256+(level&0xff); len+=8;
2015
2016 if(len < len_tab[index]){
2017 if(bits_tab) bits_tab[index]= bits;
2018 len_tab [index]= len;
2019 }
2020 }
2021 }
2022 }
2023 }
2024
2025 void h263_encode_init(MpegEncContext *s)
2026 {
2027 static int done = 0;
2028
2029 if (!done) {
2030 done = 1;
2031
2032 init_uni_dc_tab();
2033
2034 init_rl(&rl_inter, static_rl_table_store[0]);
2035 init_rl(&rl_intra, static_rl_table_store[1]);
2036 init_rl(&rl_intra_aic, static_rl_table_store[2]);
2037
2038 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2039 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2040
2041 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2042 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
2043
2044 init_mv_penalty_and_fcode(s);
2045 }
2046 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2047
2048 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
2049 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2050 if(s->h263_aic){
2051 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
2052 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2053 }
2054 s->ac_esc_length= 7+1+6+8;
2055
2056 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2057 switch(s->codec_id){
2058 case CODEC_ID_MPEG4:
2059 s->fcode_tab= fcode_tab;
2060 s->min_qcoeff= -2048;
2061 s->max_qcoeff= 2047;
2062 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2063 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2064 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2065 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2066 s->luma_dc_vlc_length= uni_DCtab_lum_len;
2067 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2068 s->ac_esc_length= 7+2+1+6+1+12+1;
2069 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2070 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2071
2072 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2073
2074 s->avctx->extradata= av_malloc(1024);
2075 init_put_bits(&s->pb, s->avctx->extradata, 1024);
2076
2077 if(!(s->workaround_bugs & FF_BUG_MS))
2078 mpeg4_encode_visual_object_header(s);
2079 mpeg4_encode_vol_header(s, 0, 0);
2080
2081 // ff_mpeg4_stuffing(&s->pb); ?
2082 flush_put_bits(&s->pb);
2083 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2084 }
2085
2086 break;
2087 case CODEC_ID_H263P:
2088 if(s->umvplus)
2089 s->fcode_tab= umv_fcode_tab;
2090 if(s->modified_quant){
2091 s->min_qcoeff= -2047;
2092 s->max_qcoeff= 2047;
2093 }else{
2094 s->min_qcoeff= -127;
2095 s->max_qcoeff= 127;
2096 }
2097 break;
2098 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2099 case CODEC_ID_FLV1:
2100 if (s->h263_flv > 1) {
2101 s->min_qcoeff= -1023;
2102 s->max_qcoeff= 1023;
2103 } else {
2104 s->min_qcoeff= -127;
2105 s->max_qcoeff= 127;
2106 }
2107 s->y_dc_scale_table=
2108 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2109 break;
2110 default: //nothing needed - default table already set in mpegvideo.c
2111 s->min_qcoeff= -127;
2112 s->max_qcoeff= 127;
2113 s->y_dc_scale_table=
2114 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2115 }
2116 }
2117
2118 /**
2119 * encodes a 8x8 block.
2120 * @param block the 8x8 block
2121 * @param n block index (0-3 are luma, 4-5 are chroma)
2122 */
2123 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2124 {
2125 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2126 RLTable *rl;
2127
2128 rl = &rl_inter;
2129 if (s->mb_intra && !s->h263_aic) {
2130 /* DC coef */
2131 level = block[0];
2132 /* 255 cannot be represented, so we clamp */
2133 if (level > 254) {
2134 level = 254;
2135 block[0] = 254;
2136 }
2137 /* 0 cannot be represented also */
2138 else if (level < 1) {
2139 level = 1;
2140 block[0] = 1;
2141 }
2142 if (level == 128) //FIXME check rv10
2143 put_bits(&s->pb, 8, 0xff);
2144 else
2145 put_bits(&s->pb, 8, level);
2146 i = 1;
2147 } else {
2148 i = 0;
2149 if (s->h263_aic && s->mb_intra)
2150 rl = &rl_intra_aic;
2151
2152 if(s->alt_inter_vlc && !s->mb_intra){
2153 int aic_vlc_bits=0;
2154 int inter_vlc_bits=0;
2155 int wrong_pos=-1;
2156 int aic_code;
2157
2158 last_index = s->block_last_index[n];
2159 last_non_zero = i - 1;
2160 for (; i <= last_index; i++) {
2161 j = s->intra_scantable.permutated[i];
2162 level = block[j];
2163 if (level) {
2164 run = i - last_non_zero - 1;
2165 last = (i == last_index);
2166
2167 if(level<0) level= -level;
2168
2169 code = get_rl_index(rl, last, run, level);
2170 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2171 inter_vlc_bits += rl->table_vlc[code][1]+1;
2172 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2173
2174 if (code == rl->n) {
2175 inter_vlc_bits += 1+6+8-1;
2176 }
2177 if (aic_code == rl_intra_aic.n) {
2178 aic_vlc_bits += 1+6+8-1;
2179 wrong_pos += run + 1;
2180 }else
2181 wrong_pos += wrong_run[aic_code];
2182 last_non_zero = i;
2183 }
2184 }
2185 i = 0;
2186 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2187 rl = &rl_intra_aic;
2188 }
2189 }
2190
2191 /* AC coefs */
2192 last_index = s->block_last_index[n];
2193 last_non_zero = i - 1;
2194 for (; i <= last_index; i++) {
2195 j = s->intra_scantable.permutated[i];
2196 level = block[j];
2197 if (level) {
2198 run = i - last_non_zero - 1;
2199 last = (i == last_index);
2200 sign = 0;
2201 slevel = level;
2202 if (level < 0) {
2203 sign = 1;
2204 level = -level;
2205 }
2206 code = get_rl_index(rl, last, run, level);
2207 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2208 if (code == rl->n) {
2209 if(s->h263_flv <= 1){
2210 put_bits(&s->pb, 1, last);
2211 put_bits(&s->pb, 6, run);
2212
2213 assert(slevel != 0);
2214
2215 if(level < 128)
2216 put_bits(&s->pb, 8, slevel & 0xff);
2217 else{
2218 put_bits(&s->pb, 8, 128);
2219 put_bits(&s->pb, 5, slevel & 0x1f);
2220 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2221 }
2222 }else{
2223 if(level < 64) { // 7-bit level
2224 put_bits(&s->pb, 1, 0);
2225 put_bits(&s->pb, 1, last);
2226 put_bits(&s->pb, 6, run);
2227
2228 put_bits(&s->pb, 7, slevel & 0x7f);
2229 } else {
2230 /* 11-bit level */
2231 put_bits(&s->pb, 1, 1);
2232 put_bits(&s->pb, 1, last);
2233 put_bits(&s->pb, 6, run);
2234
2235 put_bits(&s->pb, 11, slevel & 0x7ff);
2236 }
2237 }
2238 } else {
2239 put_bits(&s->pb, 1, sign);
2240 }
2241 last_non_zero = i;
2242 }
2243 }
2244 }
2245 #endif
2246
2247 #ifdef CONFIG_ENCODERS
2248
2249 /***************************************************/
2250 /**
2251 * add mpeg4 stuffing bits (01...1)
2252 */
2253 void ff_mpeg4_stuffing(PutBitContext * pbc)
2254 {
2255 int length;
2256 put_bits(pbc, 1, 0);
2257 length= (-put_bits_count(pbc))&7;
2258 if(length) put_bits(pbc, length, (1<<length)-1);
2259 }
2260
2261 /* must be called before writing the header */
2262 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2263 int time_div, time_mod;
2264
2265 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2266 s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2267
2268 time_div= s->time/s->avctx->time_base.den;
2269 time_mod= s->time%s->avctx->time_base.den;
2270
2271 if(s->pict_type==B_TYPE){
2272 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2273 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2274 ff_mpeg4_init_direct_mv(s);
2275 }else{
2276 s->last_time_base= s->time_base;
2277 s->time_base= time_div;
2278 s->pp_time= s->time - s->last_non_b_time;
2279 s->last_non_b_time= s->time;
2280 assert(picture_number==0 || s->pp_time > 0);
2281 }
2282 }
2283
2284 static void mpeg4_encode_gop_header(MpegEncContext * s){
2285 int hours, minutes, seconds;
2286 int64_t time;
2287
2288 put_bits(&s->pb, 16, 0);
2289 put_bits(&s->pb, 16, GOP_STARTCODE);
2290
2291 time= s->current_picture_ptr->pts;
2292 if(s->reordered_input_picture[1])
2293 time= FFMIN(time, s->reordered_input_picture[1]->pts);
2294 time= time*s->avctx->time_base.num;
2295
2296 seconds= time/s->avctx->time_base.den;
2297 minutes= seconds/60; seconds %= 60;
2298 hours= minutes/60; minutes %= 60;
2299 hours%=24;
2300
2301 put_bits(&s->pb, 5, hours);
2302 put_bits(&s->pb, 6, minutes);
2303 put_bits(&s->pb, 1, 1);
2304 put_bits(&s->pb, 6, seconds);
2305
2306 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2307 put_bits(&s->pb, 1, 0); //broken link == NO
2308
2309 s->last_time_base= time / s->avctx->time_base.den;
2310
2311 ff_mpeg4_stuffing(&s->pb);
2312 }
2313
2314 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2315 int profile_and_level_indication;
2316 int vo_ver_id;
2317
2318 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2319 profile_and_level_indication = s->avctx->profile << 4;
2320 }else if(s->max_b_frames || s->quarter_sample){
2321 profile_and_level_indication= 0xF0; // adv simple
2322 }else{
2323 profile_and_level_indication= 0x00; // simple
2324 }
2325
2326 if(s->avctx->level != FF_LEVEL_UNKNOWN){
2327 profile_and_level_indication |= s->avctx->level;
2328 }else{
2329 profile_and_level_indication |= 1; //level 1
2330 }
2331
2332 if(profile_and_level_indication>>4 == 0xF){
2333 vo_ver_id= 5;
2334 }else{
2335 vo_ver_id= 1;
2336 }
2337
2338 //FIXME levels
2339
2340 put_bits(&s->pb, 16, 0);
2341 put_bits(&s->pb, 16, VOS_STARTCODE);
2342
2343 put_bits(&s->pb, 8, profile_and_level_indication);
2344
2345 put_bits(&s->pb, 16, 0);
2346 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2347
2348 put_bits(&s->pb, 1, 1);
2349 put_bits(&s->pb, 4, vo_ver_id);
2350 put_bits(&s->pb, 3, 1); //priority
2351
2352 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2353
2354 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2355
2356 ff_mpeg4_stuffing(&s->pb);
2357 }
2358
2359 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2360 {
2361 int vo_ver_id;
2362
2363 if(s->max_b_frames || s->quarter_sample){
2364 vo_ver_id= 5;
2365 s->vo_type= ADV_SIMPLE_VO_TYPE;
2366 }else{
2367 vo_ver_id= 1;
2368 s->vo_type= SIMPLE_VO_TYPE;
2369 }
2370
2371 put_bits(&s->pb, 16, 0);
2372 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2373 put_bits(&s->pb, 16, 0);
2374 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2375
2376 put_bits(&s->pb, 1, 0); /* random access vol */
2377 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2378 if(s->workaround_bugs & FF_BUG_MS) {
2379 put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2380 } else {
2381 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2382 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2383 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2384 }
2385
2386 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2387
2388 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2389 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2390 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2391 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2392 }
2393
2394 if(s->workaround_bugs & FF_BUG_MS) { //
2395 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2396 } else {
2397 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2398 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2399 put_bits(&s->pb, 1, s->low_delay);
2400 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2401 }
2402
2403 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2404 put_bits(&s->pb, 1, 1); /* marker bit */
2405
2406 put_bits(&s->pb, 16, s->avctx->time_base.den);
2407 if (s->time_increment_bits < 1)
2408 s->time_increment_bits = 1;
2409 put_bits(&s->pb, 1, 1); /* marker bit */
2410 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2411 put_bits(&s->pb, 1, 1); /* marker bit */
2412 put_bits(&s->pb, 13, s->width); /* vol width */
2413 put_bits(&s->pb, 1, 1); /* marker bit */
2414 put_bits(&s->pb, 13, s->height); /* vol height */
2415 put_bits(&s->pb, 1, 1); /* marker bit */
2416 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2417 put_bits(&s->pb, 1, 1); /* obmc disable */
2418 if (vo_ver_id == 1) {
2419 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2420 }else{
2421 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2422 }
2423
2424 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2425 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2426
2427 if(s->mpeg_quant){
2428 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2429 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2430 }
2431
2432 if (vo_ver_id != 1)
2433 put_bits(&s->pb, 1, s->quarter_sample);
2434 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2435 s->resync_marker= s->rtp_mode;
2436 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2437 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2438 if(s->data_partitioning){
2439 put_bits(&s->pb, 1, 0); /* no rvlc */
2440 }
2441
2442 if (vo_ver_id != 1){
2443 put_bits(&s->pb, 1, 0); /* newpred */
2444 put_bits(&s->pb, 1, 0); /* reduced res vop */
2445 }
2446 put_bits(&s->pb, 1, 0); /* scalability */
2447
2448 ff_mpeg4_stuffing(&s->pb);
2449
2450 /* user data */
2451 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2452 put_bits(&s->pb, 16, 0);
2453 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2454 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2455 }
2456 }
2457
2458 /* write mpeg4 VOP header */
2459 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2460 {
2461 int time_incr;
2462 int time_div, time_mod;
2463
2464 if(s->pict_type==I_TYPE){
2465 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2466 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2467 mpeg4_encode_visual_object_header(s);
2468 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2469 mpeg4_encode_vol_header(s, 0, 0);
2470 }
2471 if(!(s->workaround_bugs & FF_BUG_MS))
2472 mpeg4_encode_gop_header(s);
2473 }
2474
2475 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2476
2477 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2478
2479 put_bits(&s->pb, 16, 0); /* vop header */
2480 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2481 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2482
2483 assert(s->time>=0);
2484 time_div= s->time/s->avctx->time_base.den;
2485 time_mod= s->time%s->avctx->time_base.den;
2486 time_incr= time_div - s->last_time_base;
2487 assert(time_incr >= 0);
2488 while(time_incr--)
2489 put_bits(&s->pb, 1, 1);
2490
2491 put_bits(&s->pb, 1, 0);
2492
2493 put_bits(&s->pb, 1, 1); /* marker */
2494 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2495 put_bits(&s->pb, 1, 1); /* marker */
2496 put_bits(&s->pb, 1, 1); /* vop coded */
2497 if ( s->pict_type == P_TYPE
2498 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2499 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2500 }
2501 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2502 if(!s->progressive_sequence){
2503 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2504 put_bits(&s->pb, 1, s->alternate_scan);
2505 }
2506 //FIXME sprite stuff
2507
2508 put_bits(&s->pb, 5, s->qscale);
2509
2510 if (s->pict_type != I_TYPE)
2511 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2512 if (s->pict_type == B_TYPE)
2513 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2514 // printf("****frame %d\n", picture_number);
2515 }
2516
2517 #endif //CONFIG_ENCODERS
2518
2519 /**
2520 * set qscale and update qscale dependent variables.
2521 */
2522 void ff_set_qscale(MpegEncContext * s, int qscale)
2523 {
2524 if (qscale < 1)
2525 qscale = 1;
2526 else if (qscale > 31)
2527 qscale = 31;
2528
2529 s->qscale = qscale;
2530 s->chroma_qscale= s->chroma_qscale_table[qscale];
2531
2532 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2533 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2534 }
2535
2536 /**
2537 * predicts the dc.
2538 * encoding quantized level -> quantized diff
2539 * decoding quantized diff -> quantized level
2540 * @param n block index (0-3 are luma, 4-5 are chroma)
2541 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2542 */
2543 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2544 {
2545 int a, b, c, wrap, pred, scale, ret;
2546 int16_t *dc_val;
2547
2548 /* find prediction */
2549 if (n < 4) {
2550 scale = s->y_dc_scale;
2551 } else {
2552 scale = s->c_dc_scale;
2553 }
2554 if(IS_3IV1)
2555 scale= 8;
2556
2557 wrap= s->block_wrap[n];
2558 dc_val = s->dc_val[0] + s->block_index[n];
2559
2560 /* B C
2561 * A X
2562 */
2563 a = dc_val[ - 1];
2564 b = dc_val[ - 1 - wrap];
2565 c = dc_val[ - wrap];
2566
2567 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2568 if(s->first_slice_line && n!=3){
2569 if(n!=2) b=c= 1024;
2570 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2571 }
2572 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2573 if(n==0 || n==4 || n==5)
2574 b=1024;
2575 }
2576
2577 if (abs(a - b) < abs(b - c)) {
2578 pred = c;
2579 *dir_ptr = 1; /* top */
2580 } else {
2581 pred = a;
2582 *dir_ptr = 0; /* left */
2583 }
2584 /* we assume pred is positive */
2585 pred = FASTDIV((pred + (scale >> 1)), scale);
2586
2587 if(encoding){
2588 ret = level - pred;
2589 }else{
2590 level += pred;
2591 ret= level;
2592 if(s->error_resilience>=3){
2593 if(level<0){
2594 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2595 return -1;
2596 }
2597 if(level*scale > 2048 + scale){
2598 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2599 return -1;
2600 }
2601 }
2602 }
2603 level *=scale;
2604 if(level&(~2047)){
2605 if(level<0)
2606 level=0;
2607 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2608 level=2047;
2609 }
2610 dc_val[0]= level;
2611
2612 return ret;
2613 }
2614
2615 /**
2616 * predicts the ac.
2617 * @param n block index (0-3 are luma, 4-5 are chroma)
2618 * @param dir the ac prediction direction
2619 */
2620 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2621 int dir)
2622 {
2623 int i;
2624 int16_t *ac_val, *ac_val1;
2625 int8_t * const qscale_table= s->current_picture.qscale_table;
2626
2627 /* find prediction */
2628 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2629 ac_val1 = ac_val;
2630 if (s->ac_pred) {
2631 if (dir == 0) {
2632 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2633 /* left prediction */
2634 ac_val -= 16;
2635
2636 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2637 /* same qscale */
2638 for(i=1;i<8;i++) {
2639 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2640 }
2641 }else{
2642 /* different qscale, we must rescale */
2643 for(i=1;i<8;i++) {
2644 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2645 }
2646 }
2647 } else {
2648 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2649 /* top prediction */
2650 ac_val -= 16 * s->block_wrap[n];
2651
2652 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2653 /* same qscale */
2654 for(i=1;i<8;i++) {
2655 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2656 }
2657 }else{
2658 /* different qscale, we must rescale */
2659 for(i=1;i<8;i++) {
2660 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2661 }
2662 }
2663 }
2664 }
2665 /* left copy */
2666 for(i=1;i<8;i++)
2667 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2668
2669 /* top copy */
2670 for(i=1;i<8;i++)
2671 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2672
2673 }
2674
2675 #ifdef CONFIG_ENCODERS
2676
2677 /**
2678 * encodes the dc value.
2679 * @param n block index (0-3 are luma, 4-5 are chroma)
2680 */
2681 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2682 {
2683 #if 1
2684 // if(level<-255 || level>255) printf("dc overflow\n");
2685 level+=256;
2686 if (n < 4) {
2687 /* luminance */
2688 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2689 } else {
2690 /* chrominance */
2691 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2692 }
2693 #else
2694 int size, v;
2695 /* find number of bits */
2696 size = 0;
2697 v = abs(level);
2698 while (v) {
2699 v >>= 1;
2700 size++;
2701 }
2702
2703 if (n < 4) {
2704 /* luminance */
2705 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2706 } else {
2707 /* chrominance */
2708 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2709 }
2710
2711 /* encode remaining bits */
2712 if (size > 0) {
2713 if (level < 0)
2714 level = (-level) ^ ((1 << size) - 1);
2715 put_bits(&s->pb, size, level);
2716 if (size > 8)
2717 put_bits(&s->pb, 1, 1);
2718 }
2719 #endif
2720 }
2721
2722 static inline int mpeg4_get_dc_length(int level, int n){
2723 if (n < 4) {
2724 return uni_DCtab_lum_len[level + 256];
2725 } else {
2726 return uni_DCtab_chrom_len[level + 256];
2727 }
2728 }
2729
2730 /**
2731 * encodes a 8x8 block
2732 * @param n block index (0-3 are luma, 4-5 are chroma)
2733 */
2734 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2735 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2736 {
2737 int i, last_non_zero;
2738 #if 0 //variables for the outcommented version
2739 int code, sign, last;
2740 #endif
2741 const RLTable *rl;
2742 uint32_t *bits_tab;
2743 uint8_t *len_tab;
2744 const int last_index = s->block_last_index[n];
2745
2746 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2747 /* mpeg4 based DC predictor */
2748 mpeg4_encode_dc(dc_pb, intra_dc, n);
2749 if(last_index<1) return;
2750 i = 1;
2751 rl = &rl_intra;
2752 bits_tab= uni_mpeg4_intra_rl_bits;
2753 len_tab = uni_mpeg4_intra_rl_len;
2754 } else {
2755 if(last_index<0) return;
2756 i = 0;
2757 rl = &rl_inter;
2758 bits_tab= uni_mpeg4_inter_rl_bits;
2759 len_tab = uni_mpeg4_inter_rl_len;
2760 }
2761
2762 /* AC coefs */
2763 last_non_zero = i - 1;
2764 #if 1
2765 for (; i < last_index; i++) {
2766 int level = block[ scan_table[i] ];
2767 if (level) {
2768 int run = i - last_non_zero - 1;
2769 level+=64;
2770 if((level&(~127)) == 0){
2771 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2772 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2773 }else{ //ESC3
2774 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);
2775 }
2776 last_non_zero = i;
2777 }
2778 }
2779 /*if(i<=last_index)*/{
2780 int level = block[ scan_table[i] ];
2781 int run = i - last_non_zero - 1;
2782 level+=64;
2783 if((level&(~127)) == 0){
2784 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2785 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2786 }else{ //ESC3
2787 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);
2788 }
2789 }
2790 #else
2791 for (; i <= last_index; i++) {
2792 const int slevel = block[ scan_table[i] ];
2793 if (slevel) {
2794 int level;
2795 int run = i - last_non_zero - 1;
2796 last = (i == last_index);
2797 sign = 0;
2798 level = slevel;
2799 if (level < 0) {
2800 sign = 1;
2801 level = -level;
2802 }
2803 code = get_rl_index(rl, last, run, level);
2804 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2805 if (code == rl->n) {
2806 int level1, run1;
2807 level1 = level - rl->max_level[last][run];
2808 if (level1 < 1)
2809 goto esc2;
2810 code = get_rl_index(rl, last, run, level1);
2811 if (code == rl->n) {
2812 esc2:
2813 put_bits(ac_pb, 1, 1);
2814 if (level > MAX_LEVEL)
2815 goto esc3;
2816 run1 = run - rl->max_run[last][level] - 1;
2817 if (run1 < 0)
2818 goto esc3;
2819 code = get_rl_index(rl, last, run1, level);
2820 if (code == rl->n) {
2821 esc3:
2822 /* third escape */
2823 put_bits(ac_pb, 1, 1);
2824 put_bits(ac_pb, 1, last);
2825 put_bits(ac_pb, 6, run);
2826 put_bits(ac_pb, 1, 1);
2827 put_bits(ac_pb, 12, slevel & 0xfff);
2828 put_bits(ac_pb, 1, 1);
2829 } else {
2830 /* second escape */
2831 put_bits(ac_pb, 1, 0);
2832 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2833 put_bits(ac_pb, 1, sign);
2834 }
2835 } else {
2836 /* first escape */
2837 put_bits(ac_pb, 1, 0);
2838 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2839 put_bits(ac_pb, 1, sign);
2840 }
2841 } else {
2842 put_bits(ac_pb, 1, sign);
2843 }
2844 last_non_zero = i;
2845 }
2846 }
2847 #endif
2848 }
2849
2850 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2851 uint8_t *scan_table)
2852 {
2853 int i, last_non_zero;
2854 const RLTable *rl;
2855 uint8_t *len_tab;
2856 const int last_index = s->block_last_index[n];
2857 int len=0;
2858
2859 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2860 /* mpeg4 based DC predictor */
2861 len += mpeg4_get_dc_length(intra_dc, n);
2862 if(last_index<1) return len;
2863 i = 1;
2864 rl = &rl_intra;
2865 len_tab = uni_mpeg4_intra_rl_len;
2866 } else {
2867 if(last_index<0) return 0;
2868 i = 0;
2869 rl = &rl_inter;
2870 len_tab = uni_mpeg4_inter_rl_len;
2871 }
2872
2873 /* AC coefs */
2874 last_non_zero = i - 1;
2875 for (; i < last_index; i++) {
2876 int level = block[ scan_table[i] ];
2877 if (level) {
2878 int run = i - last_non_zero - 1;
2879 level+=64;
2880 if((level&(~127)) == 0){
2881 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2882 len += len_tab[index];
2883 }else{ //ESC3
2884 len += 7+2+1+6+1+12+1;
2885 }
2886 last_non_zero = i;
2887 }
2888 }
2889 /*if(i<=last_index)*/{
2890 int level = block[ scan_table[i] ];
2891 int run = i - last_non_zero - 1;
2892 level+=64;
2893 if((level&(~127)) == 0){
2894 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2895 len += len_tab[index];
2896 }else{ //ESC3
2897 len += 7+2+1+6+1+12+1;
2898 }
2899 }
2900
2901 return len;
2902 }
2903
2904 #endif
2905
2906
2907 /***********************************************/
2908 /* decoding */
2909
2910 static VLC intra_MCBPC_vlc;
2911 static VLC inter_MCBPC_vlc;
2912 static VLC cbpy_vlc;
2913 static VLC mv_vlc;
2914 static VLC dc_lum, dc_chrom;
2915 static VLC sprite_trajectory;
2916 static VLC mb_type_b_vlc;
2917 static VLC h263_mbtype_b_vlc;
2918 static VLC cbpc_b_vlc;
2919
2920 void init_vlc_rl(RLTable *rl, int use_static)
2921 {
2922 int i, q;
2923
2924 /* Return if static table is already initialized */
2925 if(use_static && rl->rl_vlc[0])
2926 return;
2927
2928 init_vlc(&rl->vlc, 9, rl->n + 1,
2929 &rl->table_vlc[0][1], 4, 2,
2930 &rl->table_vlc[0][0], 4, 2, use_static);
2931
2932
2933 for(q=0; q<32; q++){
2934 int qmul= q*2;
2935 int qadd= (q-1)|1;
2936
2937 if(q==0){
2938 qmul=1;
2939 qadd=0;
2940 }
2941 if(use_static)
2942 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2943 else
2944 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2945 for(i=0; i<rl->vlc.table_size; i++){
2946 int code= rl->vlc.table[i][0];
2947 int len = rl->vlc.table[i][1];
2948 int level, run;
2949
2950 if(len==0){ // illegal code
2951 run= 66;
2952 level= MAX_LEVEL;
2953 }else if(len<0){ //more bits needed
2954 run= 0;
2955 level= code;
2956 }else{
2957 if(code==rl->n){ //esc
2958 run= 66;
2959 level= 0;
2960 }else{
2961 run= rl->table_run [code] + 1;
2962 level= rl->table_level[code] * qmul + qadd;
2963 if(code >= rl->last) run+=192;
2964 }
2965 }
2966 rl->rl_vlc[q][i].len= len;
2967 rl->rl_vlc[q][i].level= level;
2968 rl->rl_vlc[q][i].run= run;
2969 }
2970 }
2971 }
2972
2973 /* init vlcs */
2974
2975 /* XXX: find a better solution to handle static init */
2976 void h263_decode_init_vlc(MpegEncContext *s)
2977 {
2978 static int done = 0;
2979
2980 if (!done) {
2981 done = 1;
2982
2983 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2984 intra_MCBPC_bits, 1, 1,
2985 intra_MCBPC_code, 1, 1, 1);
2986 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2987 inter_MCBPC_bits, 1, 1,
2988 inter_MCBPC_code, 1, 1, 1);
2989 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2990 &cbpy_tab[0][1], 2, 1,
2991 &cbpy_tab[0][0], 2, 1, 1);
2992 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2993 &mvtab[0][1], 2, 1,
2994 &mvtab[0][0], 2, 1, 1);
2995 init_rl(&rl_inter, static_rl_table_store[0]);
2996 init_rl(&rl_intra, static_rl_table_store[1]);
2997 init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2998 init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2999 init_rl(&rl_intra_aic, static_rl_table_store[2]);
3000 init_vlc_rl(&rl_inter, 1);
3001 init_vlc_rl(&rl_intra, 1);
3002 init_vlc_rl(&rvlc_rl_inter, 1);
3003 init_vlc_rl(&rvlc_rl_intra, 1);
3004 init_vlc_rl(&rl_intra_aic, 1);
3005 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
3006 &DCtab_lum[0][1], 2, 1,
3007 &DCtab_lum[0][0], 2, 1, 1);
3008 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
3009 &DCtab_chrom[0][1], 2, 1,
3010 &DCtab_chrom[0][0], 2, 1, 1);
3011 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
3012 &sprite_trajectory_tab[0][1], 4, 2,
3013 &sprite_trajectory_tab[0][0], 4, 2, 1);
3014 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
3015 &mb_type_b_tab[0][1], 2, 1,
3016 &mb_type_b_tab[0][0], 2, 1, 1);
3017 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
3018 &h263_mbtype_b_tab[0][1], 2, 1,
3019 &h263_mbtype_b_tab[0][0], 2, 1, 1);
3020 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
3021 &cbpc_b_tab[0][1], 2, 1,
3022 &cbpc_b_tab[0][0], 2, 1, 1);
3023 }
3024 }
3025
3026 /**
3027 * Get the GOB height based on picture height.
3028 */
3029 int ff_h263_get_gob_height(MpegEncContext *s){
3030 if (s->height <= 400)
3031 return 1;
3032 else if (s->height <= 800)
3033 return 2;
3034 else
3035 return 4;
3036 }
3037
3038 int ff_h263_decode_mba(MpegEncContext *s)
3039 {
3040 int i, mb_pos;
3041
3042 for(i=0; i<6; i++){
3043 if(s->mb_num-1 <= ff_mba_max[i]) break;
3044 }
3045 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
3046 s->mb_x= mb_pos % s->mb_width;
3047 s->mb_y= mb_pos / s->mb_width;
3048
3049 return mb_pos;
3050 }
3051
3052 void ff_h263_encode_mba(MpegEncContext *s)
3053 {
3054 int i, mb_pos;
3055
3056 for(i=0; i<6; i++){
3057 if(s->mb_num-1 <= ff_mba_max[i]) break;
3058 }
3059 mb_pos= s->mb_x + s->mb_width*s->mb_y;
3060 put_bits(&s->pb, ff_mba_length[i], mb_pos);
3061 }
3062
3063 /**
3064 * decodes the group of blocks header or slice header.
3065 * @return <0 if an error occured
3066 */
3067 static int h263_decode_gob_header(MpegEncContext *s)
3068 {
3069 unsigned int val, gfid, gob_number;
3070 int left;
3071
3072 /* Check for GOB Start Code */
3073 val = show_bits(&s->gb, 16);
3074 if(val)
3075 return -1;
3076
3077 /* We have a GBSC probably with GSTUFF */
3078 skip_bits(&s->gb, 16); /* Drop the zeros */
3079 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3080 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3081 for(;left>13; left--){
3082 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3083 }
3084 if(left<=13)
3085 return -1;
3086
3087 if(s->h263_slice_structured){
3088 if(get_bits1(&s->gb)==0)
3089 return -1;
3090
3091 ff_h263_decode_mba(s);
3092
3093 if(s->mb_num > 1583)
3094 if(get_bits1(&s->gb)==0)
3095 return -1;
3096
3097 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3098 if(get_bits1(&s->gb)==0)
3099 return -1;
3100 gfid = get_bits(&s->gb, 2); /* GFID */
3101 }else{
3102 gob_number = get_bits(&s->gb, 5); /* GN */
3103 s->mb_x= 0;
3104 s->mb_y= s->gob_index* gob_number;
3105 gfid = get_bits(&s->gb, 2); /* GFID */
3106 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3107 }
3108
3109 if(s->mb_y >= s->mb_height)
3110 return -1;
3111
3112 if(s->qscale==0)
3113 return -1;
3114
3115 return 0;
3116 }
3117
3118 static inline void memsetw(short *tab, int val, int n)
3119 {
3120 int i;
3121 for(i=0;i<n;i++)
3122 tab[i] = val;
3123 }
3124
3125 #ifdef CONFIG_ENCODERS
3126
3127 void ff_mpeg4_init_partitions(MpegEncContext *s)
3128 {
3129 uint8_t *start= pbBufPtr(&s->pb);
3130 uint8_t *end= s->pb.buf_end;
3131 int size= end - start;
3132 int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3133 int tex_size= (size - 2*pb_size)&(~3);
3134
3135 set_put_bits_buffer_size(&s->pb, pb_size);
3136 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3137 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3138 }
3139
3140 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3141 {
3142 const int pb2_len = put_bits_count(&s->pb2 );
3143 const int tex_pb_len= put_bits_count(&s->tex_pb);
3144 const int bits= put_bits_count(&s->pb);
3145
3146 if(s->pict_type==I_TYPE){
3147 put_bits(&s->pb, 19, DC_MARKER);
3148 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3149 s->i_tex_bits+= tex_pb_len;
3150 }else{
3151 put_bits(&s->pb, 17, MOTION_MARKER);
3152 s->misc_bits+=17 + pb2_len;
3153 s->mv_bits+= bits - s->last_bits;
3154 s->p_tex_bits+= tex_pb_len;
3155 }
3156
3157 flush_put_bits(&s->pb2);
3158 flush_put_bits(&s->tex_pb);
3159
3160 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3161 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3162 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3163 s->last_bits= put_bits_count(&s->pb);
3164 }
3165
3166 #endif //CONFIG_ENCODERS
3167
3168 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3169 switch(s->pict_type){
3170 case I_TYPE:
3171 return 16;
3172 case P_TYPE:
3173 case S_TYPE:
3174 return s->f_code+15;
3175 case B_TYPE:
3176 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3177 default:
3178 return -1;
3179 }
3180 }
3181
3182 #ifdef CONFIG_ENCODERS
3183
3184 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3185 {
3186 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3187
3188 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3189 put_bits(&s->pb, 1, 1);
3190
3191 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3192 put_bits(&s->pb, s->quant_precision, s->qscale);
3193 put_bits(&s->pb, 1, 0); /* no HEC */
3194 }
3195
3196 #endif //CONFIG_ENCODERS
3197
3198 /**
3199 * check if the next stuff is a resync marker or the end.
3200 * @return 0 if not
3201 */
3202 static inline int mpeg4_is_resync(MpegEncContext *s){
3203 int bits_count= get_bits_count(&s->gb);
3204 int v= show_bits(&s->gb, 16);
3205
3206 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3207 return 0;
3208 }
3209
3210 while(v<=0xFF){
3211 if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3212 break;
3213 skip_bits(&s->gb, 8+s->pict_type);
3214 bits_count+= 8+s->pict_type;
3215 v= show_bits(&s->gb, 16);
3216 }
3217
3218 if(bits_count + 8 >= s->gb.size_in_bits){
3219 v>>=8;
3220 v|= 0x7F >> (7-(bits_count&7));
3221
3222 if(v==0x7F)
3223 return 1;
3224 }else{
3225 if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3226 int len;
3227 GetBitContext gb= s->gb;
3228
3229 skip_bits(&s->gb, 1);
3230 align_get_bits(&s->gb);
3231
3232 for(len=0; len<32; len++){
3233 if(get_bits1(&s->gb)) break;
3234 }
3235
3236 s->gb= gb;
3237
3238 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3239 return 1;
3240 }
3241 }
3242 return 0;
3243 }
3244
3245 /**
3246 * decodes the next video packet.
3247 * @return <0 if something went wrong
3248 */
3249 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3250 {
3251 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3252 int header_extension=0, mb_num, len;
3253
3254 /* is there enough space left for a video packet + header */
3255 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3256
3257 for(len=0; len<32; len++){
3258 if(get_bits1(&s->gb)) break;
3259 }
3260
3261 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3262 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3263 return -1;
3264 }
3265
3266 if(s->shape != RECT_SHAPE){
3267 header_extension= get_bits1(&s->gb);
3268 //FIXME more stuff here
3269 }
3270
3271 mb_num= get_bits(&s->gb, mb_num_bits);
3272 if(mb_num>=s->mb_num){
3273 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3274 return -1;
3275 }
3276 if(s->pict_type == B_TYPE){
3277 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3278 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3279 }
3280
3281 s->mb_x= mb_num % s->mb_width;
3282 s->mb_y= mb_num / s->mb_width;
3283
3284 if(s->shape != BIN_ONLY_SHAPE){
3285 int qscale= get_bits(&s->gb, s->quant_precision);
3286 if(qscale)
3287 s->chroma_qscale=s->qscale= qscale;
3288 }
3289
3290 if(s->shape == RECT_SHAPE){
3291 header_extension= get_bits1(&s->gb);
3292 }
3293 if(header_extension){
3294 int time_increment;
3295 int time_incr=0;
3296
3297 while (get_bits1(&s->gb) != 0)
3298 time_incr++;
3299
3300 check_marker(&s->gb, "before time_increment in video packed header");
3301 time_increment= get_bits(&s->gb, s->time_increment_bits);
3302 check_marker(&s->gb, "before vop_coding_type in video packed header");
3303
3304 skip_bits(&s->gb, 2); /* vop coding type */
3305 //FIXME not rect stuff here
3306
3307 if(s->shape != BIN_ONLY_SHAPE){
3308 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3309 //FIXME don't just ignore everything
3310 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3311 mpeg4_decode_sprite_trajectory(s, &s->gb);
3312 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3313 }
3314
3315 //FIXME reduced res stuff here
3316
3317 if (s->pict_type != I_TYPE) {
3318 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3319 if(f_code==0){
3320 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3321 }
3322 }
3323 if (s->pict_type == B_TYPE) {
3324 int b_code = get_bits(&s->gb, 3);
3325 if(b_code==0){
3326 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3327 }
3328 }
3329 }
3330 }
3331 //FIXME new-pred stuff
3332
3333 //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));
3334
3335 return 0;
3336 }
3337
3338 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3339 {
3340 int c_wrap, c_xy, l_wrap, l_xy;
3341
3342 l_wrap= s->b8_stride;
3343 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3344 c_wrap= s->mb_stride;
3345 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3346
3347 #if 0
3348 /* clean DC */
3349 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3350 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3351 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3352 #endif
3353
3354 /* clean AC */
3355 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3356 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3357 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3358
3359 /* clean MV */
3360 // we can't clear the MVs as they might be needed by a b frame
3361 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3362 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3363 s->last_mv[0][0][0]=
3364 s->last_mv[0][0][1]=
3365 s->last_mv[1][0][0]=
3366 s->last_mv[1][0][1]= 0;
3367 }
3368
3369 /**
3370 * decodes the group of blocks / video packet header.
3371 * @return <0 if no resync found
3372 */
3373 int ff_h263_resync(MpegEncContext *s){
3374 int left, ret;
3375
3376 if(s->codec_id==CODEC_ID_MPEG4){
3377 skip_bits1(&s->gb);
3378 align_get_bits(&s->gb);
3379 }
3380
3381 if(show_bits(&s->gb, 16)==0){
3382 if(s->codec_id==CODEC_ID_MPEG4)
3383 ret= mpeg4_decode_video_packet_header(s);
3384 else
3385 ret= h263_decode_gob_header(s);
3386 if(ret>=0)
3387 return 0;
3388 }
3389 //ok, it's not where its supposed to be ...
3390 s->gb= s->last_resync_gb;
3391 align_get_bits(&s->gb);
3392 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3393
3394 for(;left>16+1+5+5; left-=8){
3395 if(show_bits(&s->gb, 16)==0){
3396 GetBitContext bak= s->gb;
3397
3398 if(s->codec_id==CODEC_ID_MPEG4)
3399 ret= mpeg4_decode_video_packet_header(s);
3400 else
3401 ret= h263_decode_gob_header(s);
3402 if(ret>=0)
3403 return 0;
3404
3405 s->gb= bak;
3406 }
3407 skip_bits(&s->gb, 8);
3408 }
3409
3410 return -1;
3411 }
3412
3413 /**
3414 * gets the average motion vector for a GMC MB.
3415 * @param n either 0 for the x component or 1 for y
3416 * @returns the average MV for a GMC MB
3417 */
3418 static inline int get_amv(MpegEncContext *s, int n){
3419 int x, y, mb_v, sum, dx, dy, shift;
3420 int len = 1 << (s->f_code + 4);
3421 const int a= s->sprite_warping_accuracy;
3422
3423 if(s->workaround_bugs & FF_BUG_AMV)
3424 len >>= s->quarter_sample;
3425
3426 if(s->real_sprite_warping_points==1){
3427 if(s->divx_version==500 && s->divx_build==413)
3428 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3429 else
3430 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3431 }else{
3432 dx= s->sprite_delta[n][0];
3433 dy= s->sprite_delta[n][1];
3434 shift= s->sprite_shift[0];
3435 if(n) dy -= 1<<(shift + a + 1);
3436 else dx -= 1<<(shift + a + 1);
3437 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3438
3439 sum=0;
3440 for(y=0; y<16; y++){
3441 int v;
3442
3443 v= mb_v + dy*y;
3444 //XXX FIXME optimize
3445 for(x=0; x<16; x++){
3446 sum+= v>>shift;
3447 v+= dx;
3448 }
3449 }
3450 sum= RSHIFT(sum, a+8-s->quarter_sample);
3451 }
3452
3453 if (sum < -len) sum= -len;
3454 else if (sum >= len) sum= len-1;
3455
3456 return sum;
3457 }
3458
3459 /**
3460 * decodes first partition.
3461 * @return number of MBs decoded or <0 if an error occured
3462 */
3463 static int mpeg4_decode_partition_a(MpegEncContext *s){
3464 int mb_num;
3465 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3466
3467 /* decode first partition */
3468 mb_num=0;
3469 s->first_slice_line=1;
3470 for(; s->mb_y<s->mb_height; s->mb_y++){
3471 ff_init_block_index(s);
3472 for(; s->mb_x<s->mb_width; s->mb_x++){
3473 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3474 int cbpc;
3475 int dir=0;
3476
3477 mb_num++;
3478 ff_update_block_index(s);
3479 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3480 s->first_slice_line=0;
3481
3482 if(s->pict_type==I_TYPE){
3483 int i;
3484
3485 do{
3486 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3487 return mb_num-1;
3488 }
3489
3490 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3491 if (cbpc < 0){
3492 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3493 return -1;
3494 }
3495 }while(cbpc == 8);
3496
3497 s->cbp_table[xy]= cbpc & 3;
3498 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3499 s->mb_intra = 1;
3500
3501 if(cbpc & 4) {
3502 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3503 }
3504 s->current_picture.qscale_table[xy]= s->qscale;
3505
3506 s->mbintra_table[xy]= 1;
3507 for(i=0; i<6; i++){
3508 int dc_pred_dir;
3509 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3510 if(dc < 0){
3511 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3512 return -1;
3513 }
3514 dir<<=1;
3515 if(dc_pred_dir) dir|=1;
3516 }
3517 s->pred_dir_table[xy]= dir;
3518 }else{ /* P/S_TYPE */
3519 int mx, my, pred_x, pred_y, bits;
3520 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3521 const int stride= s->b8_stride*2;
3522
3523 try_again:
3524 bits= show_bits(&s->gb, 17);
3525 if(bits==MOTION_MARKER){
3526 return mb_num-1;
3527 }
3528 skip_bits1(&s->gb);
3529 if(bits&0x10000){
3530 /* skip mb */
3531 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3532 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3533 mx= get_amv(s, 0);
3534 my= get_amv(s, 1);
3535 }else{
3536 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3537 mx=my=0;
3538 }
3539 mot_val[0 ]= mot_val[2 ]=
3540 mot_val[0+stride]= mot_val[2+stride]= mx;
3541 mot_val[1 ]= mot_val[3 ]=
3542 mot_val[1+stride]= mot_val[3+stride]= my;
3543
3544 if(s->mbintra_table[xy])
3545 ff_clean_intra_table_entries(s);
3546 continue;
3547 }
3548
3549 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3550 if (cbpc < 0){
3551 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3552 return -1;
3553 }
3554 if(cbpc == 20)
3555 goto try_again;
3556
3557 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3558
3559 s->mb_intra = ((cbpc & 4) != 0);
3560
3561 if(s->mb_intra){
3562 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3563 s->mbintra_table[xy]= 1;
3564 mot_val[0 ]= mot_val[2 ]=
3565 mot_val[0+stride]= mot_val[2+stride]= 0;
3566 mot_val[1 ]= mot_val[3 ]=
3567 mot_val[1+stride]= mot_val[3+stride]= 0;
3568 }else{
3569 if(s->mbintra_table[xy])
3570 ff_clean_intra_table_entries(s);
3571
3572 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3573 s->mcsel= get_bits1(&s->gb);
3574 else s->mcsel= 0;
3575
3576 if ((cbpc & 16) == 0) {
3577 /* 16x16 motion prediction */
3578
3579 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3580 if(!s->mcsel){
3581 mx = h263_decode_motion(s, pred_x, s->f_code);
3582 if (mx >= 0xffff)
3583 return -1;
3584
3585 my = h263_decode_motion(s, pred_y, s->f_code);
3586 if (my >= 0xffff)
3587 return -1;
3588 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3589 } else {
3590 mx = get_amv(s, 0);
3591 my = get_amv(s, 1);
3592 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3593 }
3594
3595 mot_val[0 ]= mot_val[2 ] =
3596 mot_val[0+stride]= mot_val[2+stride]= mx;
3597 mot_val[1 ]= mot_val[3 ]=
3598 mot_val[1+stride]= mot_val[3+stride]= my;
3599 } else {
3600 int i;
3601 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3602 for(i=0;i<4;i++) {
3603 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3604 mx = h263_decode_motion(s, pred_x, s->f_code);
3605 if (mx >= 0xffff)
3606 return -1;
3607
3608 my = h263_decode_motion(s, pred_y, s->f_code);
3609 if (my >= 0xffff)
3610 return -1;
3611 mot_val[0] = mx;
3612 mot_val[1] = my;
3613 }
3614 }
3615 }
3616 }
3617 }
3618 s->mb_x= 0;
3619 }
3620
3621 return mb_num;
3622 }
3623
3624 /**
3625 * decode second partition.
3626 * @return <0 if an error occured
3627 */
3628 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3629 int mb_num=0;
3630 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3631
3632 s->mb_x= s->resync_mb_x;
3633 s->first_slice_line=1;
3634 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3635 ff_init_block_index(s);
3636 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3637 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3638
3639 mb_num++;
3640 ff_update_block_index(s);
3641 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3642 s->first_slice_line=0;
3643
3644 if(s->pict_type==I_TYPE){
3645 int ac_pred= get_bits1(&s->gb);
3646 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3647 if(cbpy<0){
3648 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3649 return -1;
3650 }
3651
3652 s->cbp_table[xy]|= cbpy<<2;
3653 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3654 }else{ /* P || S_TYPE */
3655 if(IS_INTRA(s->current_picture.mb_type[xy])){
3656 int dir=0,i;
3657 int ac_pred = get_bits1(&s->gb);
3658 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3659
3660 if(cbpy<0){
3661 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3662 return -1;
3663 }
3664
3665 if(s->cbp_table[xy] & 8) {
3666 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3667 }
3668 s->current_picture.qscale_table[xy]= s->qscale;
3669
3670 for(i=0; i<6; i++){
3671 int dc_pred_dir;
3672 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3673 if(dc < 0){
3674 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3675 return -1;
3676 }
3677 dir<<=1;
3678 if(dc_pred_dir) dir|=1;
3679 }
3680 s->cbp_table[xy]&= 3; //remove dquant
3681 s->cbp_table[xy]|= cbpy<<2;
3682 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3683 s->pred_dir_table[xy]= dir;
3684 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3685 s->current_picture.qscale_table[xy]= s->qscale;
3686 s->cbp_table[xy]= 0;
3687 }else{
3688 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3689
3690 if(cbpy<0){
3691 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3692 return -1;
3693 }
3694
3695 if(s->cbp_table[xy] & 8) {
3696 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3697 }
3698 s->current_picture.qscale_table[xy]= s->qscale;
3699
3700 s->cbp_table[xy]&= 3; //remove dquant
3701 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3702 }
3703 }
3704 }
3705 if(mb_num >= mb_count) return 0;
3706 s->mb_x= 0;
3707 }
3708 return 0;
3709 }
3710
3711 /**
3712 * decodes the first & second partition
3713 * @return <0 if error (and sets error type in the error_status_table)
3714 */
3715 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3716 {
3717 int mb_num;
3718 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3719 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3720
3721 mb_num= mpeg4_decode_partition_a(s);
3722 if(mb_num<0){
3723 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3724 return -1;
3725 }
3726
3727 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3728 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3729 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3730 return -1;
3731 }
3732
3733 s->mb_num_left= mb_num;
3734
3735 if(s->pict_type==I_TYPE){
3736 while(show_bits(&s->gb, 9) == 1)
3737 skip_bits(&s->gb, 9);
3738 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3739 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3740 return -1;
3741 }
3742 }else{
3743 while(show_bits(&s->gb, 10) == 1)
3744 skip_bits(&s->gb, 10);
3745 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3746 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3747 return -1;
3748 }
3749 }
3750 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3751
3752 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3753 if(s->pict_type==P_TYPE)
3754 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3755 return -1;
3756 }else{
3757 if(s->pict_type==P_TYPE)
3758 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3759 }
3760
3761 return 0;
3762 }
3763
3764 /**
3765 * decode partition C of one MB.
3766 * @return <0 if an error occured
3767 */
3768 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3769 {
3770 int cbp, mb_type;
3771 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3772
3773 mb_type= s->current_picture.mb_type[xy];
3774 cbp = s->cbp_table[xy];
3775
3776 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3777
3778 if(s->current_picture.qscale_table[xy] != s->qscale){
3779 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3780 }
3781
3782 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3783 int i;
3784 for(i=0; i<4; i++){
3785 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3786 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3787 }
3788 s->mb_intra = IS_INTRA(mb_type);
3789
3790 if (IS_SKIP(mb_type)) {
3791 /* skip mb */
3792 for(i=0;i<6;i++)
3793 s->block_last_index[i] = -1;
3794 s->mv_dir = MV_DIR_FORWARD;
3795 s->mv_type = MV_TYPE_16X16;
3796 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3797 s->mcsel=1;
3798 s->mb_skipped = 0;
3799 }else{
3800 s->mcsel=0;
3801 s->mb_skipped = 1;
3802 }
3803 }else if(s->mb_intra){
3804 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3805 }else if(!s->mb_intra){
3806 // s->mcsel= 0; //FIXME do we need to init that
3807
3808 s->mv_dir = MV_DIR_FORWARD;
3809 if (IS_8X8(mb_type)) {
3810 s->mv_type = MV_TYPE_8X8;
3811 } else {
3812 s->mv_type = MV_TYPE_16X16;
3813 }
3814 }
3815 } else { /* I-Frame */
3816 s->mb_intra = 1;
3817 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3818 }
3819
3820 if (!IS_SKIP(mb_type)) {
3821 int i;
3822 s->dsp.clear_blocks(s->block[0]);
3823 /* decode each block */
3824 for (i = 0; i < 6; i++) {
3825 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3826 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3827 return -1;
3828 }
3829 cbp+=cbp;
3830 }
3831 }
3832
3833 /* per-MB end of slice check */
3834
3835 if(--s->mb_num_left <= 0){
3836 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3837 if(mpeg4_is_resync(s))
3838 return SLICE_END;
3839 else
3840 return SLICE_NOEND;
3841 }else{
3842 if(mpeg4_is_resync(s)){
3843 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3844 if(s->cbp_table[xy+delta])
3845 return SLICE_END;
3846 }
3847 return SLICE_OK;
3848 }
3849 }
3850
3851 /**
3852 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3853 */
3854 static void preview_obmc(MpegEncContext *s){
3855 GetBitContext gb= s->gb;
3856
3857 int cbpc, i, pred_x, pred_y, mx, my;
3858 int16_t *mot_val;
3859 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3860 const int stride= s->b8_stride*2;
3861
3862 for(i=0; i<4; i++)
3863 s->block_index[i]+= 2;
3864 for(i=4; i<6; i++)
3865 s->block_index[i]+= 1;
3866 s->mb_x++;
3867
3868 assert(s->pict_type == P_TYPE);
3869
3870 do{
3871 if (get_bits1(&s->gb)) {
3872 /* skip mb */
3873 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3874 mot_val[0 ]= mot_val[2 ]=
3875 mot_val[0+stride]= mot_val[2+stride]= 0;
3876 mot_val[1 ]= mot_val[3 ]=
3877 mot_val[1+stride]= mot_val[3+stride]= 0;
3878
3879 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3880 goto end;
3881 }
3882 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3883 }while(cbpc == 20);
3884
3885 if(cbpc & 4){
3886 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3887 }else{
3888 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3889 if (cbpc & 8) {
3890 if(s->modified_quant){
3891 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3892 else skip_bits(&s->gb, 5);
3893 }else
3894 skip_bits(&s->gb, 2);
3895 }
3896
3897 if ((cbpc & 16) == 0) {
3898 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3899 /* 16x16 motion prediction */
3900 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3901 if (s->umvplus)
3902 mx = h263p_decode_umotion(s, pred_x);
3903 else
3904 mx = h263_decode_motion(s, pred_x, 1);
3905
3906 if (s->umvplus)
3907 my = h263p_decode_umotion(s, pred_y);
3908 else
3909 my = h263_decode_motion(s, pred_y, 1);
3910
3911 mot_val[0 ]= mot_val[2 ]=
3912 mot_val[0+stride]= mot_val[2+stride]= mx;
3913 mot_val[1 ]= mot_val[3 ]=
3914 mot_val[1+stride]= mot_val[3+stride]= my;
3915 } else {
3916 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3917 for(i=0;i<4;i++) {
3918 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3919 if (s->umvplus)
3920 mx = h263p_decode_umotion(s, pred_x);
3921 else
3922 mx = h263_decode_motion(s, pred_x, 1);
3923
3924 if (s->umvplus)
3925 my = h263p_decode_umotion(s, pred_y);
3926 else
3927 my = h263_decode_motion(s, pred_y, 1);
3928 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3929 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3930 mot_val[0] = mx;
3931 mot_val[1] = my;
3932 }
3933 }
3934 }
3935 end:
3936
3937 for(i=0; i<4; i++)
3938 s->block_index[i]-= 2;
3939 for(i=4; i<6; i++)
3940 s->block_index[i]-= 1;
3941 s->mb_x--;
3942
3943 s->gb= gb;
3944 }
3945
3946 static void h263_decode_dquant(MpegEncContext *s){
3947 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3948
3949 if(s->modified_quant){
3950 if(get_bits1(&s->gb))
3951 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3952 else
3953 s->qscale= get_bits(&s->gb, 5);
3954 }else
3955 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3956 ff_set_qscale(s, s->qscale);
3957 }
3958
3959 int ff_h263_decode_mb(MpegEncContext *s,
3960 DCTELEM block[6][64])
3961 {
3962 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3963 int16_t *mot_val;
3964 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3965
3966 assert(!s->h263_pred);
3967
3968 if (s->pict_type == P_TYPE) {
3969 do{
3970 if (get_bits1(&s->gb)) {
3971 /* skip mb */
3972 s->mb_intra = 0;
3973 for(i=0;i<6;i++)
3974 s->block_last_index[i] = -1;
3975 s->mv_dir = MV_DIR_FORWARD;
3976 s->mv_type = MV_TYPE_16X16;
3977 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3978 s->mv[0][0][0] = 0;
3979 s->mv[0][0][1] = 0;
3980 s->mb_skipped = !(s->obmc | s->loop_filter);
3981 goto end;
3982 }
3983 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3984 //fprintf(stderr, "\tCBPC: %d", cbpc);
3985 if (cbpc < 0){
3986 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3987 return -1;
3988 }
3989 }while(cbpc == 20);
3990
3991 s->dsp.clear_blocks(s->block[0]);
3992
3993 dquant = cbpc & 8;
3994 s->mb_intra = ((cbpc & 4) != 0);
3995 if (s->mb_intra) goto intra;
3996
3997 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3998
3999 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4000 cbpy ^= 0xF;
4001
4002 cbp = (cbpc & 3) | (cbpy << 2);
4003 if (dquant) {
4004 h263_decode_dquant(s);
4005 }
4006
4007 s->mv_dir = MV_DIR_FORWARD;
4008 if ((cbpc & 16) == 0) {
4009 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4010 /* 16x16 motion prediction */
4011 s->mv_type = MV_TYPE_16X16;
4012 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4013 if (s->umvplus)
4014 mx = h263p_decode_umotion(s, pred_x);
4015 else
4016 mx = h263_decode_motion(s, pred_x, 1);
4017
4018 if (mx >= 0xffff)
4019 return -1;
4020
4021 if (s->umvplus)
4022 my = h263p_decode_umotion(s, pred_y);
4023 else
4024 my = h263_decode_motion(s, pred_y, 1);
4025
4026 if (my >= 0xffff)
4027 return -1;
4028 s->mv[0][0][0] = mx;
4029 s->mv[0][0][1] = my;
4030
4031 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4032 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4033 } else {
4034 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4035 s->mv_type = MV_TYPE_8X8;
4036 for(i=0;i<4;i++) {
4037 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4038 if (s->umvplus)
4039 mx = h263p_decode_umotion(s, pred_x);
4040 else
4041 mx = h263_decode_motion(s, pred_x, 1);
4042 if (mx >= 0xffff)
4043 return -1;
4044
4045 if (s->umvplus)
4046 my = h263p_decode_umotion(s, pred_y);
4047 else
4048 my = h263_decode_motion(s, pred_y, 1);
4049 if (my >= 0xffff)
4050 return -1;
4051 s->mv[0][i][0] = mx;
4052 s->mv[0][i][1] = my;
4053 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4054 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4055 mot_val[0] = mx;
4056 mot_val[1] = my;
4057 }
4058 }
4059
4060 /* decode each block */
4061 for (i = 0; i < 6; i++) {
4062 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4063 return -1;
4064 cbp+=cbp;
4065 }
4066
4067 if(s->obmc){
4068 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4069 preview_obmc(s);
4070 }
4071 } else if(s->pict_type==B_TYPE) {
4072 int mb_type;
4073 const int stride= s->b8_stride;
4074 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4075 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4076 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4077
4078 //FIXME ugly
4079 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4080 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4081 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4082 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4083
4084 do{
4085 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4086 if (mb_type < 0){
4087 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4088 return -1;
4089 }
4090
4091 mb_type= h263_mb_type_b_map[ mb_type ];
4092 }while(!mb_type);
4093
4094 s->mb_intra = IS_INTRA(mb_type);
4095 if(HAS_CBP(mb_type)){
4096 s->dsp.clear_blocks(s->block[0]);
4097 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4098 if(s->mb_intra){
4099 dquant = IS_QUANT(mb_type);
4100 goto intra;
4101 }
4102
4103 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4104
4105 if (cbpy < 0){
4106 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4107 return -1;
4108 }
4109
4110 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4111 cbpy ^= 0xF;
4112
4113 cbp = (cbpc & 3) | (cbpy << 2);
4114 }else
4115 cbp=0;
4116
4117 assert(!s->mb_intra);
4118
4119 if(IS_QUANT(mb_type)){
4120 h263_decode_dquant(s);
4121 }
4122
4123 if(IS_DIRECT(mb_type)){
4124 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4125 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4126 }else{
4127 s->mv_dir = 0;
4128 s->mv_type= MV_TYPE_16X16;
4129 //FIXME UMV
4130
4131 if(USES_LIST(mb_type, 0)){
4132 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4133 s->mv_dir = MV_DIR_FORWARD;
4134
4135 mx = h263_decode_motion(s, mx, 1);
4136 my = h263_decode_motion(s, my, 1);
4137
4138 s->mv[0][0][0] = mx;
4139 s->mv[0][0][1] = my;
4140 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4141 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4142 }
4143
4144 if(USES_LIST(mb_type, 1)){
4145 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4146 s->mv_dir |= MV_DIR_BACKWARD;
4147
4148 mx = h263_decode_motion(s, mx, 1);
4149 my = h263_decode_motion(s, my, 1);
4150
4151 s->mv[1][0][0] = mx;
4152 s->mv[1][0][1] = my;
4153 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4154 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4155 }
4156 }
4157
4158 s->current_picture.mb_type[xy]= mb_type;
4159
4160 /* decode each block */
4161 for (i = 0; i < 6; i++) {
4162 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4163 return -1;
4164 cbp+=cbp;
4165 }
4166 } else { /* I-Frame */
4167 do{
4168 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4169 if (cbpc < 0){
4170 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4171 return -1;
4172 }
4173 }while(cbpc == 8);
4174
4175 s->dsp.clear_blocks(s->block[0]);
4176
4177 dquant = cbpc & 4;
4178 s->mb_intra = 1;
4179 intra:
4180 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4181 if (s->h263_aic) {
4182 s->ac_pred = get_bits1(&s->gb);
4183 if(s->ac_pred){
4184 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4185
4186 s->h263_aic_dir = get_bits1(&s->gb);
4187 }
4188 }else
4189 s->ac_pred = 0;
4190
4191 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4192 if(cbpy<0){
4193 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4194 return -1;
4195 }
4196 cbp = (cbpc & 3) | (cbpy << 2);
4197 if (dquant) {
4198 h263_decode_dquant(s);
4199 }
4200
4201 /* decode each block */
4202 for (i = 0; i < 6; i++) {
4203 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4204 return -1;
4205 cbp+=cbp;
4206 }
4207 }
4208 end:
4209
4210 /* per-MB end of slice check */
4211 {
4212 int v= show_bits(&s->gb, 16);
4213
4214 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4215 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4216 }
4217
4218 if(v==0)
4219 return SLICE_END;
4220 }
4221
4222 return SLICE_OK;
4223 }
4224
4225 int ff_mpeg4_decode_mb(MpegEncContext *s,
4226 DCTELEM block[6][64])
4227 {
4228 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4229 int16_t *mot_val;
4230 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4231 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4232
4233 assert(s->h263_pred);
4234
4235 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4236 do{
4237 if (get_bits1(&s->gb)) {
4238 /* skip mb */
4239 s->mb_intra = 0;
4240 for(i=0;i<6;i++)
4241 s->block_last_index[i] = -1;
4242 s->mv_dir = MV_DIR_FORWARD;
4243 s->mv_type = MV_TYPE_16X16;
4244 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4245 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4246 s->mcsel=1;
4247 s->mv[0][0][0]= get_amv(s, 0);
4248 s->mv[0][0][1]= get_amv(s, 1);
4249
4250 s->mb_skipped = 0;
4251 }else{
4252 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4253 s->mcsel=0;
4254 s->mv[0][0][0] = 0;
4255 s->mv[0][0][1] = 0;
4256 s->mb_skipped = 1;
4257 }
4258 goto end;
4259 }
4260 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4261 //fprintf(stderr, "\tCBPC: %d", cbpc);
4262 if (cbpc < 0){
4263 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4264 return -1;
4265 }
4266 }while(cbpc == 20);
4267
4268 s->dsp.clear_blocks(s->block[0]);
4269 dquant = cbpc & 8;
4270 s->mb_intra = ((cbpc & 4) != 0);
4271 if (s->mb_intra) goto intra;
4272
4273 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4274 s->mcsel= get_bits1(&s->gb);
4275 else s->mcsel= 0;
4276 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4277
4278 cbp = (cbpc & 3) | (cbpy << 2);
4279 if (dquant) {
4280 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4281 }
4282 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4283 s->interlaced_dct= get_bits1(&s->gb);
4284
4285 s->mv_dir = MV_DIR_FORWARD;
4286 if ((cbpc & 16) == 0) {
4287 if(s->mcsel){
4288 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4289 /* 16x16 global motion prediction */
4290 s->mv_type = MV_TYPE_16X16;
4291 mx= get_amv(s, 0);
4292 my= get_amv(s, 1);
4293 s->mv[0][0][0] = mx;
4294 s->mv[0][0][1] = my;
4295 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4296 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4297 /* 16x8 field motion prediction */
4298 s->mv_type= MV_TYPE_FIELD;
4299
4300 s->field_select[0][0]= get_bits1(&s->gb);
4301 s->field_select[0][1]= get_bits1(&s->gb);
4302
4303 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4304
4305 for(i=0; i<2; i++){
4306 mx = h263_decode_motion(s, pred_x, s->f_code);
4307 if (mx >= 0xffff)
4308 return -1;
4309
4310 my = h263_decode_motion(s, pred_y/2, s->f_code);
4311 if (my >= 0xffff)
4312 return -1;
4313
4314 s->mv[0][i][0] = mx;
4315 s->mv[0][i][1] = my;
4316 }
4317 }else{
4318 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4319 /* 16x16 motion prediction */
4320 s->mv_type = MV_TYPE_16X16;
4321 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4322 mx = h263_decode_motion(s, pred_x, s->f_code);
4323
4324 if (mx >= 0xffff)
4325 return -1;
4326
4327 my = h263_decode_motion(s, pred_y, s->f_code);
4328
4329 if (my >= 0xffff)
4330 return -1;
4331 s->mv[0][0][0] = mx;
4332 s->mv[0][0][1] = my;
4333 }
4334 } else {
4335 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4336 s->mv_type = MV_TYPE_8X8;
4337 for(i=0;i<4;i++) {
4338 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4339 mx = h263_decode_motion(s, pred_x, s->f_code);
4340 if (mx >= 0xffff)
4341 return -1;
4342
4343 my = h263_decode_motion(s, pred_y, s->f_code);
4344 if (my >= 0xffff)
4345 return -1;
4346 s->mv[0][i][0] = mx;
4347 s->mv[0][i][1] = my;
4348 mot_val[0] = mx;
4349 mot_val[1] = my;
4350 }
4351 }
4352 } else if(s->pict_type==B_TYPE) {
4353 int modb1; // first bit of modb
4354 int modb2; // second bit of modb
4355 int mb_type;
4356
4357 s->mb_intra = 0; //B-frames never contain intra blocks
4358 s->mcsel=0; // ... true gmc blocks
4359
4360 if(s->mb_x==0){
4361 for(i=0; i<2; i++){
4362 s->last_mv[i][0][0]=
4363 s->last_mv[i][0][1]=
4364 s->last_mv[i][1][0]=
4365 s->last_mv[i][1][1]= 0;
4366 }
4367 }
4368
4369 /* if we skipped it in the future P Frame than skip it now too */
4370 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4371
4372 if(s->mb_skipped){
4373 /* skip mb */
4374 for(i=0;i<6;i++)
4375 s->block_last_index[i] = -1;
4376
4377 s->mv_dir = MV_DIR_FORWARD;
4378 s->mv_type = MV_TYPE_16X16;
4379 s->mv[0][0][0] = 0;
4380 s->mv[0][0][1] = 0;
4381 s->mv[1][0][0] = 0;
4382 s->mv[1][0][1] = 0;
4383 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4384 goto end;
4385 }
4386
4387 modb1= get_bits1(&s->gb);
4388 if(modb1){
4389 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4390 cbp=0;
4391 }else{
4392 modb2= get_bits1(&s->gb);
4393 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4394 if(mb_type<0){
4395 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4396 return -1;
4397 }
4398 mb_type= mb_type_b_map[ mb_type ];
4399 if(modb2) cbp= 0;
4400 else{
4401 s->dsp.clear_blocks(s->block[0]);
4402 cbp= get_bits(&s->gb, 6);
4403 }
4404
4405 if ((!IS_DIRECT(mb_type)) && cbp) {
4406 if(get_bits1(&s->gb)){
4407 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4408 }
4409 }
4410
4411 if(!s->progressive_sequence){
4412 if(cbp)
4413 s->interlaced_dct= get_bits1(&s->gb);
4414
4415 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4416 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4417 mb_type &= ~MB_TYPE_16x16;
4418
4419 if(USES_LIST(mb_type, 0)){
4420 s->field_select[0][0]= get_bits1(&s->gb);
4421 s->field_select[0][1]= get_bits1(&s->gb);
4422 }
4423 if(USES_LIST(mb_type, 1)){
4424 s->field_select[1][0]= get_bits1(&s->gb);
4425 s->field_select[1][1]= get_bits1(&s->gb);
4426 }
4427 }
4428 }
4429
4430 s->mv_dir = 0;
4431 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4432 s->mv_type= MV_TYPE_16X16;
4433
4434 if(USES_LIST(mb_type, 0)){
4435 s->mv_dir = MV_DIR_FORWARD;
4436
4437 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4438 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4439 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4440 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4441 }
4442
4443 if(USES_LIST(mb_type, 1)){
4444 s->mv_dir |= MV_DIR_BACKWARD;
4445
4446 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4447 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4448 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4449 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4450 }
4451 }else if(!IS_DIRECT(mb_type)){
4452 s->mv_type= MV_TYPE_FIELD;
4453
4454 if(USES_LIST(mb_type, 0)){
4455 s->mv_dir = MV_DIR_FORWARD;
4456
4457 for(i=0; i<2; i++){
4458 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
4459 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4460 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
4461 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4462 }
4463 }
4464
4465 if(USES_LIST(mb_type, 1)){
4466 s->mv_dir |= MV_DIR_BACKWARD;
4467
4468 for(i=0; i<2; i++){
4469 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
4470 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4471 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
4472 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4473 }
4474 }
4475 }
4476 }
4477
4478 if(IS_DIRECT(mb_type)){
4479 if(IS_SKIP(mb_type))
4480 mx=my=0;
4481 else{
4482 mx = h263_decode_motion(s, 0, 1);
4483 my = h263_decode_motion(s, 0, 1);
4484 }
4485
4486 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4487 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4488 }
4489 s->current_picture.mb_type[xy]= mb_type;
4490 } else { /* I-Frame */
4491 do{
4492 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4493 if (cbpc < 0){
4494 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4495 return -1;
4496 }
4497 }while(cbpc == 8);
4498
4499 dquant = cbpc & 4;
4500 s->mb_intra = 1;
4501 intra:
4502 s->ac_pred = get_bits1(&s->gb);
4503 if(s->ac_pred)
4504 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4505 else
4506 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4507
4508 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4509 if(cbpy<0){
4510 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4511 return -1;
4512 }
4513 cbp = (cbpc & 3) | (cbpy << 2);
4514
4515 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4516
4517 if (dquant) {
4518 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4519 }
4520
4521 if(!s->progressive_sequence)
4522 s->interlaced_dct= get_bits1(&s->gb);
4523
4524 s->dsp.clear_blocks(s->block[0]);
4525 /* decode each block */
4526 for (i = 0; i < 6; i++) {
4527 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4528 return -1;
4529 cbp+=cbp;
4530 }
4531 goto end;
4532 }
4533
4534 /* decode each block */
4535 for (i = 0; i < 6; i++) {
4536 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4537 return -1;
4538 cbp+=cbp;
4539 }
4540 end:
4541
4542 /* per-MB end of slice check */
4543 if(s->codec_id==CODEC_ID_MPEG4){
4544 if(mpeg4_is_resync(s)){
4545 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4546 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4547 return SLICE_OK;
4548 return SLICE_END;
4549 }
4550 }
4551
4552 return SLICE_OK;
4553 }
4554
4555 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4556 {
4557 int code, val, sign, shift, l;
4558 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4559
4560 if (code == 0)
4561 return pred;
4562 if (code < 0)
4563 return 0xffff;
4564
4565 sign = get_bits1(&s->gb);
4566 shift = f_code - 1;
4567 val = code;
4568 if (shift) {
4569 val = (val - 1) << shift;
4570 val |= get_bits(&s->gb, shift);
4571 val++;
4572 }
4573 if (sign)
4574 val = -val;
4575 val += pred;
4576
4577 /* modulo decoding */
4578 if (!s->h263_long_vectors) {
4579 l = INT_BIT - 5 - f_code;
4580 val = (val<<l)>>l;
4581 } else {
4582 /* horrible h263 long vector mode */
4583 if (pred < -31 && val < -63)
4584 val += 64;
4585 if (pred > 32 && val > 63)
4586 val -= 64;
4587
4588 }
4589 return val;
4590 }
4591
4592 /* Decodes RVLC of H.263+ UMV */
4593 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4594 {
4595 int code = 0, sign;
4596
4597 if (get_bits1(&s->gb)) /* Motion difference = 0 */
4598 return pred;
4599
4600 code = 2 + get_bits1(&s->gb);
4601
4602 while (get_bits1(&s->gb))
4603 {
4604 code <<= 1;
4605 code += get_bits1(&s->gb);
4606 }
4607 sign = code & 1;
4608 code >>= 1;
4609
4610 code = (sign) ? (pred - code) : (pred + code);
4611 #ifdef DEBUG
4612 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4613 #endif
4614 return code;
4615
4616 }
4617
4618 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4619 int n, int coded)
4620 {
4621 int code, level, i, j, last, run;
4622 RLTable *rl = &rl_inter;
4623 const uint8_t *scan_table;
4624 GetBitContext gb= s->gb;
4625
4626 scan_table = s->intra_scantable.permutated;
4627 if (s->h263_aic && s->mb_intra) {
4628 rl = &rl_intra_aic;
4629 i = 0;
4630 if (s->ac_pred) {
4631 if (s->h263_aic_dir)
4632 scan_table = s->intra_v_scantable.permutated; /* left */
4633 else
4634 scan_table = s->intra_h_scantable.permutated; /* top */
4635 }
4636 } else if (s->mb_intra) {
4637 /* DC coef */
4638 if(s->codec_id == CODEC_ID_RV10){
4639 #ifdef CONFIG_RV10_DECODER
4640 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4641 int component, diff;
4642 component = (n <= 3 ? 0 : n - 4 + 1);
4643 level = s->last_dc[component];
4644 if (s->rv10_first_dc_coded[component]) {
4645 diff = rv_decode_dc(s, n);
4646 if (diff == 0xffff)
4647 return -1;
4648 level += diff;
4649 level = level & 0xff; /* handle wrap round */
4650 s->last_dc[component] = level;
4651 } else {
4652 s->rv10_first_dc_coded[component] = 1;
4653 }
4654 } else {
4655 level = get_bits(&s->gb, 8);
4656 if (level == 255)
4657 level = 128;
4658 }
4659 #endif
4660 }else{
4661 level = get_bits(&s->gb, 8);
4662 if((level&0x7F) == 0){
4663 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4664 if(s->error_resilience >= FF_ER_COMPLIANT)
4665 return -1;
4666 }
4667 if (level == 255)
4668 level = 128;
4669 }
4670 block[0] = level;
4671 i = 1;
4672 } else {
4673 i = 0;
4674 }
4675 if (!coded) {
4676 if (s->mb_intra && s->h263_aic)
4677 goto not_coded;
4678 s->block_last_index[n] = i - 1;
4679 return 0;
4680 }
4681 retry:
4682 for(;;) {
4683 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4684 if (code < 0){
4685 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4686 return -1;
4687 }
4688 if (code == rl->n) {
4689 /* escape */
4690 if (s->h263_flv > 1) {
4691 int is11 = get_bits1(&s->gb);
4692 last = get_bits1(&s->gb);
4693 run = get_bits(&s->gb, 6);
4694 if(is11){
4695 level = get_sbits(&s->gb, 11);
4696 } else {
4697 level = get_sbits(&s->gb, 7);
4698 }
4699 } else {
4700 last = get_bits1(&s->gb);
4701 run = get_bits(&s->gb, 6);
4702 level = (int8_t)get_bits(&s->gb, 8);
4703 if(level == -128){
4704 if (s->codec_id == CODEC_ID_RV10) {
4705 /* XXX: should patch encoder too */
4706 level = get_sbits(&s->gb, 12);
4707 }else{
4708 level = get_bits(&s->gb, 5);
4709 level |= get_sbits(&s->gb, 6)<<5;
4710 }
4711 }
4712 }
4713 } else {
4714 run = rl->table_run[code];
4715 level = rl->table_level[code];
4716 last = code >= rl->last;
4717 if (get_bits1(&s->gb))
4718 level = -level;
4719 }
4720 i += run;
4721 if (i >= 64){
4722 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4723 //looks like a hack but no, it's the way its supposed to work ...
4724 rl = &rl_intra_aic;
4725 i = 0;
4726 s->gb= gb;
4727 memset(block, 0, sizeof(DCTELEM)*64);
4728 goto retry;
4729 }
4730 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4731 return -1;
4732 }
4733 j = scan_table[i];
4734 block[j] = level;
4735 if (last)
4736 break;
4737 i++;
4738 }
4739 not_coded:
4740 if (s->mb_intra && s->h263_aic) {
4741 h263_pred_acdc(s, block, n);
4742 i = 63;
4743 }
4744 s->block_last_index[n] = i;
4745 return 0;
4746 }
4747
4748 /**
4749 * decodes the dc value.
4750 * @param n block index (0-3 are luma, 4-5 are chroma)
4751 * @param dir_ptr the prediction direction will be stored here
4752 * @return the quantized dc
4753 */
4754 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4755 {
4756 int level, code;
4757
4758 if (n < 4)
4759 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4760 else
4761 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4762 if (code < 0 || code > 9 /* && s->nbit<9 */){
4763 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4764 return -1;
4765 }
4766 if (code == 0) {
4767 level = 0;
4768 } else {
4769 if(IS_3IV1){
4770 if(code==1)
4771 level= 2*get_bits1(&s->gb)-1;
4772 else{
4773 if(get_bits1(&s->gb))
4774 level = get_bits(&s->gb, code-1) + (1<<(code-1));
4775 else
4776 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4777 }
4778 }else{
4779 level = get_xbits(&s->gb, code);
4780 }
4781
4782 if (code > 8){
4783 if(get_bits1(&s->gb)==0){ /* marker */
4784 if(s->error_resilience>=2){
4785 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4786 return -1;
4787 }
4788 }
4789 }
4790 }
4791
4792 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4793 }
4794
4795 /**
4796 * decodes a block.
4797 * @return <0 if an error occured
4798 */
4799 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4800 int n, int coded, int intra, int rvlc)
4801 {
4802 int level, i, last, run;
4803 int dc_pred_dir;
4804 RLTable * rl;
4805 RL_VLC_ELEM * rl_vlc;
4806 const uint8_t * scan_table;
4807 int qmul, qadd;
4808
4809 //Note intra & rvlc should be optimized away if this is inlined
4810
4811 if(intra) {
4812 if(s->use_intra_dc_vlc){
4813 /* DC coef */
4814 if(s->partitioned_frame){
4815 level = s->dc_val[0][ s->block_index[n] ];
4816 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4817 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4818 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4819 }else{
4820 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4821 if (level < 0)
4822 return -1;
4823 }
4824 block[0] = level;
4825 i = 0;
4826 }else{
4827 i = -1;
4828 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4829 }
4830 if (!coded)
4831 goto not_coded;
4832
4833 if(rvlc){
4834 rl = &rvlc_rl_intra;
4835 rl_vlc = rvlc_rl_intra.rl_vlc[0];
4836 }else{
4837 rl = &rl_intra;
4838 rl_vlc = rl_intra.rl_vlc[0];
4839 }
4840 if (s->ac_pred) {
4841 if (dc_pred_dir == 0)
4842 scan_table = s->intra_v_scantable.permutated; /* left */
4843 else
4844 scan_table = s->intra_h_scantable.permutated; /* top */
4845 } else {
4846 scan_table = s->intra_scantable.permutated;
4847 }
4848 qmul=1;
4849 qadd=0;
4850 } else {
4851 i = -1;
4852 if (!coded) {
4853 s->block_last_index[n] = i;
4854 return 0;
4855 }
4856 if(rvlc) rl = &rvlc_rl_inter;
4857 else rl = &rl_inter;
4858
4859 scan_table = s->intra_scantable.permutated;
4860
4861 if(s->mpeg_quant){
4862 qmul=1;
4863 qadd=0;
4864 if(rvlc){
4865 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4866 }else{
4867 rl_vlc = rl_inter.rl_vlc[0];
4868 }
4869 }else{
4870 qmul = s->qscale << 1;
4871 qadd = (s->qscale - 1) | 1;
4872 if(rvlc){
4873 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4874 }else{
4875 rl_vlc = rl_inter.rl_vlc[s->qscale];
4876 }
4877 }
4878 }
4879 {
4880 OPEN_READER(re, &s->gb);
4881 for(;;) {
4882 UPDATE_CACHE(re, &s->gb);
4883 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4884 if (level==0) {
4885 /* escape */
4886 if(rvlc){
4887 if(SHOW_UBITS(re, &s->gb, 1)==0){
4888 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4889 return -1;
4890 }; SKIP_CACHE(re, &s->gb, 1);
4891
4892 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4893 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4894 SKIP_COUNTER(re, &s->gb, 1+1+6);
4895 UPDATE_CACHE(re, &s->gb);
4896
4897 if(SHOW_UBITS(re, &s->gb, 1)==0){
4898 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4899 return -1;
4900 }; SKIP_CACHE(re, &s->gb, 1);
4901
4902 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4903
4904 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4905 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4906 return -1;
4907 }; SKIP_CACHE(re, &s->gb, 5);
4908
4909 level= level * qmul + qadd;
4910 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4911 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4912
4913 i+= run + 1;
4914 if(last) i+=192;
4915 }else{
4916 int cache;
4917 cache= GET_CACHE(re, &s->gb);
4918
4919 if(IS_3IV1)
4920 cache ^= 0xC0000000;
4921
4922 if (cache&0x80000000) {
4923 if (cache&0x40000000) {
4924 /* third escape */
4925 SKIP_CACHE(re, &s->gb, 2);
4926 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4927 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4928 SKIP_COUNTER(re, &s->gb, 2+1+6);
4929 UPDATE_CACHE(re, &s->gb);
4930
4931 if(IS_3IV1){
4932 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4933 }else{
4934 if(SHOW_UBITS(re, &s->gb, 1)==0){
4935 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4936 return -1;
4937 }; SKIP_CACHE(re, &s->gb, 1);
4938
4939 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4940
4941 if(SHOW_UBITS(re, &s->gb, 1)==0){
4942 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4943 return -1;
4944 }; LAST_SKIP_CACHE(re, &s->gb, 1);
4945
4946 SKIP_COUNTER(re, &s->gb, 1+12+1);
4947 }
4948
4949 #if 0
4950 if(s->error_resilience >= FF_ER_COMPLIANT){
4951 const int abs_level= FFABS(level);
4952 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4953 const int run1= run - rl->max_run[last][abs_level] - 1;
4954 if(abs_level <= rl->max_level[last][run]){
4955 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4956 return -1;
4957 }
4958 if(s->error_resilience > FF_ER_COMPLIANT){
4959 if(abs_level <= rl->max_level[last][run]*2){
4960 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4961 return -1;
4962 }
4963 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4964 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4965 return -1;
4966 }
4967 }
4968 }
4969 }
4970 #endif
4971 if (level>0) level= level * qmul + qadd;
4972 else level= level * qmul - qadd;
4973
4974 if((unsigned)(level + 2048) > 4095){
4975 if(s->error_resilience > FF_ER_COMPLIANT){
4976 if(level > 2560 || level<-2560){
4977 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4978 return -1;
4979 }
4980 }
4981 level= level<0 ? -2048 : 2047;
4982 }
4983
4984 i+= run + 1;
4985 if(last) i+=192;
4986 } else {
4987 /* second escape */
4988 #if MIN_CACHE_BITS < 20
4989 LAST_SKIP_BITS(re, &s->gb, 2);
4990 UPDATE_CACHE(re, &s->gb);
4991 #else
4992 SKIP_BITS(re, &s->gb, 2);
4993 #endif
4994 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4995 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4996 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4997 LAST_SKIP_BITS(re, &s->gb, 1);
4998 }
4999 } else {
5000 /* first escape */
5001 #if MIN_CACHE_BITS < 19
5002 LAST_SKIP_BITS(re, &s->gb, 1);
5003 UPDATE_CACHE(re, &s->gb);
5004 #else
5005 SKIP_BITS(re, &s->gb, 1);
5006 #endif
5007 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
5008 i+= run;
5009 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
5010 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
5011 LAST_SKIP_BITS(re, &s->gb, 1);
5012 }
5013 }
5014 } else {
5015 i+= run;
5016 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
5017 LAST_SKIP_BITS(re, &s->gb, 1);
5018 }
5019 if (i > 62){
5020 i-= 192;
5021 if(i&(~63)){
5022 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
5023 return -1;
5024 }
5025
5026 block[scan_table[i]] = level;
5027 break;
5028 }
5029
5030 block[scan_table[i]] = level;
5031 }
5032 CLOSE_READER(re, &s->gb);
5033 }
5034 not_coded:
5035 if (intra) {
5036 if(!s->use_intra_dc_vlc){
5037 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
5038
5039 i -= i>>31; //if(i == -1) i=0;
5040 }
5041
5042 mpeg4_pred_ac(s, block, n, dc_pred_dir);
5043 if (s->ac_pred) {
5044 i = 63; /* XXX: not optimal */
5045 }
5046 }
5047 s->block_last_index[n] = i;
5048 return 0;
5049 }
5050
5051 /* most is hardcoded. should extend to handle all h263 streams */
5052 int h263_decode_picture_header(MpegEncContext *s)
5053 {
5054 int format, width, height, i;
5055 uint32_t startcode;
5056
5057 align_get_bits(&s->gb);
5058
5059 startcode= get_bits(&s->gb, 22-8);
5060
5061 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
5062 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
5063
5064 if(startcode == 0x20)
5065 break;
5066 }
5067
5068 if (startcode != 0x20) {
5069 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5070 return -1;
5071 }
5072 /* temporal reference */
5073 i = get_bits(&s->gb, 8); /* picture timestamp */
5074 if( (s->picture_number&~0xFF)+i < s->picture_number)
5075 i+= 256;
5076 s->current_picture_ptr->pts=
5077 s->picture_number= (s->picture_number&~0xFF) + i;
5078
5079 /* PTYPE starts here */
5080 if (get_bits1(&s->gb) != 1) {
5081 /* marker */
5082 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5083 return -1;
5084 }
5085 if (get_bits1(&s->gb) != 0) {
5086 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5087 return -1; /* h263 id */
5088 }
5089 skip_bits1(&s->gb); /* split screen off */
5090 skip_bits1(&s->gb); /* camera off */
5091 skip_bits1(&s->gb); /* freeze picture release off */
5092
5093 format = get_bits(&s->gb, 3);
5094 /*
5095 0 forbidden
5096 1 sub-QCIF
5097 10 QCIF
5098 7 extended PTYPE (PLUSPTYPE)
5099 */
5100
5101 if (format != 7 && format != 6) {
5102 s->h263_plus = 0;
5103 /* H.263v1 */
5104 width = h263_format[format][0];
5105 height = h263_format[format][1];
5106 if (!width)
5107 return -1;
5108
5109 s->pict_type = I_TYPE + get_bits1(&s->gb);
5110
5111 s->h263_long_vectors = get_bits1(&s->gb);
5112
5113 if (get_bits1(&s->gb) != 0) {
5114 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5115 return -1; /* SAC: off */
5116 }
5117 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5118 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5119
5120 if (get_bits1(&s->gb) != 0) {
5121 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5122 return -1; /* not PB frame */
5123 }
5124 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5125 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5126
5127 s->width = width;
5128 s->height = height;
5129 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5130 s->avctx->time_base= (AVRational){1001, 30000};
5131 } else {
5132 int ufep;
5133
5134 /* H.263v2 */
5135 s->h263_plus = 1;
5136 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5137
5138 /* ufep other than 0 and 1 are reserved */
5139 if (ufep == 1) {
5140 /* OPPTYPE */
5141 format = get_bits(&s->gb, 3);
5142 dprintf(s->avctx, "ufep=1, format: %d\n", format);
5143 s->custom_pcf= get_bits1(&s->gb);
5144 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5145 if (get_bits1(&s->gb) != 0) {
5146 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5147 }
5148 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5149 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5150 s->loop_filter= get_bits1(&s->gb);
5151 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5152
5153 s->h263_slice_structured= get_bits1(&s->gb);
5154 if (get_bits1(&s->gb) != 0) {
5155 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5156 }
5157 if (get_bits1(&s->gb) != 0) {
5158 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5159 }
5160 s->alt_inter_vlc= get_bits1(&s->gb);
5161 s->modified_quant= get_bits1(&s->gb);
5162 if(s->modified_quant)
5163 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5164
5165 skip_bits(&s->gb, 1); /* Prevent start code emulation */
5166
5167 skip_bits(&s->gb, 3); /* Reserved */
5168 } else if (ufep != 0) {
5169 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5170 return -1;
5171 }
5172
5173 /* MPPTYPE */
5174 s->pict_type = get_bits(&s->gb, 3);
5175 switch(s->pict_type){
5176 case 0: s->pict_type= I_TYPE;break;
5177 case 1: s->pict_type= P_TYPE;break;
5178 case 3: s->pict_type= B_TYPE;break;
5179 case 7: s->pict_type= I_TYPE;break; //ZYGO
5180 default:
5181 return -1;
5182 }
5183 skip_bits(&s->gb, 2);
5184 s->no_rounding = get_bits1(&s->gb);
5185 skip_bits(&s->gb, 4);
5186
5187 /* Get the picture dimensions */
5188 if (ufep) {
5189 if (format == 6) {
5190 /* Custom Picture Format (CPFMT) */
5191 s->aspect_ratio_info = get_bits(&s->gb, 4);
5192 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
5193 /* aspect ratios:
5194 0 - forbidden
5195 1 - 1:1
5196 2 - 12:11 (CIF 4:3)
5197 3 - 10:11 (525-type 4:3)
5198 4 - 16:11 (CIF 16:9)
5199 5 - 40:33 (525-type 16:9)
5200 6-14 - reserved
5201 */
5202 width = (get_bits(&s->gb, 9) + 1) * 4;
5203 skip_bits1(&s->gb);
5204 height = get_bits(&s->gb, 9) * 4;
5205 dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
5206 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5207 /* aspected dimensions */
5208 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5209 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5210 }else{
5211 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5212 }
5213 } else {
5214 width = h263_format[format][0];
5215 height = h263_format[format][1];
5216 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5217 }
5218 if ((width == 0) || (height == 0))
5219 return -1;
5220 s->width = width;
5221 s->height = height;
5222
5223 if(s->custom_pcf){
5224 int gcd;
5225 s->avctx->time_base.den= 1800000;
5226 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5227 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5228 if(s->avctx->time_base.num == 0){
5229 av_log(s, AV_LOG_ERROR, "zero framerate\n");
5230 return -1;
5231 }
5232 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5233 s->avctx->time_base.den /= gcd;
5234 s->avctx->time_base.num /= gcd;
5235 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5236 }else{
5237 s->avctx->time_base= (AVRational){1001, 30000};
5238 }
5239 }
5240
5241 if(s->custom_pcf){
5242 skip_bits(&s->gb, 2); //extended Temporal reference
5243 }
5244
5245 if (ufep) {
5246 if (s->umvplus) {
5247 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5248 skip_bits1(&s->gb);
5249 }
5250 if(s->h263_slice_structured){
5251 if (get_bits1(&s->gb) != 0) {
5252 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5253 }
5254 if (get_bits1(&s->gb) != 0) {
5255 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5256 }
5257 }
5258 }
5259
5260 s->qscale = get_bits(&s->gb, 5);
5261 }
5262
5263 s->mb_width = (s->width + 15) / 16;
5264 s->mb_height = (s->height + 15) / 16;
5265 s->mb_num = s->mb_width * s->mb_height;
5266
5267 /* PEI */
5268 while (get_bits1(&s->gb) != 0) {
5269 skip_bits(&s->gb, 8);
5270 }
5271
5272 if(s->h263_slice_structured){
5273 if (get_bits1(&s->gb) != 1) {
5274 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5275 return -1;
5276 }
5277
5278 ff_h263_decode_mba(s);
5279
5280 if (get_bits1(&s->gb) != 1) {
5281 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5282 return -1;
5283 }
5284 }
5285 s->f_code = 1;
5286
5287 if(s->h263_aic){
5288 s->y_dc_scale_table=
5289 s->c_dc_scale_table= ff_aic_dc_scale_table;
5290 }else{
5291 s->y_dc_scale_table=
5292 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5293 }
5294
5295 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5296 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",
5297 s->qscale, av_get_pict_type_char(s->pict_type),
5298 s->gb.size_in_bits, 1-s->no_rounding,
5299 s->obmc ? " AP" : "",
5300 s->umvplus ? " UMV" : "",
5301 s->h263_long_vectors ? " LONG" : "",
5302 s->h263_plus ? " +" : "",
5303 s->h263_aic ? " AIC" : "",
5304 s->alt_inter_vlc ? " AIV" : "",
5305 s->modified_quant ? " MQ" : "",
5306 s->loop_filter ? " LOOP" : "",
5307 s->h263_slice_structured ? " SS" : "",
5308 s->avctx->time_base.den, s->avctx->time_base.num
5309 );
5310 }
5311 #if 1
5312 if (s->pict_type == I_TYPE && s->codec_tag == ff_get_fourcc("ZYGO")){
5313 int i,j;
5314 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5315 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5316 for(i=0; i<13; i++){
5317 for(j=0; j<3; j++){
5318 int v= get_bits(&s->gb, 8);
5319 v |= get_sbits(&s->gb, 8)<<8;
5320 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5321 }
5322 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5323 }
5324 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5325 }
5326 #endif
5327
5328 return 0;
5329 }
5330
5331 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5332 {
5333 int i;
5334 int a= 2<<s->sprite_warping_accuracy;
5335 int rho= 3-s->sprite_warping_accuracy;
5336 int r=16/a;
5337 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5338 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5339 int sprite_ref[4][2];
5340 int virtual_ref[2][2];
5341 int w2, h2, w3, h3;
5342 int alpha=0, beta=0;
5343 int w= s->width;
5344 int h= s->height;
5345 int min_ab;
5346
5347 for(i=0; i<s->num_sprite_warping_points; i++){
5348 int length;
5349 int x=0, y=0;
5350
5351 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5352 if(length){
5353 x= get_xbits(gb, length);
5354 }
5355 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5356
5357 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5358 if(length){
5359 y=get_xbits(gb, length);
5360 }
5361 skip_bits1(gb); /* marker bit */
5362 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5363 d[i][0]= x;
5364 d[i][1]= y;
5365 }
5366
5367 while((1<<alpha)<w) alpha++;
5368 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5369 w2= 1<<alpha;
5370 h2= 1<<beta;
5371
5372 // Note, the 4th point isn't used for GMC
5373 if(s->divx_version==500 && s->divx_build==413){
5374 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5375 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5376 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5377 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5378 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5379 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5380 } else {
5381 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5382 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5383 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5384 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5385 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5386 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5387 }
5388 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5389 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5390
5391 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5392 // perhaps it should be reordered to be more readable ...
5393 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5394 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5395 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5396 + 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);
5397 virtual_ref[0][1]= 16*vop_ref[0][1]
5398 + 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);
5399 virtual_ref[1][0]= 16*vop_ref[0][0]
5400 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
5401 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5402 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
5403
5404 switch(s->num_sprite_warping_points)
5405 {
5406 case 0:
5407 s->sprite_offset[0][0]= 0;
5408 s->sprite_offset[0][1]= 0;
5409 s->sprite_offset[1][0]= 0;
5410 s->sprite_offset[1][1]= 0;
5411 s->sprite_delta[0][0]= a;
5412 s->sprite_delta[0][1]= 0;
5413 s->sprite_delta[1][0]= 0;
5414 s->sprite_delta[1][1]= a;
5415 s->sprite_shift[0]= 0;
5416 s->sprite_shift[1]= 0;
5417 break;
5418 case 1: //GMC only
5419 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5420 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5421 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5422 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5423 s->sprite_delta[0][0]= a;
5424 s->sprite_delta[0][1]= 0;
5425 s->sprite_delta[1][0]= 0;
5426 s->sprite_delta[1][1]= a;
5427 s->sprite_shift[0]= 0;
5428 s->sprite_shift[1]= 0;
5429 break;
5430 case 2:
5431 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5432 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5433 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5434 + (1<<(alpha+rho-1));
5435 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5436 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5437 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5438 + (1<<(alpha+rho-1));
5439 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5440 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5441 +2*w2*r*sprite_ref[0][0]
5442 - 16*w2
5443 + (1<<(alpha+rho+1)));
5444 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5445 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5446 +2*w2*r*sprite_ref[0][1]
5447 - 16*w2
5448 + (1<<(alpha+rho+1)));
5449 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5450 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5451 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5452 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5453
5454 s->sprite_shift[0]= alpha+rho;
5455 s->sprite_shift[1]= alpha+rho+2;
5456 break;
5457 case 3:
5458 min_ab= FFMIN(alpha, beta);
5459 w3= w2>>min_ab;
5460 h3= h2>>min_ab;
5461 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5462 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5463 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5464 + (1<<(alpha+beta+rho-min_ab-1));
5465 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5466 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5467 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5468 + (1<<(alpha+beta+rho-min_ab-1));
5469 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5470 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5471 + 2*w2*h3*r*sprite_ref[0][0]
5472 - 16*w2*h3
5473 + (1<<(alpha+beta+rho-min_ab+1));
5474 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5475 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5476 + 2*w2*h3*r*sprite_ref[0][1]
5477 - 16*w2*h3
5478 + (1<<(alpha+beta+rho-min_ab+1));
5479 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5480 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5481 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5482 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5483
5484 s->sprite_shift[0]= alpha + beta + rho - min_ab;
5485 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5486 break;
5487 }
5488 /* try to simplify the situation */
5489 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5490 && s->sprite_delta[0][1] == 0
5491 && s->sprite_delta[1][0] == 0
5492 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5493 {
5494 s->sprite_offset[0][0]>>=s->sprite_shift[0];
5495 s->sprite_offset[0][1]>>=s->sprite_shift[0];
5496 s->sprite_offset[1][0]>>=s->sprite_shift[1];
5497 s->sprite_offset[1][1]>>=s->sprite_shift[1];
5498 s->sprite_delta[0][0]= a;
5499 s->sprite_delta[0][1]= 0;
5500 s->sprite_delta[1][0]= 0;
5501 s->sprite_delta[1][1]= a;
5502 s->sprite_shift[0]= 0;
5503 s->sprite_shift[1]= 0;
5504 s->real_sprite_warping_points=1;
5505 }
5506 else{
5507 int shift_y= 16 - s->sprite_shift[0];
5508 int shift_c= 16 - s->sprite_shift[1];
5509 //printf("shifts %d %d\n", shift_y, shift_c);
5510 for(i=0; i<2; i++){
5511 s->sprite_offset[0][i]<<= shift_y;
5512 s->sprite_offset[1][i]<<= shift_c;
5513 s->sprite_delta[0][i]<<= shift_y;
5514 s->sprite_delta[1][i]<<= shift_y;
5515 s->sprite_shift[i]= 16;
5516 }
5517 s->real_sprite_warping_points= s->num_sprite_warping_points;
5518 }
5519 #if 0
5520 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5521 vop_ref[0][0], vop_ref[0][1],
5522 vop_ref[1][0], vop_ref[1][1],
5523 vop_ref[2][0], vop_ref[2][1],
5524 sprite_ref[0][0], sprite_ref[0][1],
5525 sprite_ref[1][0], sprite_ref[1][1],
5526 sprite_ref[2][0], sprite_ref[2][1],
5527 virtual_ref[0][0], virtual_ref[0][1],
5528 virtual_ref[1][0], virtual_ref[1][1]
5529 );
5530
5531 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5532 s->sprite_offset[0][0], s->sprite_offset[0][1],
5533 s->sprite_delta[0][0], s->sprite_delta[0][1],
5534 s->sprite_delta[1][0], s->sprite_delta[1][1],
5535 s->sprite_shift[0]
5536 );
5537 #endif
5538 }
5539
5540 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5541 int hours, minutes, seconds;
5542
5543 hours= get_bits(gb, 5);
5544 minutes= get_bits(gb, 6);
5545 skip_bits1(gb);
5546 seconds= get_bits(gb, 6);
5547
5548 s->time_base= seconds + 60*(minutes + 60*hours);
5549
5550 skip_bits1(gb);
5551 skip_bits1(gb);
5552
5553 return 0;
5554 }
5555
5556 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5557 int width, height, vo_ver_id;
5558
5559 /* vol header */
5560 skip_bits(gb, 1); /* random access */
5561 s->vo_type= get_bits(gb, 8);
5562 if (get_bits1(gb) != 0) { /* is_ol_id */
5563 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5564 skip_bits(gb, 3); /* vo_priority */
5565 } else {
5566 vo_ver_id = 1;
5567 }
5568 //printf("vo type:%d\n",s->vo_type);
5569 s->aspect_ratio_info= get_bits(gb, 4);
5570 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5571 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5572 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5573 }else{
5574 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5575 }
5576
5577 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5578 int chroma_format= get_bits(gb, 2);
5579 if(chroma_format!=1){
5580 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5581 }
5582 s->low_delay= get_bits1(gb);
5583 if(get_bits1(gb)){ /* vbv parameters */
5584 get_bits(gb, 15); /* first_half_bitrate */
5585 skip_bits1(gb); /* marker */
5586 get_bits(gb, 15); /* latter_half_bitrate */
5587 skip_bits1(gb); /* marker */
5588 get_bits(gb, 15); /* first_half_vbv_buffer_size */
5589 skip_bits1(gb); /* marker */
5590 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5591 get_bits(gb, 11); /* first_half_vbv_occupancy */
5592 skip_bits1(gb); /* marker */
5593 get_bits(gb, 15); /* latter_half_vbv_occupancy */
5594 skip_bits1(gb); /* marker */
5595 }
5596 }else{
5597 // set low delay flag only once the smartest? low delay detection won't be overriden
5598 if(s->picture_number==0)
5599 s->low_delay=0;
5600 }
5601
5602 s->shape = get_bits(gb, 2); /* vol shape */
5603 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5604 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5605 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5606 skip_bits(gb, 4); //video_object_layer_shape_extension
5607 }
5608
5609 check_marker(gb, "before time_increment_resolution");
5610
5611 s->avctx->time_base.den = get_bits(gb, 16);
5612 if(!s->avctx->time_base.den){
5613 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5614 return -1;
5615 }
5616
5617 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5618 if (s->time_increment_bits < 1)
5619 s->time_increment_bits = 1;
5620
5621 check_marker(gb, "before fixed_vop_rate");
5622
5623 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
5624 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5625 }else
5626 s->avctx->time_base.num = 1;
5627
5628 s->t_frame=0;
5629
5630 if (s->shape != BIN_ONLY_SHAPE) {
5631 if (s->shape == RECT_SHAPE) {
5632 skip_bits1(gb); /* marker */
5633 width = get_bits(gb, 13);
5634 skip_bits1(gb); /* marker */
5635 height = get_bits(gb, 13);
5636 skip_bits1(gb); /* marker */
5637 if(width && height && !(s->width && s->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5638 s->width = width;
5639 s->height = height;
5640 // printf("width/height: %d %d\n", width, height);
5641 }
5642 }
5643
5644 s->progressive_sequence=
5645 s->progressive_frame= get_bits1(gb)^1;
5646 s->interlaced_dct=0;
5647 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5648 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
5649 if (vo_ver_id == 1) {
5650 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5651 } else {
5652 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5653 }
5654 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5655 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5656 if(s->vol_sprite_usage==STATIC_SPRITE){
5657 s->sprite_width = get_bits(gb, 13);
5658 skip_bits1(gb); /* marker */
5659 s->sprite_height= get_bits(gb, 13);
5660 skip_bits1(gb); /* marker */
5661 s->sprite_left = get_bits(gb, 13);
5662 skip_bits1(gb); /* marker */
5663 s->sprite_top = get_bits(gb, 13);
5664 skip_bits1(gb); /* marker */
5665 }
5666 s->num_sprite_warping_points= get_bits(gb, 6);
5667 if(s->num_sprite_warping_points > 3){
5668 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points);
5669 s->num_sprite_warping_points= 0;
5670 return -1;
5671 }
5672 s->sprite_warping_accuracy = get_bits(gb, 2);
5673 s->sprite_brightness_change= get_bits1(gb);
5674 if(s->vol_sprite_usage==STATIC_SPRITE)
5675 s->low_latency_sprite= get_bits1(gb);
5676 }
5677 // FIXME sadct disable bit if verid!=1 && shape not rect
5678
5679 if (get_bits1(gb) == 1) { /* not_8_bit */
5680 s->quant_precision = get_bits(gb, 4); /* quant_precision */
5681 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5682 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5683 } else {
5684 s->quant_precision = 5;
5685 }
5686
5687 // FIXME a bunch of grayscale shape things
5688
5689 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5690 int i, v;
5691
5692 /* load default matrixes */
5693 for(i=0; i<64; i++){
5694 int j= s->dsp.idct_permutation[i];
5695 v= ff_mpeg4_default_intra_matrix[i];
5696 s->intra_matrix[j]= v;
5697 s->chroma_intra_matrix[j]= v;
5698
5699 v= ff_mpeg4_default_non_intra_matrix[i];
5700 s->inter_matrix[j]= v;
5701 s->chroma_inter_matrix[j]= v;
5702 }
5703
5704 /* load custom intra matrix */
5705 if(get_bits1(gb)){
5706 int last=0;
5707 for(i=0; i<64; i++){
5708 int j;
5709 v= get_bits(gb, 8);
5710 if(v==0) break;
5711
5712 last= v;
5713 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5714 s->intra_matrix[j]= v;
5715 s->chroma_intra_matrix[j]= v;
5716 }
5717
5718 /* replicate last value */
5719 for(; i<64; i++){
5720 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5721 s->intra_matrix[j]= last;
5722 s->chroma_intra_matrix[j]= last;
5723 }
5724 }
5725
5726 /* load custom non intra matrix */
5727 if(get_bits1(gb)){
5728 int last=0;
5729 for(i=0; i<64; i++){
5730 int j;
5731 v= get_bits(gb, 8);
5732 if(v==0) break;
5733
5734 last= v;
5735 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5736 s->inter_matrix[j]= v;
5737 s->chroma_inter_matrix[j]= v;
5738 }
5739
5740 /* replicate last value */
5741 for(; i<64; i++){
5742 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5743 s->inter_matrix[j]= last;
5744 s->chroma_inter_matrix[j]= last;
5745 }
5746 }
5747
5748 // FIXME a bunch of grayscale shape things
5749 }
5750
5751 if(vo_ver_id != 1)
5752 s->quarter_sample= get_bits1(gb);
5753 else s->quarter_sample=0;
5754
5755 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5756
5757 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5758
5759 s->data_partitioning= get_bits1(gb);
5760 if(s->data_partitioning){
5761 s->rvlc= get_bits1(gb);
5762 }
5763
5764 if(vo_ver_id != 1) {
5765 s->new_pred= get_bits1(gb);
5766 if(s->new_pred){
5767 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5768 skip_bits(gb, 2); /* requested upstream message type */
5769 skip_bits1(gb); /* newpred segment type */
5770 }
5771 s->reduced_res_vop= get_bits1(gb);
5772 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5773 }
5774 else{
5775 s->new_pred=0;
5776 s->reduced_res_vop= 0;
5777 }
5778
5779 s->scalability= get_bits1(gb);
5780
5781 if (s->scalability) {
5782 GetBitContext bak= *gb;
5783 int ref_layer_id;
5784 int ref_layer_sampling_dir;
5785 int h_sampling_factor_n;
5786 int h_sampling_factor_m;
5787 int v_sampling_factor_n;
5788 int v_sampling_factor_m;
5789
5790 s->hierachy_type= get_bits1(gb);
5791 ref_layer_id= get_bits(gb, 4);
5792 ref_layer_sampling_dir= get_bits1(gb);
5793 h_sampling_factor_n= get_bits(gb, 5);
5794 h_sampling_factor_m= get_bits(gb, 5);
5795 v_sampling_factor_n= get_bits(gb, 5);
5796 v_sampling_factor_m= get_bits(gb, 5);
5797 s->enhancement_type= get_bits1(gb);
5798
5799 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
5800 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5801
5802 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5803 s->scalability=0;
5804
5805 *gb= bak;
5806 }else
5807 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5808
5809 // bin shape stuff FIXME
5810 }
5811 }
5812 return 0;
5813 }
5814
5815 /**
5816 * decodes the user data stuff in the header.
5817 * allso inits divx/xvid/lavc_version/build
5818 */
5819 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5820 char buf[256];
5821 int i;
5822 int e;
5823 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5824 char last;
5825
5826 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
5827 if(show_bits(gb, 23) == 0) break;
5828 buf[i]= get_bits(gb, 8);
5829 }
5830 buf[i]=0;
5831
5832 /* divx detection */
5833 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5834 if(e<2)
5835 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5836 if(e>=2){
5837 s->divx_version= ver;
5838 s->divx_build= build;
5839 s->divx_packed= e==3 && last=='p';
5840 }
5841
5842 /* ffmpeg detection */
5843 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5844 if(e!=4)
5845 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5846 if(e!=4){
5847 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5848 if (e>1)
5849 build= (ver<<16) + (ver2<<8) + ver3;
5850 }
5851 if(e!=4){
5852 if(strcmp(buf, "ffmpeg")==0){
5853 s->lavc_build= 4600;
5854 }
5855 }
5856 if(e==4){
5857 s->lavc_build= build;
5858 }
5859
5860 /* xvid detection */
5861 e=sscanf(buf, "XviD%d", &build);
5862 if(e==1){
5863 s->xvid_build= build;
5864 }
5865
5866 //printf("User Data: %s\n", buf);
5867 return 0;
5868 }
5869
5870 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5871 int time_incr, time_increment;
5872
5873 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
5874 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5875 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5876 s->low_delay=0;
5877 }
5878
5879 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5880 if(s->partitioned_frame)
5881 s->decode_mb= mpeg4_decode_partitioned_mb;
5882 else
5883 s->decode_mb= ff_mpeg4_decode_mb;
5884
5885 time_incr=0;
5886 while (get_bits1(gb) != 0)
5887 time_incr++;
5888
5889 check_marker(gb, "before time_increment");
5890
5891 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5892 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5893
5894 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5895 if(show_bits(gb, s->time_increment_bits+1)&1) break;
5896 }
5897
5898 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5899 }
5900
5901 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5902 else time_increment= get_bits(gb, s->time_increment_bits);
5903
5904 // printf("%d %X\n", s->time_increment_bits, time_increment);
5905 //av_log(s->avctx, AV_LOG_DEBUG, " type:%d modulo_time_base:%d increment:%d t_frame %d\n", s->pict_type, time_incr, time_increment, s->t_frame);
5906 if(s->pict_type!=B_TYPE){
5907 s->last_time_base= s->time_base;
5908 s->time_base+= time_incr;
5909 s->time= s->time_base*s->avctx->time_base.den + time_increment;
5910 if(s->workaround_bugs&FF_BUG_UMP4){
5911 if(s->time < s->last_non_b_time){
5912 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5913 s->time_base++;
5914 s->time+= s->avctx->time_base.den;
5915 }
5916 }
5917 s->pp_time= s->time - s->last_non_b_time;
5918 s->last_non_b_time= s->time;
5919 }else{
5920 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5921 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5922 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5923 // printf("messed up order, maybe after seeking? skipping current b frame\n");
5924 return FRAME_SKIPPED;
5925 }
5926 ff_mpeg4_init_direct_mv(s);
5927
5928 if(s->t_frame==0) s->t_frame= s->pb_time;
5929 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5930 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5931 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5932 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
5933 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5934 if(!s->progressive_sequence){
5935 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
5936 return FRAME_SKIPPED;
5937 }
5938 }
5939 //av_log(s->avctx, AV_LOG_DEBUG, "last nonb %"PRId64" last_base %d time %"PRId64" pp %d pb %d t %d ppf %d pbf %d\n", s->last_non_b_time, s->last_time_base, s->time, s->pp_time, s->pb_time, s->t_frame, s->pp_field_time, s->pb_field_time);
5940
5941 if(s->avctx->time_base.num)
5942 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5943 else
5944 s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5945 if(s->avctx->debug&FF_DEBUG_PTS)
5946 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5947
5948 check_marker(gb, "before vop_coded");
5949
5950 /* vop coded */
5951 if (get_bits1(gb) != 1){
5952 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5953 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5954 return FRAME_SKIPPED;
5955 }
5956 //printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5957 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5958 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5959 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5960 /* rounding type for motion estimation */
5961 s->no_rounding = get_bits1(gb);
5962 } else {
5963 s->no_rounding = 0;
5964 }
5965 //FIXME reduced res stuff
5966
5967 if (s->shape != RECT_SHAPE) {
5968 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5969 int width, height, hor_spat_ref, ver_spat_ref;
5970
5971 width = get_bits(gb, 13);
5972 skip_bits1(gb); /* marker */
5973 height = get_bits(gb, 13);
5974 skip_bits1(gb); /* marker */
5975 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5976 skip_bits1(gb); /* marker */
5977 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5978 }
5979 skip_bits1(gb); /* change_CR_disable */
5980
5981 if (get_bits1(gb) != 0) {
5982 skip_bits(gb, 8); /* constant_alpha_value */
5983 }
5984 }
5985 //FIXME complexity estimation stuff
5986
5987 if (s->shape != BIN_ONLY_SHAPE) {
5988 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5989 if(!s->progressive_sequence){
5990 s->top_field_first= get_bits1(gb);
5991 s->alternate_scan= get_bits1(gb);
5992 }else
5993 s->alternate_scan= 0;
5994 }
5995
5996 if(s->alternate_scan){
5997 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
5998 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
5999 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
6000 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
6001 } else{
6002 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
6003 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
6004 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
6005 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
6006 }
6007
6008 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
6009 mpeg4_decode_sprite_trajectory(s, gb);
6010 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
6011 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
6012 }
6013
6014 if (s->shape != BIN_ONLY_SHAPE) {
6015 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
6016 if(s->qscale==0){
6017 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
6018 return -1; // makes no sense to continue, as there is nothing left from the image then
6019 }
6020
6021 if (s->pict_type != I_TYPE) {
6022 s->f_code = get_bits(gb, 3); /* fcode_for */
6023 if(s->f_code==0){
6024 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
6025 return -1; // makes no sense to continue, as the MV decoding will break very quickly
6026 }
6027 }else
6028 s->f_code=1;
6029
6030 if (s->pict_type == B_TYPE) {
6031 s->b_code = get_bits(gb, 3);
6032 }else
6033 s->b_code=1;
6034
6035 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
6036 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d\n",
6037 s->qscale, s->f_code, s->b_code,
6038 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
6039 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
6040 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
6041 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
6042 }
6043
6044 if(!s->scalability){
6045 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
6046 skip_bits1(gb); // vop shape coding type
6047 }
6048 }else{
6049 if(s->enhancement_type){
6050 int load_backward_shape= get_bits1(gb);
6051 if(load_backward_shape){
6052 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
6053 }
6054 }
6055 skip_bits(gb, 2); //ref_select_code
6056 }
6057 }
6058 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
6059 // note we cannot detect divx5 without b-frames easily (although it's buggy too)
6060 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
6061 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
6062 s->low_delay=1;
6063 }
6064
6065 s->picture_number++; // better than pic number==0 always ;)
6066
6067 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
6068 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
6069
6070 if(s->workaround_bugs&FF_BUG_EDGE){
6071 s->h_edge_pos= s->width;
6072 s->v_edge_pos= s->height;
6073 }
6074 return 0;
6075 }
6076
6077 /**
6078 * decode mpeg4 headers
6079 * @return <0 if no VOP found (or a damaged one)
6080 * FRAME_SKIPPED if a not coded VOP is found
6081 * 0 if a VOP is found
6082 */
6083 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6084 {
6085 int startcode, v;
6086
6087 /* search next start code */
6088 align_get_bits(gb);
6089
6090 if(s->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6091 skip_bits(gb, 24);
6092 if(get_bits(gb, 8) == 0xF0)
6093 return decode_vop_header(s, gb);
6094 }
6095
6096 startcode = 0xff;
6097 for(;;) {
6098 if(get_bits_count(gb) >= gb->size_in_bits){
6099 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6100 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6101 return FRAME_SKIPPED; //divx bug
6102 }else
6103 return -1; //end of stream
6104 }
6105
6106 /* use the bits after the test */
6107 v = get_bits(gb, 8);
6108 startcode = ((startcode << 8) | v) & 0xffffffff;
6109
6110 if((startcode&0xFFFFFF00) != 0x100)
6111 continue; //no startcode
6112
6113 if(s->avctx->debug&FF_DEBUG_STARTCODE){
6114 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6115 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6116 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6117 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6118 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6119 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6120 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6121 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6122 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6123 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6124 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6125 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6126 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6127 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6128 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6129 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6130 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6131 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6132 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6133 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6134 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6135 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6136 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6137 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6138 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6139 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6140 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6141 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6142 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6143 }
6144
6145 if(startcode >= 0x120 && startcode <= 0x12F){
6146 if(decode_vol_header(s, gb) < 0)
6147 return -1;
6148 }
6149 else if(startcode == USER_DATA_STARTCODE){
6150 decode_user_data(s, gb);
6151 }
6152 else if(startcode == GOP_STARTCODE){
6153 mpeg4_decode_gop_header(s, gb);
6154 }
6155 else if(startcode == VOP_STARTCODE){
6156 return decode_vop_header(s, gb);
6157 }
6158
6159 align_get_bits(gb);
6160 startcode = 0xff;
6161 }
6162 }
6163
6164 /* don't understand why they choose a different header ! */
6165 int intel_h263_decode_picture_header(MpegEncContext *s)
6166 {
6167 int format;
6168
6169 /* picture header */
6170 if (get_bits_long(&s->gb, 22) != 0x20) {
6171 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6172 return -1;
6173 }
6174 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6175
6176 if (get_bits1(&s->gb) != 1) {
6177 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6178 return -1; /* marker */
6179 }
6180 if (get_bits1(&s->gb) != 0) {
6181 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6182 return -1; /* h263 id */
6183 }
6184 skip_bits1(&s->gb); /* split screen off */
6185 skip_bits1(&s->gb); /* camera off */
6186 skip_bits1(&s->gb); /* freeze picture release off */
6187
6188 format = get_bits(&s->gb, 3);
6189 if (format != 7) {
6190 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6191 return -1;
6192 }
6193 s->h263_plus = 0;
6194
6195 s->pict_type = I_TYPE + get_bits1(&s->gb);
6196
6197 s->unrestricted_mv = get_bits1(&s->gb);
6198 s->h263_long_vectors = s->unrestricted_mv;
6199
6200 if (get_bits1(&s->gb) != 0) {
6201 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6202 return -1; /* SAC: off */
6203 }
6204 if (get_bits1(&s->gb) != 0) {
6205 s->obmc= 1;
6206 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6207 // return -1; /* advanced prediction mode: off */
6208 }
6209 if (get_bits1(&s->gb) != 0) {
6210 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6211 return -1; /* PB frame mode */
6212 }
6213
6214 /* skip unknown header garbage */
6215 skip_bits(&s->gb, 41);
6216
6217 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6218 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6219
6220 /* PEI */
6221 while (get_bits1(&s->gb) != 0) {
6222 skip_bits(&s->gb, 8);
6223 }
6224 s->f_code = 1;
6225
6226 s->y_dc_scale_table=
6227 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6228
6229 return 0;
6230 }
6231
6232 int flv_h263_decode_picture_header(MpegEncContext *s)
6233 {
6234 int format, width, height;
6235
6236 /* picture header */
6237 if (get_bits_long(&s->gb, 17) != 1) {
6238 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6239 return -1;
6240 }
6241 format = get_bits(&s->gb, 5);
6242 if (format != 0 && format != 1) {
6243 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6244 return -1;
6245 }
6246 s->h263_flv = format+1;
6247 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6248 format = get_bits(&s->gb, 3);
6249 switch (format) {
6250 case 0:
6251 width = get_bits(&s->gb, 8);
6252 height = get_bits(&s->gb, 8);
6253 break;
6254 case 1:
6255 width = get_bits(&s->gb, 16);
6256 height = get_bits(&s->gb, 16);
6257 break;
6258 case 2:
6259 width = 352;
6260 height = 288;
6261 break;
6262 case 3:
6263 width = 176;
6264 height = 144;
6265 break;
6266 case 4:
6267 width = 128;
6268 height = 96;
6269 break;
6270 case 5:
6271 width = 320;
6272 height = 240;
6273 break;
6274 case 6:
6275 width = 160;
6276 height = 120;
6277 break;
6278 default:
6279 width = height = 0;
6280 break;
6281 }
6282 if(avcodec_check_dimensions(s->avctx, width, height))
6283 return -1;
6284 s->width = width;
6285 s->height = height;
6286
6287 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6288 s->dropable= s->pict_type > P_TYPE;
6289 if (s->dropable)
6290 s->pict_type = P_TYPE;
6291
6292 skip_bits1(&s->gb); /* deblocking flag */
6293 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6294
6295 s->h263_plus = 0;
6296
6297 s->unrestricted_mv = 1;
6298 s->h263_long_vectors = 0;
6299
6300 /* PEI */
6301 while (get_bits1(&s->gb) != 0) {
6302 skip_bits(&s->gb, 8);
6303 }
6304 s->f_code = 1;
6305
6306 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6307 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6308 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6309 }
6310
6311 s->y_dc_scale_table=
6312 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6313
6314 return 0;
6315 }
ffmpeg with support for matroska ordered chapters