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