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