?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Check if there is enough bytes before reading the buffer in the EA ADPCM
[ffmpeg-lucabe.git] / libavcodec / h263.c
blob862e98c1ebd0b423bc2d15a145dc8b0c0b14ad54
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 const RLTable *rl;
2829 uint8_t *len_tab;
2830 const int last_index = s->block_last_index[n];
2831 int len=0;
2832
2833 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2834 /* mpeg4 based DC predictor */
2835 len += mpeg4_get_dc_length(intra_dc, n);
2836 if(last_index<1) return len;
2837 i = 1;
2838 rl = &rl_intra;
2839 len_tab = uni_mpeg4_intra_rl_len;
2840 } else {
2841 if(last_index<0) return 0;
2842 i = 0;
2843 rl = &rl_inter;
2844 len_tab = uni_mpeg4_inter_rl_len;
2845 }
2846
2847 /* AC coefs */
2848 last_non_zero = i - 1;
2849 for (; i < last_index; i++) {
2850 int level = block[ scan_table[i] ];
2851 if (level) {
2852 int run = i - last_non_zero - 1;
2853 level+=64;
2854 if((level&(~127)) == 0){
2855 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2856 len += len_tab[index];
2857 }else{ //ESC3
2858 len += 7+2+1+6+1+12+1;
2859 }
2860 last_non_zero = i;
2861 }
2862 }
2863 /*if(i<=last_index)*/{
2864 int level = block[ scan_table[i] ];
2865 int run = i - last_non_zero - 1;
2866 level+=64;
2867 if((level&(~127)) == 0){
2868 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2869 len += len_tab[index];
2870 }else{ //ESC3
2871 len += 7+2+1+6+1+12+1;
2872 }
2873 }
2874
2875 return len;
2876 }
2877
2878 #endif
2879
2880
2881 /***********************************************/
2882 /* decoding */
2883
2884 static VLC intra_MCBPC_vlc;
2885 static VLC inter_MCBPC_vlc;
2886 static VLC cbpy_vlc;
2887 static VLC mv_vlc;
2888 static VLC dc_lum, dc_chrom;
2889 static VLC sprite_trajectory;
2890 static VLC mb_type_b_vlc;
2891 static VLC h263_mbtype_b_vlc;
2892 static VLC cbpc_b_vlc;
2893
2894 /* init vlcs */
2895
2896 /* XXX: find a better solution to handle static init */
2897 void h263_decode_init_vlc(MpegEncContext *s)
2898 {
2899 static int done = 0;
2900
2901 if (!done) {
2902 done = 1;
2903
2904 INIT_VLC_STATIC(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2905 intra_MCBPC_bits, 1, 1,
2906 intra_MCBPC_code, 1, 1, 72);
2907 INIT_VLC_STATIC(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2908 inter_MCBPC_bits, 1, 1,
2909 inter_MCBPC_code, 1, 1, 198);
2910 INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16,
2911 &cbpy_tab[0][1], 2, 1,
2912 &cbpy_tab[0][0], 2, 1, 64);
2913 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33,
2914 &mvtab[0][1], 2, 1,
2915 &mvtab[0][0], 2, 1, 538);
2916 init_rl(&rl_inter, static_rl_table_store[0]);
2917 init_rl(&rl_intra, static_rl_table_store[1]);
2918 init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2919 init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2920 init_rl(&rl_intra_aic, static_rl_table_store[2]);
2921 INIT_VLC_RL(rl_inter, 554);
2922 INIT_VLC_RL(rl_intra, 554);
2923 INIT_VLC_RL(rvlc_rl_inter, 1072);
2924 INIT_VLC_RL(rvlc_rl_intra, 1072);
2925 INIT_VLC_RL(rl_intra_aic, 554);
2926 INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2927 &DCtab_lum[0][1], 2, 1,
2928 &DCtab_lum[0][0], 2, 1, 512);
2929 INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2930 &DCtab_chrom[0][1], 2, 1,
2931 &DCtab_chrom[0][0], 2, 1, 512);
2932 INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2933 &sprite_trajectory_tab[0][1], 4, 2,
2934 &sprite_trajectory_tab[0][0], 4, 2, 128);
2935 INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2936 &mb_type_b_tab[0][1], 2, 1,
2937 &mb_type_b_tab[0][0], 2, 1, 16);
2938 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2939 &h263_mbtype_b_tab[0][1], 2, 1,
2940 &h263_mbtype_b_tab[0][0], 2, 1, 80);
2941 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2942 &cbpc_b_tab[0][1], 2, 1,
2943 &cbpc_b_tab[0][0], 2, 1, 8);
2944 }
2945 }
2946
2947 /**
2948 * Get the GOB height based on picture height.
2949 */
2950 int ff_h263_get_gob_height(MpegEncContext *s){
2951 if (s->height <= 400)
2952 return 1;
2953 else if (s->height <= 800)
2954 return 2;
2955 else
2956 return 4;
2957 }
2958
2959 int ff_h263_decode_mba(MpegEncContext *s)
2960 {
2961 int i, mb_pos;
2962
2963 for(i=0; i<6; i++){
2964 if(s->mb_num-1 <= ff_mba_max[i]) break;
2965 }
2966 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2967 s->mb_x= mb_pos % s->mb_width;
2968 s->mb_y= mb_pos / s->mb_width;
2969
2970 return mb_pos;
2971 }
2972
2973 void ff_h263_encode_mba(MpegEncContext *s)
2974 {
2975 int i, mb_pos;
2976
2977 for(i=0; i<6; i++){
2978 if(s->mb_num-1 <= ff_mba_max[i]) break;
2979 }
2980 mb_pos= s->mb_x + s->mb_width*s->mb_y;
2981 put_bits(&s->pb, ff_mba_length[i], mb_pos);
2982 }
2983
2984 /**
2985 * decodes the group of blocks header or slice header.
2986 * @return <0 if an error occurred
2987 */
2988 static int h263_decode_gob_header(MpegEncContext *s)
2989 {
2990 unsigned int val, gfid, gob_number;
2991 int left;
2992
2993 /* Check for GOB Start Code */
2994 val = show_bits(&s->gb, 16);
2995 if(val)
2996 return -1;
2997
2998 /* We have a GBSC probably with GSTUFF */
2999 skip_bits(&s->gb, 16); /* Drop the zeros */
3000 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3001 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3002 for(;left>13; left--){
3003 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3004 }
3005 if(left<=13)
3006 return -1;
3007
3008 if(s->h263_slice_structured){
3009 if(get_bits1(&s->gb)==0)
3010 return -1;
3011
3012 ff_h263_decode_mba(s);
3013
3014 if(s->mb_num > 1583)
3015 if(get_bits1(&s->gb)==0)
3016 return -1;
3017
3018 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3019 if(get_bits1(&s->gb)==0)
3020 return -1;
3021 gfid = get_bits(&s->gb, 2); /* GFID */
3022 }else{
3023 gob_number = get_bits(&s->gb, 5); /* GN */
3024 s->mb_x= 0;
3025 s->mb_y= s->gob_index* gob_number;
3026 gfid = get_bits(&s->gb, 2); /* GFID */
3027 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3028 }
3029
3030 if(s->mb_y >= s->mb_height)
3031 return -1;
3032
3033 if(s->qscale==0)
3034 return -1;
3035
3036 return 0;
3037 }
3038
3039 static inline void memsetw(short *tab, int val, int n)
3040 {
3041 int i;
3042 for(i=0;i<n;i++)
3043 tab[i] = val;
3044 }
3045
3046 #if CONFIG_ENCODERS
3047
3048 void ff_mpeg4_init_partitions(MpegEncContext *s)
3049 {
3050 uint8_t *start= put_bits_ptr(&s->pb);
3051 uint8_t *end= s->pb.buf_end;
3052 int size= end - start;
3053 int pb_size = (((intptr_t)start + size/3)&(~3)) - (intptr_t)start;
3054 int tex_size= (size - 2*pb_size)&(~3);
3055
3056 set_put_bits_buffer_size(&s->pb, pb_size);
3057 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3058 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3059 }
3060
3061 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3062 {
3063 const int pb2_len = put_bits_count(&s->pb2 );
3064 const int tex_pb_len= put_bits_count(&s->tex_pb);
3065 const int bits= put_bits_count(&s->pb);
3066
3067 if(s->pict_type==FF_I_TYPE){
3068 put_bits(&s->pb, 19, DC_MARKER);
3069 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3070 s->i_tex_bits+= tex_pb_len;
3071 }else{
3072 put_bits(&s->pb, 17, MOTION_MARKER);
3073 s->misc_bits+=17 + pb2_len;
3074 s->mv_bits+= bits - s->last_bits;
3075 s->p_tex_bits+= tex_pb_len;
3076 }
3077
3078 flush_put_bits(&s->pb2);
3079 flush_put_bits(&s->tex_pb);
3080
3081 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3082 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3083 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3084 s->last_bits= put_bits_count(&s->pb);
3085 }
3086
3087 #endif //CONFIG_ENCODERS
3088
3089 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3090 switch(s->pict_type){
3091 case FF_I_TYPE:
3092 return 16;
3093 case FF_P_TYPE:
3094 case FF_S_TYPE:
3095 return s->f_code+15;
3096 case FF_B_TYPE:
3097 return FFMAX3(s->f_code, s->b_code, 2) + 15;
3098 default:
3099 return -1;
3100 }
3101 }
3102
3103 #if CONFIG_ENCODERS
3104
3105 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3106 {
3107 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3108
3109 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3110 put_bits(&s->pb, 1, 1);
3111
3112 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3113 put_bits(&s->pb, s->quant_precision, s->qscale);
3114 put_bits(&s->pb, 1, 0); /* no HEC */
3115 }
3116
3117 #endif //CONFIG_ENCODERS
3118
3119 /**
3120 * check if the next stuff is a resync marker or the end.
3121 * @return 0 if not
3122 */
3123 static inline int mpeg4_is_resync(MpegEncContext *s){
3124 int bits_count= get_bits_count(&s->gb);
3125 int v= show_bits(&s->gb, 16);
3126
3127 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3128 return 0;
3129 }
3130
3131 while(v<=0xFF){
3132 if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3133 break;
3134 skip_bits(&s->gb, 8+s->pict_type);
3135 bits_count+= 8+s->pict_type;
3136 v= show_bits(&s->gb, 16);
3137 }
3138
3139 if(bits_count + 8 >= s->gb.size_in_bits){
3140 v>>=8;
3141 v|= 0x7F >> (7-(bits_count&7));
3142
3143 if(v==0x7F)
3144 return 1;
3145 }else{
3146 if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3147 int len;
3148 GetBitContext gb= s->gb;
3149
3150 skip_bits(&s->gb, 1);
3151 align_get_bits(&s->gb);
3152
3153 for(len=0; len<32; len++){
3154 if(get_bits1(&s->gb)) break;
3155 }
3156
3157 s->gb= gb;
3158
3159 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3160 return 1;
3161 }
3162 }
3163 return 0;
3164 }
3165
3166 /**
3167 * decodes the next video packet.
3168 * @return <0 if something went wrong
3169 */
3170 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3171 {
3172 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3173 int header_extension=0, mb_num, len;
3174
3175 /* is there enough space left for a video packet + header */
3176 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3177
3178 for(len=0; len<32; len++){
3179 if(get_bits1(&s->gb)) break;
3180 }
3181
3182 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3183 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3184 return -1;
3185 }
3186
3187 if(s->shape != RECT_SHAPE){
3188 header_extension= get_bits1(&s->gb);
3189 //FIXME more stuff here
3190 }
3191
3192 mb_num= get_bits(&s->gb, mb_num_bits);
3193 if(mb_num>=s->mb_num){
3194 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3195 return -1;
3196 }
3197 if(s->pict_type == FF_B_TYPE){
3198 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3199 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded
3200 }
3201
3202 s->mb_x= mb_num % s->mb_width;
3203 s->mb_y= mb_num / s->mb_width;
3204
3205 if(s->shape != BIN_ONLY_SHAPE){
3206 int qscale= get_bits(&s->gb, s->quant_precision);
3207 if(qscale)
3208 s->chroma_qscale=s->qscale= qscale;
3209 }
3210
3211 if(s->shape == RECT_SHAPE){
3212 header_extension= get_bits1(&s->gb);
3213 }
3214 if(header_extension){
3215 int time_increment;
3216 int time_incr=0;
3217
3218 while (get_bits1(&s->gb) != 0)
3219 time_incr++;
3220
3221 check_marker(&s->gb, "before time_increment in video packed header");
3222 time_increment= get_bits(&s->gb, s->time_increment_bits);
3223 check_marker(&s->gb, "before vop_coding_type in video packed header");
3224
3225 skip_bits(&s->gb, 2); /* vop coding type */
3226 //FIXME not rect stuff here
3227
3228 if(s->shape != BIN_ONLY_SHAPE){
3229 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3230 //FIXME don't just ignore everything
3231 if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3232 mpeg4_decode_sprite_trajectory(s, &s->gb);
3233 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3234 }
3235
3236 //FIXME reduced res stuff here
3237
3238 if (s->pict_type != FF_I_TYPE) {
3239 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3240 if(f_code==0){
3241 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3242 }
3243 }
3244 if (s->pict_type == FF_B_TYPE) {
3245 int b_code = get_bits(&s->gb, 3);
3246 if(b_code==0){
3247 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3248 }
3249 }
3250 }
3251 }
3252 //FIXME new-pred stuff
3253
3254 //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));
3255
3256 return 0;
3257 }
3258
3259 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3260 {
3261 int c_wrap, c_xy, l_wrap, l_xy;
3262
3263 l_wrap= s->b8_stride;
3264 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3265 c_wrap= s->mb_stride;
3266 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3267
3268 #if 0
3269 /* clean DC */
3270 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3271 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3272 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3273 #endif
3274
3275 /* clean AC */
3276 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3277 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3278 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3279
3280 /* clean MV */
3281 // we can't clear the MVs as they might be needed by a b frame
3282 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3283 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3284 s->last_mv[0][0][0]=
3285 s->last_mv[0][0][1]=
3286 s->last_mv[1][0][0]=
3287 s->last_mv[1][0][1]= 0;
3288 }
3289
3290 /**
3291 * finds the next resync_marker
3292 * @param p pointer to buffer to scan
3293 * @param end pointer to the end of the buffer
3294 * @return pointer to the next resync_marker, or \p end if none was found
3295 */
3296 const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end)
3297 {
3298 assert(p < end);
3299
3300 end-=2;
3301 p++;
3302 for(;p<end; p+=2){
3303 if(!*p){
3304 if (!p[-1] && p[1]) return p - 1;
3305 else if(!p[ 1] && p[2]) return p;
3306 }
3307 }
3308 return end+2;
3309 }
3310
3311 /**
3312 * decodes the group of blocks / video packet header.
3313 * @return bit position of the resync_marker, or <0 if none was found
3314 */
3315 int ff_h263_resync(MpegEncContext *s){
3316 int left, pos, ret;
3317
3318 if(s->codec_id==CODEC_ID_MPEG4){
3319 skip_bits1(&s->gb);
3320 align_get_bits(&s->gb);
3321 }
3322
3323 if(show_bits(&s->gb, 16)==0){
3324 pos= get_bits_count(&s->gb);
3325 if(s->codec_id==CODEC_ID_MPEG4)
3326 ret= mpeg4_decode_video_packet_header(s);
3327 else
3328 ret= h263_decode_gob_header(s);
3329 if(ret>=0)
3330 return pos;
3331 }
3332 //OK, it's not where it is supposed to be ...
3333 s->gb= s->last_resync_gb;
3334 align_get_bits(&s->gb);
3335 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3336
3337 for(;left>16+1+5+5; left-=8){
3338 if(show_bits(&s->gb, 16)==0){
3339 GetBitContext bak= s->gb;
3340
3341 pos= get_bits_count(&s->gb);
3342 if(s->codec_id==CODEC_ID_MPEG4)
3343 ret= mpeg4_decode_video_packet_header(s);
3344 else
3345 ret= h263_decode_gob_header(s);
3346 if(ret>=0)
3347 return pos;
3348
3349 s->gb= bak;
3350 }
3351 skip_bits(&s->gb, 8);
3352 }
3353
3354 return -1;
3355 }
3356
3357 /**
3358 * gets the average motion vector for a GMC MB.
3359 * @param n either 0 for the x component or 1 for y
3360 * @returns the average MV for a GMC MB
3361 */
3362 static inline int get_amv(MpegEncContext *s, int n){
3363 int x, y, mb_v, sum, dx, dy, shift;
3364 int len = 1 << (s->f_code + 4);
3365 const int a= s->sprite_warping_accuracy;
3366
3367 if(s->workaround_bugs & FF_BUG_AMV)
3368 len >>= s->quarter_sample;
3369
3370 if(s->real_sprite_warping_points==1){
3371 if(s->divx_version==500 && s->divx_build==413)
3372 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3373 else
3374 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3375 }else{
3376 dx= s->sprite_delta[n][0];
3377 dy= s->sprite_delta[n][1];
3378 shift= s->sprite_shift[0];
3379 if(n) dy -= 1<<(shift + a + 1);
3380 else dx -= 1<<(shift + a + 1);
3381 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3382
3383 sum=0;
3384 for(y=0; y<16; y++){
3385 int v;
3386
3387 v= mb_v + dy*y;
3388 //XXX FIXME optimize
3389 for(x=0; x<16; x++){
3390 sum+= v>>shift;
3391 v+= dx;
3392 }
3393 }
3394 sum= RSHIFT(sum, a+8-s->quarter_sample);
3395 }
3396
3397 if (sum < -len) sum= -len;
3398 else if (sum >= len) sum= len-1;
3399
3400 return sum;
3401 }
3402
3403 /**
3404 * decodes first partition.
3405 * @return number of MBs decoded or <0 if an error occurred
3406 */
3407 static int mpeg4_decode_partition_a(MpegEncContext *s){
3408 int mb_num;
3409 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3410
3411 /* decode first partition */
3412 mb_num=0;
3413 s->first_slice_line=1;
3414 for(; s->mb_y<s->mb_height; s->mb_y++){
3415 ff_init_block_index(s);
3416 for(; s->mb_x<s->mb_width; s->mb_x++){
3417 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3418 int cbpc;
3419 int dir=0;
3420
3421 mb_num++;
3422 ff_update_block_index(s);
3423 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3424 s->first_slice_line=0;
3425
3426 if(s->pict_type==FF_I_TYPE){
3427 int i;
3428
3429 do{
3430 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3431 return mb_num-1;
3432 }
3433
3434 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3435 if (cbpc < 0){
3436 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3437 return -1;
3438 }
3439 }while(cbpc == 8);
3440
3441 s->cbp_table[xy]= cbpc & 3;
3442 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3443 s->mb_intra = 1;
3444
3445 if(cbpc & 4) {
3446 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3447 }
3448 s->current_picture.qscale_table[xy]= s->qscale;
3449
3450 s->mbintra_table[xy]= 1;
3451 for(i=0; i<6; i++){
3452 int dc_pred_dir;
3453 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3454 if(dc < 0){
3455 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3456 return -1;
3457 }
3458 dir<<=1;
3459 if(dc_pred_dir) dir|=1;
3460 }
3461 s->pred_dir_table[xy]= dir;
3462 }else{ /* P/S_TYPE */
3463 int mx, my, pred_x, pred_y, bits;
3464 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3465 const int stride= s->b8_stride*2;
3466
3467 try_again:
3468 bits= show_bits(&s->gb, 17);
3469 if(bits==MOTION_MARKER){
3470 return mb_num-1;
3471 }
3472 skip_bits1(&s->gb);
3473 if(bits&0x10000){
3474 /* skip mb */
3475 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3476 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3477 mx= get_amv(s, 0);
3478 my= get_amv(s, 1);
3479 }else{
3480 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3481 mx=my=0;
3482 }
3483 mot_val[0 ]= mot_val[2 ]=
3484 mot_val[0+stride]= mot_val[2+stride]= mx;
3485 mot_val[1 ]= mot_val[3 ]=
3486 mot_val[1+stride]= mot_val[3+stride]= my;
3487
3488 if(s->mbintra_table[xy])
3489 ff_clean_intra_table_entries(s);
3490 continue;
3491 }
3492
3493 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3494 if (cbpc < 0){
3495 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3496 return -1;
3497 }
3498 if(cbpc == 20)
3499 goto try_again;
3500
3501 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3502
3503 s->mb_intra = ((cbpc & 4) != 0);
3504
3505 if(s->mb_intra){
3506 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3507 s->mbintra_table[xy]= 1;
3508 mot_val[0 ]= mot_val[2 ]=
3509 mot_val[0+stride]= mot_val[2+stride]= 0;
3510 mot_val[1 ]= mot_val[3 ]=
3511 mot_val[1+stride]= mot_val[3+stride]= 0;
3512 }else{
3513 if(s->mbintra_table[xy])
3514 ff_clean_intra_table_entries(s);
3515
3516 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3517 s->mcsel= get_bits1(&s->gb);
3518 else s->mcsel= 0;
3519
3520 if ((cbpc & 16) == 0) {
3521 /* 16x16 motion prediction */
3522
3523 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3524 if(!s->mcsel){
3525 mx = h263_decode_motion(s, pred_x, s->f_code);
3526 if (mx >= 0xffff)
3527 return -1;
3528
3529 my = h263_decode_motion(s, pred_y, s->f_code);
3530 if (my >= 0xffff)
3531 return -1;
3532 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3533 } else {
3534 mx = get_amv(s, 0);
3535 my = get_amv(s, 1);
3536 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3537 }
3538
3539 mot_val[0 ]= mot_val[2 ] =
3540 mot_val[0+stride]= mot_val[2+stride]= mx;
3541 mot_val[1 ]= mot_val[3 ]=
3542 mot_val[1+stride]= mot_val[3+stride]= my;
3543 } else {
3544 int i;
3545 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3546 for(i=0;i<4;i++) {
3547 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3548 mx = h263_decode_motion(s, pred_x, s->f_code);
3549 if (mx >= 0xffff)
3550 return -1;
3551
3552 my = h263_decode_motion(s, pred_y, s->f_code);
3553 if (my >= 0xffff)
3554 return -1;
3555 mot_val[0] = mx;
3556 mot_val[1] = my;
3557 }
3558 }
3559 }
3560 }
3561 }
3562 s->mb_x= 0;
3563 }
3564
3565 return mb_num;
3566 }
3567
3568 /**
3569 * decode second partition.
3570 * @return <0 if an error occurred
3571 */
3572 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3573 int mb_num=0;
3574 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3575
3576 s->mb_x= s->resync_mb_x;
3577 s->first_slice_line=1;
3578 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3579 ff_init_block_index(s);
3580 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3581 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3582
3583 mb_num++;
3584 ff_update_block_index(s);
3585 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3586 s->first_slice_line=0;
3587
3588 if(s->pict_type==FF_I_TYPE){
3589 int ac_pred= get_bits1(&s->gb);
3590 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3591 if(cbpy<0){
3592 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3593 return -1;
3594 }
3595
3596 s->cbp_table[xy]|= cbpy<<2;
3597 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3598 }else{ /* P || S_TYPE */
3599 if(IS_INTRA(s->current_picture.mb_type[xy])){
3600 int dir=0,i;
3601 int ac_pred = get_bits1(&s->gb);
3602 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3603
3604 if(cbpy<0){
3605 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3606 return -1;
3607 }
3608
3609 if(s->cbp_table[xy] & 8) {
3610 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3611 }
3612 s->current_picture.qscale_table[xy]= s->qscale;
3613
3614 for(i=0; i<6; i++){
3615 int dc_pred_dir;
3616 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3617 if(dc < 0){
3618 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3619 return -1;
3620 }
3621 dir<<=1;
3622 if(dc_pred_dir) dir|=1;
3623 }
3624 s->cbp_table[xy]&= 3; //remove dquant
3625 s->cbp_table[xy]|= cbpy<<2;
3626 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3627 s->pred_dir_table[xy]= dir;
3628 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3629 s->current_picture.qscale_table[xy]= s->qscale;
3630 s->cbp_table[xy]= 0;
3631 }else{
3632 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3633
3634 if(cbpy<0){
3635 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3636 return -1;
3637 }
3638
3639 if(s->cbp_table[xy] & 8) {
3640 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3641 }
3642 s->current_picture.qscale_table[xy]= s->qscale;
3643
3644 s->cbp_table[xy]&= 3; //remove dquant
3645 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3646 }
3647 }
3648 }
3649 if(mb_num >= mb_count) return 0;
3650 s->mb_x= 0;
3651 }
3652 return 0;
3653 }
3654
3655 /**
3656 * decodes the first & second partition
3657 * @return <0 if error (and sets error type in the error_status_table)
3658 */
3659 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3660 {
3661 int mb_num;
3662 const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3663 const int part_a_end = s->pict_type==FF_I_TYPE ? (DC_END |MV_END) : MV_END;
3664
3665 mb_num= mpeg4_decode_partition_a(s);
3666 if(mb_num<0){
3667 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3668 return -1;
3669 }
3670
3671 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3672 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3673 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3674 return -1;
3675 }
3676
3677 s->mb_num_left= mb_num;
3678
3679 if(s->pict_type==FF_I_TYPE){
3680 while(show_bits(&s->gb, 9) == 1)
3681 skip_bits(&s->gb, 9);
3682 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3683 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3684 return -1;
3685 }
3686 }else{
3687 while(show_bits(&s->gb, 10) == 1)
3688 skip_bits(&s->gb, 10);
3689 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3690 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3691 return -1;
3692 }
3693 }
3694 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3695
3696 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3697 if(s->pict_type==FF_P_TYPE)
3698 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3699 return -1;
3700 }else{
3701 if(s->pict_type==FF_P_TYPE)
3702 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3703 }
3704
3705 return 0;
3706 }
3707
3708 /**
3709 * decode partition C of one MB.
3710 * @return <0 if an error occurred
3711 */
3712 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3713 {
3714 int cbp, mb_type;
3715 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3716
3717 mb_type= s->current_picture.mb_type[xy];
3718 cbp = s->cbp_table[xy];
3719
3720 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3721
3722 if(s->current_picture.qscale_table[xy] != s->qscale){
3723 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3724 }
3725
3726 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
3727 int i;
3728 for(i=0; i<4; i++){
3729 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3730 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3731 }
3732 s->mb_intra = IS_INTRA(mb_type);
3733
3734 if (IS_SKIP(mb_type)) {
3735 /* skip mb */
3736 for(i=0;i<6;i++)
3737 s->block_last_index[i] = -1;
3738 s->mv_dir = MV_DIR_FORWARD;
3739 s->mv_type = MV_TYPE_16X16;
3740 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3741 s->mcsel=1;
3742 s->mb_skipped = 0;
3743 }else{
3744 s->mcsel=0;
3745 s->mb_skipped = 1;
3746 }
3747 }else if(s->mb_intra){
3748 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3749 }else if(!s->mb_intra){
3750 // s->mcsel= 0; //FIXME do we need to init that
3751
3752 s->mv_dir = MV_DIR_FORWARD;
3753 if (IS_8X8(mb_type)) {
3754 s->mv_type = MV_TYPE_8X8;
3755 } else {
3756 s->mv_type = MV_TYPE_16X16;
3757 }
3758 }
3759 } else { /* I-Frame */
3760 s->mb_intra = 1;
3761 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3762 }
3763
3764 if (!IS_SKIP(mb_type)) {
3765 int i;
3766 s->dsp.clear_blocks(s->block[0]);
3767 /* decode each block */
3768 for (i = 0; i < 6; i++) {
3769 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3770 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3771 return -1;
3772 }
3773 cbp+=cbp;
3774 }
3775 }
3776
3777 /* per-MB end of slice check */
3778
3779 if(--s->mb_num_left <= 0){
3780 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3781 if(mpeg4_is_resync(s))
3782 return SLICE_END;
3783 else
3784 return SLICE_NOEND;
3785 }else{
3786 if(mpeg4_is_resync(s)){
3787 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3788 if(s->cbp_table[xy+delta])
3789 return SLICE_END;
3790 }
3791 return SLICE_OK;
3792 }
3793 }
3794
3795 /**
3796 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3797 */
3798 static void preview_obmc(MpegEncContext *s){
3799 GetBitContext gb= s->gb;
3800
3801 int cbpc, i, pred_x, pred_y, mx, my;
3802 int16_t *mot_val;
3803 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3804 const int stride= s->b8_stride*2;
3805
3806 for(i=0; i<4; i++)
3807 s->block_index[i]+= 2;
3808 for(i=4; i<6; i++)
3809 s->block_index[i]+= 1;
3810 s->mb_x++;
3811
3812 assert(s->pict_type == FF_P_TYPE);
3813
3814 do{
3815 if (get_bits1(&s->gb)) {
3816 /* skip mb */
3817 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3818 mot_val[0 ]= mot_val[2 ]=
3819 mot_val[0+stride]= mot_val[2+stride]= 0;
3820 mot_val[1 ]= mot_val[3 ]=
3821 mot_val[1+stride]= mot_val[3+stride]= 0;
3822
3823 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3824 goto end;
3825 }
3826 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3827 }while(cbpc == 20);
3828
3829 if(cbpc & 4){
3830 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3831 }else{
3832 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3833 if (cbpc & 8) {
3834 if(s->modified_quant){
3835 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3836 else skip_bits(&s->gb, 5);
3837 }else
3838 skip_bits(&s->gb, 2);
3839 }
3840
3841 if ((cbpc & 16) == 0) {
3842 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3843 /* 16x16 motion prediction */
3844 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3845 if (s->umvplus)
3846 mx = h263p_decode_umotion(s, pred_x);
3847 else
3848 mx = h263_decode_motion(s, pred_x, 1);
3849
3850 if (s->umvplus)
3851 my = h263p_decode_umotion(s, pred_y);
3852 else
3853 my = h263_decode_motion(s, pred_y, 1);
3854
3855 mot_val[0 ]= mot_val[2 ]=
3856 mot_val[0+stride]= mot_val[2+stride]= mx;
3857 mot_val[1 ]= mot_val[3 ]=
3858 mot_val[1+stride]= mot_val[3+stride]= my;
3859 } else {
3860 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3861 for(i=0;i<4;i++) {
3862 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3863 if (s->umvplus)
3864 mx = h263p_decode_umotion(s, pred_x);
3865 else
3866 mx = h263_decode_motion(s, pred_x, 1);
3867
3868 if (s->umvplus)
3869 my = h263p_decode_umotion(s, pred_y);
3870 else
3871 my = h263_decode_motion(s, pred_y, 1);
3872 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3873 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3874 mot_val[0] = mx;
3875 mot_val[1] = my;
3876 }
3877 }
3878 }
3879 end:
3880
3881 for(i=0; i<4; i++)
3882 s->block_index[i]-= 2;
3883 for(i=4; i<6; i++)
3884 s->block_index[i]-= 1;
3885 s->mb_x--;
3886
3887 s->gb= gb;
3888 }
3889
3890 static void h263_decode_dquant(MpegEncContext *s){
3891 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3892
3893 if(s->modified_quant){
3894 if(get_bits1(&s->gb))
3895 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3896 else
3897 s->qscale= get_bits(&s->gb, 5);
3898 }else
3899 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3900 ff_set_qscale(s, s->qscale);
3901 }
3902
3903 static int h263_skip_b_part(MpegEncContext *s, int cbp)
3904 {
3905 DECLARE_ALIGNED(16, DCTELEM, dblock[64]);
3906 int i, mbi;
3907
3908 /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly
3909 * but real value should be restored in order to be used later (in OBMC condition)
3910 */
3911 mbi = s->mb_intra;
3912 s->mb_intra = 0;
3913 for (i = 0; i < 6; i++) {
3914 if (h263_decode_block(s, dblock, i, cbp&32) < 0)
3915 return -1;
3916 cbp+=cbp;
3917 }
3918 s->mb_intra = mbi;
3919 return 0;
3920 }
3921
3922 static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)
3923 {
3924 int c, mv = 1;
3925
3926 if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame
3927 c = get_bits1(gb);
3928 if (pb_frame == 2 && c)
3929 mv = !get_bits1(gb);
3930 } else { // h.263 Annex M improved PB-frame
3931 mv = get_unary(gb, 0, 4) + 1;
3932 c = mv & 1;
3933 mv = !!(mv & 2);
3934 }
3935 if(c)
3936 *cbpb = get_bits(gb, 6);
3937 return mv;
3938 }
3939
3940 int ff_h263_decode_mb(MpegEncContext *s,
3941 DCTELEM block[6][64])
3942 {
3943 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3944 int16_t *mot_val;
3945 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3946 int cbpb = 0, pb_mv_count = 0;
3947
3948 assert(!s->h263_pred);
3949
3950 if (s->pict_type == FF_P_TYPE) {
3951 do{
3952 if (get_bits1(&s->gb)) {
3953 /* skip mb */
3954 s->mb_intra = 0;
3955 for(i=0;i<6;i++)
3956 s->block_last_index[i] = -1;
3957 s->mv_dir = MV_DIR_FORWARD;
3958 s->mv_type = MV_TYPE_16X16;
3959 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3960 s->mv[0][0][0] = 0;
3961 s->mv[0][0][1] = 0;
3962 s->mb_skipped = !(s->obmc | s->loop_filter);
3963 goto end;
3964 }
3965 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3966 //fprintf(stderr, "\tCBPC: %d", cbpc);
3967 if (cbpc < 0){
3968 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3969 return -1;
3970 }
3971 }while(cbpc == 20);
3972
3973 s->dsp.clear_blocks(s->block[0]);
3974
3975 dquant = cbpc & 8;
3976 s->mb_intra = ((cbpc & 4) != 0);
3977 if (s->mb_intra) goto intra;
3978
3979 if(s->pb_frame && get_bits1(&s->gb))
3980 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
3981 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3982
3983 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3984 cbpy ^= 0xF;
3985
3986 cbp = (cbpc & 3) | (cbpy << 2);
3987 if (dquant) {
3988 h263_decode_dquant(s);
3989 }
3990
3991 s->mv_dir = MV_DIR_FORWARD;
3992 if ((cbpc & 16) == 0) {
3993 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3994 /* 16x16 motion prediction */
3995 s->mv_type = MV_TYPE_16X16;
3996 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3997 if (s->umvplus)
3998 mx = h263p_decode_umotion(s, pred_x);
3999 else
4000 mx = h263_decode_motion(s, pred_x, 1);
4001
4002 if (mx >= 0xffff)
4003 return -1;
4004
4005 if (s->umvplus)
4006 my = h263p_decode_umotion(s, pred_y);
4007 else
4008 my = h263_decode_motion(s, pred_y, 1);
4009
4010 if (my >= 0xffff)
4011 return -1;
4012 s->mv[0][0][0] = mx;
4013 s->mv[0][0][1] = my;
4014
4015 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4016 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4017 } else {
4018 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4019 s->mv_type = MV_TYPE_8X8;
4020 for(i=0;i<4;i++) {
4021 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4022 if (s->umvplus)
4023 mx = h263p_decode_umotion(s, pred_x);
4024 else
4025 mx = h263_decode_motion(s, pred_x, 1);
4026 if (mx >= 0xffff)
4027 return -1;
4028
4029 if (s->umvplus)
4030 my = h263p_decode_umotion(s, pred_y);
4031 else
4032 my = h263_decode_motion(s, pred_y, 1);
4033 if (my >= 0xffff)
4034 return -1;
4035 s->mv[0][i][0] = mx;
4036 s->mv[0][i][1] = my;
4037 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4038 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4039 mot_val[0] = mx;
4040 mot_val[1] = my;
4041 }
4042 }
4043 } else if(s->pict_type==FF_B_TYPE) {
4044 int mb_type;
4045 const int stride= s->b8_stride;
4046 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4047 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4048 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4049
4050 //FIXME ugly
4051 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4052 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4053 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4054 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4055
4056 do{
4057 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4058 if (mb_type < 0){
4059 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4060 return -1;
4061 }
4062
4063 mb_type= h263_mb_type_b_map[ mb_type ];
4064 }while(!mb_type);
4065
4066 s->mb_intra = IS_INTRA(mb_type);
4067 if(HAS_CBP(mb_type)){
4068 s->dsp.clear_blocks(s->block[0]);
4069 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4070 if(s->mb_intra){
4071 dquant = IS_QUANT(mb_type);
4072 goto intra;
4073 }
4074
4075 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4076
4077 if (cbpy < 0){
4078 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4079 return -1;
4080 }
4081
4082 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4083 cbpy ^= 0xF;
4084
4085 cbp = (cbpc & 3) | (cbpy << 2);
4086 }else
4087 cbp=0;
4088
4089 assert(!s->mb_intra);
4090
4091 if(IS_QUANT(mb_type)){
4092 h263_decode_dquant(s);
4093 }
4094
4095 if(IS_DIRECT(mb_type)){
4096 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4097 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4098 }else{
4099 s->mv_dir = 0;
4100 s->mv_type= MV_TYPE_16X16;
4101 //FIXME UMV
4102
4103 if(USES_LIST(mb_type, 0)){
4104 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4105 s->mv_dir = MV_DIR_FORWARD;
4106
4107 mx = h263_decode_motion(s, mx, 1);
4108 my = h263_decode_motion(s, my, 1);
4109
4110 s->mv[0][0][0] = mx;
4111 s->mv[0][0][1] = my;
4112 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4113 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4114 }
4115
4116 if(USES_LIST(mb_type, 1)){
4117 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4118 s->mv_dir |= MV_DIR_BACKWARD;
4119
4120 mx = h263_decode_motion(s, mx, 1);
4121 my = h263_decode_motion(s, my, 1);
4122
4123 s->mv[1][0][0] = mx;
4124 s->mv[1][0][1] = my;
4125 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4126 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4127 }
4128 }
4129
4130 s->current_picture.mb_type[xy]= mb_type;
4131 } else { /* I-Frame */
4132 do{
4133 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4134 if (cbpc < 0){
4135 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4136 return -1;
4137 }
4138 }while(cbpc == 8);
4139
4140 s->dsp.clear_blocks(s->block[0]);
4141
4142 dquant = cbpc & 4;
4143 s->mb_intra = 1;
4144 intra:
4145 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4146 if (s->h263_aic) {
4147 s->ac_pred = get_bits1(&s->gb);
4148 if(s->ac_pred){
4149 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4150
4151 s->h263_aic_dir = get_bits1(&s->gb);
4152 }
4153 }else
4154 s->ac_pred = 0;
4155
4156 if(s->pb_frame && get_bits1(&s->gb))
4157 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
4158 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4159 if(cbpy<0){
4160 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4161 return -1;
4162 }
4163 cbp = (cbpc & 3) | (cbpy << 2);
4164 if (dquant) {
4165 h263_decode_dquant(s);
4166 }
4167
4168 pb_mv_count += !!s->pb_frame;
4169 }
4170
4171 while(pb_mv_count--){
4172 h263_decode_motion(s, 0, 1);
4173 h263_decode_motion(s, 0, 1);
4174 }
4175
4176 /* decode each block */
4177 for (i = 0; i < 6; i++) {
4178 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4179 return -1;
4180 cbp+=cbp;
4181 }
4182
4183 if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0)
4184 return -1;
4185 if(s->obmc && !s->mb_intra){
4186 if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4187 preview_obmc(s);
4188 }
4189 end:
4190
4191 /* per-MB end of slice check */
4192 {
4193 int v= show_bits(&s->gb, 16);
4194
4195 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4196 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4197 }
4198
4199 if(v==0)
4200 return SLICE_END;
4201 }
4202
4203 return SLICE_OK;
4204 }
4205
4206 int ff_mpeg4_decode_mb(MpegEncContext *s,
4207 DCTELEM block[6][64])
4208 {
4209 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4210 int16_t *mot_val;
4211 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4212 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4213
4214 assert(s->h263_pred);
4215
4216 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
4217 do{
4218 if (get_bits1(&s->gb)) {
4219 /* skip mb */
4220 s->mb_intra = 0;
4221 for(i=0;i<6;i++)
4222 s->block_last_index[i] = -1;
4223 s->mv_dir = MV_DIR_FORWARD;
4224 s->mv_type = MV_TYPE_16X16;
4225 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4226 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4227 s->mcsel=1;
4228 s->mv[0][0][0]= get_amv(s, 0);
4229 s->mv[0][0][1]= get_amv(s, 1);
4230
4231 s->mb_skipped = 0;
4232 }else{
4233 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4234 s->mcsel=0;
4235 s->mv[0][0][0] = 0;
4236 s->mv[0][0][1] = 0;
4237 s->mb_skipped = 1;
4238 }
4239 goto end;
4240 }
4241 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4242 //fprintf(stderr, "\tCBPC: %d", cbpc);
4243 if (cbpc < 0){
4244 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4245 return -1;
4246 }
4247 }while(cbpc == 20);
4248
4249 s->dsp.clear_blocks(s->block[0]);
4250 dquant = cbpc & 8;
4251 s->mb_intra = ((cbpc & 4) != 0);
4252 if (s->mb_intra) goto intra;
4253
4254 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4255 s->mcsel= get_bits1(&s->gb);
4256 else s->mcsel= 0;
4257 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4258
4259 cbp = (cbpc & 3) | (cbpy << 2);
4260 if (dquant) {
4261 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4262 }
4263 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4264 s->interlaced_dct= get_bits1(&s->gb);
4265
4266 s->mv_dir = MV_DIR_FORWARD;
4267 if ((cbpc & 16) == 0) {
4268 if(s->mcsel){
4269 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4270 /* 16x16 global motion prediction */
4271 s->mv_type = MV_TYPE_16X16;
4272 mx= get_amv(s, 0);
4273 my= get_amv(s, 1);
4274 s->mv[0][0][0] = mx;
4275 s->mv[0][0][1] = my;
4276 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4277 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4278 /* 16x8 field motion prediction */
4279 s->mv_type= MV_TYPE_FIELD;
4280
4281 s->field_select[0][0]= get_bits1(&s->gb);
4282 s->field_select[0][1]= get_bits1(&s->gb);
4283
4284 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4285
4286 for(i=0; i<2; i++){
4287 mx = h263_decode_motion(s, pred_x, s->f_code);
4288 if (mx >= 0xffff)
4289 return -1;
4290
4291 my = h263_decode_motion(s, pred_y/2, s->f_code);
4292 if (my >= 0xffff)
4293 return -1;
4294
4295 s->mv[0][i][0] = mx;
4296 s->mv[0][i][1] = my;
4297 }
4298 }else{
4299 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4300 /* 16x16 motion prediction */
4301 s->mv_type = MV_TYPE_16X16;
4302 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4303 mx = h263_decode_motion(s, pred_x, s->f_code);
4304
4305 if (mx >= 0xffff)
4306 return -1;
4307
4308 my = h263_decode_motion(s, pred_y, s->f_code);
4309
4310 if (my >= 0xffff)
4311 return -1;
4312 s->mv[0][0][0] = mx;
4313 s->mv[0][0][1] = my;
4314 }
4315 } else {
4316 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4317 s->mv_type = MV_TYPE_8X8;
4318 for(i=0;i<4;i++) {
4319 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4320 mx = h263_decode_motion(s, pred_x, s->f_code);
4321 if (mx >= 0xffff)
4322 return -1;
4323
4324 my = h263_decode_motion(s, pred_y, s->f_code);
4325 if (my >= 0xffff)
4326 return -1;
4327 s->mv[0][i][0] = mx;
4328 s->mv[0][i][1] = my;
4329 mot_val[0] = mx;
4330 mot_val[1] = my;
4331 }
4332 }
4333 } else if(s->pict_type==FF_B_TYPE) {
4334 int modb1; // first bit of modb
4335 int modb2; // second bit of modb
4336 int mb_type;
4337
4338 s->mb_intra = 0; //B-frames never contain intra blocks
4339 s->mcsel=0; // ... true gmc blocks
4340
4341 if(s->mb_x==0){
4342 for(i=0; i<2; i++){
4343 s->last_mv[i][0][0]=
4344 s->last_mv[i][0][1]=
4345 s->last_mv[i][1][0]=
4346 s->last_mv[i][1][1]= 0;
4347 }
4348 }
4349
4350 /* if we skipped it in the future P Frame than skip it now too */
4351 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4352
4353 if(s->mb_skipped){
4354 /* skip mb */
4355 for(i=0;i<6;i++)
4356 s->block_last_index[i] = -1;
4357
4358 s->mv_dir = MV_DIR_FORWARD;
4359 s->mv_type = MV_TYPE_16X16;
4360 s->mv[0][0][0] = 0;
4361 s->mv[0][0][1] = 0;
4362 s->mv[1][0][0] = 0;
4363 s->mv[1][0][1] = 0;
4364 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4365 goto end;
4366 }
4367
4368 modb1= get_bits1(&s->gb);
4369 if(modb1){
4370 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4371 cbp=0;
4372 }else{
4373 modb2= get_bits1(&s->gb);
4374 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4375 if(mb_type<0){
4376 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4377 return -1;
4378 }
4379 mb_type= mb_type_b_map[ mb_type ];
4380 if(modb2) cbp= 0;
4381 else{
4382 s->dsp.clear_blocks(s->block[0]);
4383 cbp= get_bits(&s->gb, 6);
4384 }
4385
4386 if ((!IS_DIRECT(mb_type)) && cbp) {
4387 if(get_bits1(&s->gb)){
4388 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4389 }
4390 }
4391
4392 if(!s->progressive_sequence){
4393 if(cbp)
4394 s->interlaced_dct= get_bits1(&s->gb);
4395
4396 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4397 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4398 mb_type &= ~MB_TYPE_16x16;
4399
4400 if(USES_LIST(mb_type, 0)){
4401 s->field_select[0][0]= get_bits1(&s->gb);
4402 s->field_select[0][1]= get_bits1(&s->gb);
4403 }
4404 if(USES_LIST(mb_type, 1)){
4405 s->field_select[1][0]= get_bits1(&s->gb);
4406 s->field_select[1][1]= get_bits1(&s->gb);
4407 }
4408 }
4409 }
4410
4411 s->mv_dir = 0;
4412 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4413 s->mv_type= MV_TYPE_16X16;
4414
4415 if(USES_LIST(mb_type, 0)){
4416 s->mv_dir = MV_DIR_FORWARD;
4417
4418 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4419 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4420 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4421 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4422 }
4423
4424 if(USES_LIST(mb_type, 1)){
4425 s->mv_dir |= MV_DIR_BACKWARD;
4426
4427 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4428 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4429 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4430 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4431 }
4432 }else if(!IS_DIRECT(mb_type)){
4433 s->mv_type= MV_TYPE_FIELD;
4434
4435 if(USES_LIST(mb_type, 0)){
4436 s->mv_dir = MV_DIR_FORWARD;
4437
4438 for(i=0; i<2; i++){
4439 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
4440 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4441 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
4442 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4443 }
4444 }
4445
4446 if(USES_LIST(mb_type, 1)){
4447 s->mv_dir |= MV_DIR_BACKWARD;
4448
4449 for(i=0; i<2; i++){
4450 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
4451 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4452 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
4453 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4454 }
4455 }
4456 }
4457 }
4458
4459 if(IS_DIRECT(mb_type)){
4460 if(IS_SKIP(mb_type))
4461 mx=my=0;
4462 else{
4463 mx = h263_decode_motion(s, 0, 1);
4464 my = h263_decode_motion(s, 0, 1);
4465 }
4466
4467 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4468 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4469 }
4470 s->current_picture.mb_type[xy]= mb_type;
4471 } else { /* I-Frame */
4472 do{
4473 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4474 if (cbpc < 0){
4475 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4476 return -1;
4477 }
4478 }while(cbpc == 8);
4479
4480 dquant = cbpc & 4;
4481 s->mb_intra = 1;
4482 intra:
4483 s->ac_pred = get_bits1(&s->gb);
4484 if(s->ac_pred)
4485 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4486 else
4487 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4488
4489 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4490 if(cbpy<0){
4491 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4492 return -1;
4493 }
4494 cbp = (cbpc & 3) | (cbpy << 2);
4495
4496 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4497
4498 if (dquant) {
4499 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4500 }
4501
4502 if(!s->progressive_sequence)
4503 s->interlaced_dct= get_bits1(&s->gb);
4504
4505 s->dsp.clear_blocks(s->block[0]);
4506 /* decode each block */
4507 for (i = 0; i < 6; i++) {
4508 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4509 return -1;
4510 cbp+=cbp;
4511 }
4512 goto end;
4513 }
4514
4515 /* decode each block */
4516 for (i = 0; i < 6; i++) {
4517 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4518 return -1;
4519 cbp+=cbp;
4520 }
4521 end:
4522
4523 /* per-MB end of slice check */
4524 if(s->codec_id==CODEC_ID_MPEG4){
4525 if(mpeg4_is_resync(s)){
4526 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4527 if(s->pict_type==FF_B_TYPE && s->next_picture.mbskip_table[xy + delta])
4528 return SLICE_OK;
4529 return SLICE_END;
4530 }
4531 }
4532
4533 return SLICE_OK;
4534 }
4535
4536 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4537 {
4538 int code, val, sign, shift, l;
4539 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4540
4541 if (code == 0)
4542 return pred;
4543 if (code < 0)
4544 return 0xffff;
4545
4546 sign = get_bits1(&s->gb);
4547 shift = f_code - 1;
4548 val = code;
4549 if (shift) {
4550 val = (val - 1) << shift;
4551 val |= get_bits(&s->gb, shift);
4552 val++;
4553 }
4554 if (sign)
4555 val = -val;
4556 val += pred;
4557
4558 /* modulo decoding */
4559 if (!s->h263_long_vectors) {
4560 l = INT_BIT - 5 - f_code;
4561 val = (val<<l)>>l;
4562 } else {
4563 /* horrible h263 long vector mode */
4564 if (pred < -31 && val < -63)
4565 val += 64;
4566 if (pred > 32 && val > 63)
4567 val -= 64;
4568
4569 }
4570 return val;
4571 }
4572
4573 /* Decodes RVLC of H.263+ UMV */
4574 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4575 {
4576 int code = 0, sign;
4577
4578 if (get_bits1(&s->gb)) /* Motion difference = 0 */
4579 return pred;
4580
4581 code = 2 + get_bits1(&s->gb);
4582
4583 while (get_bits1(&s->gb))
4584 {
4585 code <<= 1;
4586 code += get_bits1(&s->gb);
4587 }
4588 sign = code & 1;
4589 code >>= 1;
4590
4591 code = (sign) ? (pred - code) : (pred + code);
4592 #ifdef DEBUG
4593 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4594 #endif
4595 return code;
4596
4597 }
4598
4599 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4600 int n, int coded)
4601 {
4602 int code, level, i, j, last, run;
4603 RLTable *rl = &rl_inter;
4604 const uint8_t *scan_table;
4605 GetBitContext gb= s->gb;
4606
4607 scan_table = s->intra_scantable.permutated;
4608 if (s->h263_aic && s->mb_intra) {
4609 rl = &rl_intra_aic;
4610 i = 0;
4611 if (s->ac_pred) {
4612 if (s->h263_aic_dir)
4613 scan_table = s->intra_v_scantable.permutated; /* left */
4614 else
4615 scan_table = s->intra_h_scantable.permutated; /* top */
4616 }
4617 } else if (s->mb_intra) {
4618 /* DC coef */
4619 if(s->codec_id == CODEC_ID_RV10){
4620 #if CONFIG_RV10_DECODER
4621 if (s->rv10_version == 3 && s->pict_type == FF_I_TYPE) {
4622 int component, diff;
4623 component = (n <= 3 ? 0 : n - 4 + 1);
4624 level = s->last_dc[component];
4625 if (s->rv10_first_dc_coded[component]) {
4626 diff = rv_decode_dc(s, n);
4627 if (diff == 0xffff)
4628 return -1;
4629 level += diff;
4630 level = level & 0xff; /* handle wrap round */
4631 s->last_dc[component] = level;
4632 } else {
4633 s->rv10_first_dc_coded[component] = 1;
4634 }
4635 } else {
4636 level = get_bits(&s->gb, 8);
4637 if (level == 255)
4638 level = 128;
4639 }
4640 #endif
4641 }else{
4642 level = get_bits(&s->gb, 8);
4643 if((level&0x7F) == 0){
4644 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4645 if(s->error_recognition >= FF_ER_COMPLIANT)
4646 return -1;
4647 }
4648 if (level == 255)
4649 level = 128;
4650 }
4651 block[0] = level;
4652 i = 1;
4653 } else {
4654 i = 0;
4655 }
4656 if (!coded) {
4657 if (s->mb_intra && s->h263_aic)
4658 goto not_coded;
4659 s->block_last_index[n] = i - 1;
4660 return 0;
4661 }
4662 retry:
4663 for(;;) {
4664 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4665 if (code < 0){
4666 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4667 return -1;
4668 }
4669 if (code == rl->n) {
4670 /* escape */
4671 if (s->h263_flv > 1) {
4672 int is11 = get_bits1(&s->gb);
4673 last = get_bits1(&s->gb);
4674 run = get_bits(&s->gb, 6);
4675 if(is11){
4676 level = get_sbits(&s->gb, 11);
4677 } else {
4678 level = get_sbits(&s->gb, 7);
4679 }
4680 } else {
4681 last = get_bits1(&s->gb);
4682 run = get_bits(&s->gb, 6);
4683 level = (int8_t)get_bits(&s->gb, 8);
4684 if(level == -128){
4685 if (s->codec_id == CODEC_ID_RV10) {
4686 /* XXX: should patch encoder too */
4687 level = get_sbits(&s->gb, 12);
4688 }else{
4689 level = get_bits(&s->gb, 5);
4690 level |= get_sbits(&s->gb, 6)<<5;
4691 }
4692 }
4693 }
4694 } else {
4695 run = rl->table_run[code];
4696 level = rl->table_level[code];
4697 last = code >= rl->last;
4698 if (get_bits1(&s->gb))
4699 level = -level;
4700 }
4701 i += run;
4702 if (i >= 64){
4703 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4704 //Looks like a hack but no, it's the way it is supposed to work ...
4705 rl = &rl_intra_aic;
4706 i = 0;
4707 s->gb= gb;
4708 s->dsp.clear_block(block);
4709 goto retry;
4710 }
4711 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4712 return -1;
4713 }
4714 j = scan_table[i];
4715 block[j] = level;
4716 if (last)
4717 break;
4718 i++;
4719 }
4720 not_coded:
4721 if (s->mb_intra && s->h263_aic) {
4722 h263_pred_acdc(s, block, n);
4723 i = 63;
4724 }
4725 s->block_last_index[n] = i;
4726 return 0;
4727 }
4728
4729 /**
4730 * decodes the dc value.
4731 * @param n block index (0-3 are luma, 4-5 are chroma)
4732 * @param dir_ptr the prediction direction will be stored here
4733 * @return the quantized dc
4734 */
4735 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4736 {
4737 int level, code;
4738
4739 if (n < 4)
4740 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4741 else
4742 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4743 if (code < 0 || code > 9 /* && s->nbit<9 */){
4744 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4745 return -1;
4746 }
4747 if (code == 0) {
4748 level = 0;
4749 } else {
4750 if(IS_3IV1){
4751 if(code==1)
4752 level= 2*get_bits1(&s->gb)-1;
4753 else{
4754 if(get_bits1(&s->gb))
4755 level = get_bits(&s->gb, code-1) + (1<<(code-1));
4756 else
4757 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4758 }
4759 }else{
4760 level = get_xbits(&s->gb, code);
4761 }
4762
4763 if (code > 8){
4764 if(get_bits1(&s->gb)==0){ /* marker */
4765 if(s->error_recognition>=2){
4766 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4767 return -1;
4768 }
4769 }
4770 }
4771 }
4772
4773 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4774 }
4775
4776 /**
4777 * decodes a block.
4778 * @return <0 if an error occurred
4779 */
4780 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4781 int n, int coded, int intra, int rvlc)
4782 {
4783 int level, i, last, run;
4784 int dc_pred_dir;
4785 RLTable * rl;
4786 RL_VLC_ELEM * rl_vlc;
4787 const uint8_t * scan_table;
4788 int qmul, qadd;
4789
4790 //Note intra & rvlc should be optimized away if this is inlined
4791
4792 if(intra) {
4793 if(s->use_intra_dc_vlc){
4794 /* DC coef */
4795 if(s->partitioned_frame){
4796 level = s->dc_val[0][ s->block_index[n] ];
4797 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4798 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4799 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4800 }else{
4801 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4802 if (level < 0)
4803 return -1;
4804 }
4805 block[0] = level;
4806 i = 0;
4807 }else{
4808 i = -1;
4809 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4810 }
4811 if (!coded)
4812 goto not_coded;
4813
4814 if(rvlc){
4815 rl = &rvlc_rl_intra;
4816 rl_vlc = rvlc_rl_intra.rl_vlc[0];
4817 }else{
4818 rl = &rl_intra;
4819 rl_vlc = rl_intra.rl_vlc[0];
4820 }
4821 if (s->ac_pred) {
4822 if (dc_pred_dir == 0)
4823 scan_table = s->intra_v_scantable.permutated; /* left */
4824 else
4825 scan_table = s->intra_h_scantable.permutated; /* top */
4826 } else {
4827 scan_table = s->intra_scantable.permutated;
4828 }
4829 qmul=1;
4830 qadd=0;
4831 } else {
4832 i = -1;
4833 if (!coded) {
4834 s->block_last_index[n] = i;
4835 return 0;
4836 }
4837 if(rvlc) rl = &rvlc_rl_inter;
4838 else rl = &rl_inter;
4839
4840 scan_table = s->intra_scantable.permutated;
4841
4842 if(s->mpeg_quant){
4843 qmul=1;
4844 qadd=0;
4845 if(rvlc){
4846 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4847 }else{
4848 rl_vlc = rl_inter.rl_vlc[0];
4849 }
4850 }else{
4851 qmul = s->qscale << 1;
4852 qadd = (s->qscale - 1) | 1;
4853 if(rvlc){
4854 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4855 }else{
4856 rl_vlc = rl_inter.rl_vlc[s->qscale];
4857 }
4858 }
4859 }
4860 {
4861 OPEN_READER(re, &s->gb);
4862 for(;;) {
4863 UPDATE_CACHE(re, &s->gb);
4864 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4865 if (level==0) {
4866 /* escape */
4867 if(rvlc){
4868 if(SHOW_UBITS(re, &s->gb, 1)==0){
4869 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4870 return -1;
4871 }; SKIP_CACHE(re, &s->gb, 1);
4872
4873 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4874 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4875 SKIP_COUNTER(re, &s->gb, 1+1+6);
4876 UPDATE_CACHE(re, &s->gb);
4877
4878 if(SHOW_UBITS(re, &s->gb, 1)==0){
4879 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4880 return -1;
4881 }; SKIP_CACHE(re, &s->gb, 1);
4882
4883 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4884
4885 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4886 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4887 return -1;
4888 }; SKIP_CACHE(re, &s->gb, 5);
4889
4890 level= level * qmul + qadd;
4891 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4892 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4893
4894 i+= run + 1;
4895 if(last) i+=192;
4896 }else{
4897 int cache;
4898 cache= GET_CACHE(re, &s->gb);
4899
4900 if(IS_3IV1)
4901 cache ^= 0xC0000000;
4902
4903 if (cache&0x80000000) {
4904 if (cache&0x40000000) {
4905 /* third escape */
4906 SKIP_CACHE(re, &s->gb, 2);
4907 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4908 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4909 SKIP_COUNTER(re, &s->gb, 2+1+6);
4910 UPDATE_CACHE(re, &s->gb);
4911
4912 if(IS_3IV1){
4913 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4914 }else{
4915 if(SHOW_UBITS(re, &s->gb, 1)==0){
4916 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4917 return -1;
4918 }; SKIP_CACHE(re, &s->gb, 1);
4919
4920 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4921
4922 if(SHOW_UBITS(re, &s->gb, 1)==0){
4923 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4924 return -1;
4925 }; LAST_SKIP_CACHE(re, &s->gb, 1);
4926
4927 SKIP_COUNTER(re, &s->gb, 1+12+1);
4928 }
4929
4930 #if 0
4931 if(s->error_recognition >= FF_ER_COMPLIANT){
4932 const int abs_level= FFABS(level);
4933 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4934 const int run1= run - rl->max_run[last][abs_level] - 1;
4935 if(abs_level <= rl->max_level[last][run]){
4936 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4937 return -1;
4938 }
4939 if(s->error_recognition > FF_ER_COMPLIANT){
4940 if(abs_level <= rl->max_level[last][run]*2){
4941 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4942 return -1;
4943 }
4944 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4945 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4946 return -1;
4947 }
4948 }
4949 }
4950 }
4951 #endif
4952 if (level>0) level= level * qmul + qadd;
4953 else level= level * qmul - qadd;
4954
4955 if((unsigned)(level + 2048) > 4095){
4956 if(s->error_recognition > FF_ER_COMPLIANT){
4957 if(level > 2560 || level<-2560){
4958 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4959 return -1;
4960 }
4961 }
4962 level= level<0 ? -2048 : 2047;
4963 }
4964
4965 i+= run + 1;
4966 if(last) i+=192;
4967 } else {
4968 /* second escape */
4969 #if MIN_CACHE_BITS < 20
4970 LAST_SKIP_BITS(re, &s->gb, 2);
4971 UPDATE_CACHE(re, &s->gb);
4972 #else
4973 SKIP_BITS(re, &s->gb, 2);
4974 #endif
4975 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4976 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4977 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4978 LAST_SKIP_BITS(re, &s->gb, 1);
4979 }
4980 } else {
4981 /* first escape */
4982 #if MIN_CACHE_BITS < 19
4983 LAST_SKIP_BITS(re, &s->gb, 1);
4984 UPDATE_CACHE(re, &s->gb);
4985 #else
4986 SKIP_BITS(re, &s->gb, 1);
4987 #endif
4988 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4989 i+= run;
4990 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4991 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4992 LAST_SKIP_BITS(re, &s->gb, 1);
4993 }
4994 }
4995 } else {
4996 i+= run;
4997 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4998 LAST_SKIP_BITS(re, &s->gb, 1);
4999 }
5000 if (i > 62){
5001 i-= 192;
5002 if(i&(~63)){
5003 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
5004 return -1;
5005 }
5006
5007 block[scan_table[i]] = level;
5008 break;
5009 }
5010
5011 block[scan_table[i]] = level;
5012 }
5013 CLOSE_READER(re, &s->gb);
5014 }
5015 not_coded:
5016 if (intra) {
5017 if(!s->use_intra_dc_vlc){
5018 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
5019
5020 i -= i>>31; //if(i == -1) i=0;
5021 }
5022
5023 mpeg4_pred_ac(s, block, n, dc_pred_dir);
5024 if (s->ac_pred) {
5025 i = 63; /* XXX: not optimal */
5026 }
5027 }
5028 s->block_last_index[n] = i;
5029 return 0;
5030 }
5031
5032 /* most is hardcoded. should extend to handle all h263 streams */
5033 int h263_decode_picture_header(MpegEncContext *s)
5034 {
5035 int format, width, height, i;
5036 uint32_t startcode;
5037
5038 align_get_bits(&s->gb);
5039
5040 startcode= get_bits(&s->gb, 22-8);
5041
5042 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
5043 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
5044
5045 if(startcode == 0x20)
5046 break;
5047 }
5048
5049 if (startcode != 0x20) {
5050 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5051 return -1;
5052 }
5053 /* temporal reference */
5054 i = get_bits(&s->gb, 8); /* picture timestamp */
5055 if( (s->picture_number&~0xFF)+i < s->picture_number)
5056 i+= 256;
5057 s->current_picture_ptr->pts=
5058 s->picture_number= (s->picture_number&~0xFF) + i;
5059
5060 /* PTYPE starts here */
5061 if (get_bits1(&s->gb) != 1) {
5062 /* marker */
5063 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5064 return -1;
5065 }
5066 if (get_bits1(&s->gb) != 0) {
5067 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5068 return -1; /* h263 id */
5069 }
5070 skip_bits1(&s->gb); /* split screen off */
5071 skip_bits1(&s->gb); /* camera off */
5072 skip_bits1(&s->gb); /* freeze picture release off */
5073
5074 format = get_bits(&s->gb, 3);
5075 /*
5076 0 forbidden
5077 1 sub-QCIF
5078 10 QCIF
5079 7 extended PTYPE (PLUSPTYPE)
5080 */
5081
5082 if (format != 7 && format != 6) {
5083 s->h263_plus = 0;
5084 /* H.263v1 */
5085 width = h263_format[format][0];
5086 height = h263_format[format][1];
5087 if (!width)
5088 return -1;
5089
5090 s->pict_type = FF_I_TYPE + get_bits1(&s->gb);
5091
5092 s->h263_long_vectors = get_bits1(&s->gb);
5093
5094 if (get_bits1(&s->gb) != 0) {
5095 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5096 return -1; /* SAC: off */
5097 }
5098 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5099 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5100
5101 s->pb_frame = get_bits1(&s->gb);
5102 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5103 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5104
5105 s->width = width;
5106 s->height = height;
5107 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5108 s->avctx->time_base= (AVRational){1001, 30000};
5109 } else {
5110 int ufep;
5111
5112 /* H.263v2 */
5113 s->h263_plus = 1;
5114 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5115
5116 /* ufep other than 0 and 1 are reserved */
5117 if (ufep == 1) {
5118 /* OPPTYPE */
5119 format = get_bits(&s->gb, 3);
5120 dprintf(s->avctx, "ufep=1, format: %d\n", format);
5121 s->custom_pcf= get_bits1(&s->gb);
5122 s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
5123 if (get_bits1(&s->gb) != 0) {
5124 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5125 }
5126 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5127 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5128 s->loop_filter= get_bits1(&s->gb);
5129 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5130
5131 s->h263_slice_structured= get_bits1(&s->gb);
5132 if (get_bits1(&s->gb) != 0) {
5133 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5134 }
5135 if (get_bits1(&s->gb) != 0) {
5136 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5137 }
5138 s->alt_inter_vlc= get_bits1(&s->gb);
5139 s->modified_quant= get_bits1(&s->gb);
5140 if(s->modified_quant)
5141 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5142
5143 skip_bits(&s->gb, 1); /* Prevent start code emulation */
5144
5145 skip_bits(&s->gb, 3); /* Reserved */
5146 } else if (ufep != 0) {
5147 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5148 return -1;
5149 }
5150
5151 /* MPPTYPE */
5152 s->pict_type = get_bits(&s->gb, 3);
5153 switch(s->pict_type){
5154 case 0: s->pict_type= FF_I_TYPE;break;
5155 case 1: s->pict_type= FF_P_TYPE;break;
5156 case 2: s->pict_type= FF_P_TYPE;s->pb_frame = 3;break;
5157 case 3: s->pict_type= FF_B_TYPE;break;
5158 case 7: s->pict_type= FF_I_TYPE;break; //ZYGO
5159 default:
5160 return -1;
5161 }
5162 skip_bits(&s->gb, 2);
5163 s->no_rounding = get_bits1(&s->gb);
5164 skip_bits(&s->gb, 4);
5165
5166 /* Get the picture dimensions */
5167 if (ufep) {
5168 if (format == 6) {
5169 /* Custom Picture Format (CPFMT) */
5170 s->aspect_ratio_info = get_bits(&s->gb, 4);
5171 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
5172 /* aspect ratios:
5173 0 - forbidden
5174 1 - 1:1
5175 2 - 12:11 (CIF 4:3)
5176 3 - 10:11 (525-type 4:3)
5177 4 - 16:11 (CIF 16:9)
5178 5 - 40:33 (525-type 16:9)
5179 6-14 - reserved
5180 */
5181 width = (get_bits(&s->gb, 9) + 1) * 4;
5182 skip_bits1(&s->gb);
5183 height = get_bits(&s->gb, 9) * 4;
5184 dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
5185 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5186 /* aspected dimensions */
5187 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5188 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5189 }else{
5190 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5191 }
5192 } else {
5193 width = h263_format[format][0];
5194 height = h263_format[format][1];
5195 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5196 }
5197 if ((width == 0) || (height == 0))
5198 return -1;
5199 s->width = width;
5200 s->height = height;
5201
5202 if(s->custom_pcf){
5203 int gcd;
5204 s->avctx->time_base.den= 1800000;
5205 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5206 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5207 if(s->avctx->time_base.num == 0){
5208 av_log(s, AV_LOG_ERROR, "zero framerate\n");
5209 return -1;
5210 }
5211 gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5212 s->avctx->time_base.den /= gcd;
5213 s->avctx->time_base.num /= gcd;
5214 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5215 }else{
5216 s->avctx->time_base= (AVRational){1001, 30000};
5217 }
5218 }
5219
5220 if(s->custom_pcf){
5221 skip_bits(&s->gb, 2); //extended Temporal reference
5222 }
5223
5224 if (ufep) {
5225 if (s->umvplus) {
5226 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5227 skip_bits1(&s->gb);
5228 }
5229 if(s->h263_slice_structured){
5230 if (get_bits1(&s->gb) != 0) {
5231 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5232 }
5233 if (get_bits1(&s->gb) != 0) {
5234 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5235 }
5236 }
5237 }
5238
5239 s->qscale = get_bits(&s->gb, 5);
5240 }
5241
5242 s->mb_width = (s->width + 15) / 16;
5243 s->mb_height = (s->height + 15) / 16;
5244 s->mb_num = s->mb_width * s->mb_height;
5245
5246 if (s->pb_frame) {
5247 skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */
5248 if (s->custom_pcf)
5249 skip_bits(&s->gb, 2); //extended Temporal reference
5250 skip_bits(&s->gb, 2); /* Quantization information for B-pictures */
5251 }
5252
5253 /* PEI */
5254 while (get_bits1(&s->gb) != 0) {
5255 skip_bits(&s->gb, 8);
5256 }
5257
5258 if(s->h263_slice_structured){
5259 if (get_bits1(&s->gb) != 1) {
5260 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5261 return -1;
5262 }
5263
5264 ff_h263_decode_mba(s);
5265
5266 if (get_bits1(&s->gb) != 1) {
5267 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5268 return -1;
5269 }
5270 }
5271 s->f_code = 1;
5272
5273 if(s->h263_aic){
5274 s->y_dc_scale_table=
5275 s->c_dc_scale_table= ff_aic_dc_scale_table;
5276 }else{
5277 s->y_dc_scale_table=
5278 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5279 }
5280
5281 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5282 show_pict_info(s);
5283 }
5284 #if 1
5285 if (s->pict_type == FF_I_TYPE && s->codec_tag == AV_RL32("ZYGO")){
5286 int i,j;
5287 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5288 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5289 for(i=0; i<13; i++){
5290 for(j=0; j<3; j++){
5291 int v= get_bits(&s->gb, 8);
5292 v |= get_sbits(&s->gb, 8)<<8;
5293 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5294 }
5295 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5296 }
5297 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5298 }
5299 #endif
5300
5301 return 0;
5302 }
5303
5304 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5305 {
5306 int i;
5307 int a= 2<<s->sprite_warping_accuracy;
5308 int rho= 3-s->sprite_warping_accuracy;
5309 int r=16/a;
5310 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5311 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5312 int sprite_ref[4][2];
5313 int virtual_ref[2][2];
5314 int w2, h2, w3, h3;
5315 int alpha=0, beta=0;
5316 int w= s->width;
5317 int h= s->height;
5318 int min_ab;
5319
5320 for(i=0; i<s->num_sprite_warping_points; i++){
5321 int length;
5322 int x=0, y=0;
5323
5324 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5325 if(length){
5326 x= get_xbits(gb, length);
5327 }
5328 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5329
5330 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5331 if(length){
5332 y=get_xbits(gb, length);
5333 }
5334 skip_bits1(gb); /* marker bit */
5335 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5336 s->sprite_traj[i][0]= d[i][0]= x;
5337 s->sprite_traj[i][1]= d[i][1]= y;
5338 }
5339 for(; i<4; i++)
5340 s->sprite_traj[i][0]= s->sprite_traj[i][1]= 0;
5341
5342 while((1<<alpha)<w) alpha++;
5343 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5344 w2= 1<<alpha;
5345 h2= 1<<beta;
5346
5347 // Note, the 4th point isn't used for GMC
5348 if(s->divx_version==500 && s->divx_build==413){
5349 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5350 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5351 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5352 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5353 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5354 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5355 } else {
5356 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5357 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5358 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5359 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5360 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5361 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5362 }
5363 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5364 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5365
5366 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5367 // perhaps it should be reordered to be more readable ...
5368 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5369 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5370 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5371 + 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);
5372 virtual_ref[0][1]= 16*vop_ref[0][1]
5373 + 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);
5374 virtual_ref[1][0]= 16*vop_ref[0][0]
5375 + 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);
5376 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5377 + 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);
5378
5379 switch(s->num_sprite_warping_points)
5380 {
5381 case 0:
5382 s->sprite_offset[0][0]= 0;
5383 s->sprite_offset[0][1]= 0;
5384 s->sprite_offset[1][0]= 0;
5385 s->sprite_offset[1][1]= 0;
5386 s->sprite_delta[0][0]= a;
5387 s->sprite_delta[0][1]= 0;
5388 s->sprite_delta[1][0]= 0;
5389 s->sprite_delta[1][1]= a;
5390 s->sprite_shift[0]= 0;
5391 s->sprite_shift[1]= 0;
5392 break;
5393 case 1: //GMC only
5394 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5395 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5396 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5397 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5398 s->sprite_delta[0][0]= a;
5399 s->sprite_delta[0][1]= 0;
5400 s->sprite_delta[1][0]= 0;
5401 s->sprite_delta[1][1]= a;
5402 s->sprite_shift[0]= 0;
5403 s->sprite_shift[1]= 0;
5404 break;
5405 case 2:
5406 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5407 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5408 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5409 + (1<<(alpha+rho-1));
5410 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5411 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5412 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5413 + (1<<(alpha+rho-1));
5414 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5415 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5416 +2*w2*r*sprite_ref[0][0]
5417 - 16*w2
5418 + (1<<(alpha+rho+1)));
5419 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5420 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5421 +2*w2*r*sprite_ref[0][1]
5422 - 16*w2
5423 + (1<<(alpha+rho+1)));
5424 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5425 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5426 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5427 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5428
5429 s->sprite_shift[0]= alpha+rho;
5430 s->sprite_shift[1]= alpha+rho+2;
5431 break;
5432 case 3:
5433 min_ab= FFMIN(alpha, beta);
5434 w3= w2>>min_ab;
5435 h3= h2>>min_ab;
5436 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5437 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5438 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5439 + (1<<(alpha+beta+rho-min_ab-1));
5440 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5441 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5442 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5443 + (1<<(alpha+beta+rho-min_ab-1));
5444 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5445 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5446 + 2*w2*h3*r*sprite_ref[0][0]
5447 - 16*w2*h3
5448 + (1<<(alpha+beta+rho-min_ab+1));
5449 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5450 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5451 + 2*w2*h3*r*sprite_ref[0][1]
5452 - 16*w2*h3
5453 + (1<<(alpha+beta+rho-min_ab+1));
5454 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5455 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5456 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5457 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5458
5459 s->sprite_shift[0]= alpha + beta + rho - min_ab;
5460 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5461 break;
5462 }
5463 /* try to simplify the situation */
5464 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5465 && s->sprite_delta[0][1] == 0
5466 && s->sprite_delta[1][0] == 0
5467 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5468 {
5469 s->sprite_offset[0][0]>>=s->sprite_shift[0];
5470 s->sprite_offset[0][1]>>=s->sprite_shift[0];
5471 s->sprite_offset[1][0]>>=s->sprite_shift[1];
5472 s->sprite_offset[1][1]>>=s->sprite_shift[1];
5473 s->sprite_delta[0][0]= a;
5474 s->sprite_delta[0][1]= 0;
5475 s->sprite_delta[1][0]= 0;
5476 s->sprite_delta[1][1]= a;
5477 s->sprite_shift[0]= 0;
5478 s->sprite_shift[1]= 0;
5479 s->real_sprite_warping_points=1;
5480 }
5481 else{
5482 int shift_y= 16 - s->sprite_shift[0];
5483 int shift_c= 16 - s->sprite_shift[1];
5484 //printf("shifts %d %d\n", shift_y, shift_c);
5485 for(i=0; i<2; i++){
5486 s->sprite_offset[0][i]<<= shift_y;
5487 s->sprite_offset[1][i]<<= shift_c;
5488 s->sprite_delta[0][i]<<= shift_y;
5489 s->sprite_delta[1][i]<<= shift_y;
5490 s->sprite_shift[i]= 16;
5491 }
5492 s->real_sprite_warping_points= s->num_sprite_warping_points;
5493 }
5494 #if 0
5495 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5496 vop_ref[0][0], vop_ref[0][1],
5497 vop_ref[1][0], vop_ref[1][1],
5498 vop_ref[2][0], vop_ref[2][1],
5499 sprite_ref[0][0], sprite_ref[0][1],
5500 sprite_ref[1][0], sprite_ref[1][1],
5501 sprite_ref[2][0], sprite_ref[2][1],
5502 virtual_ref[0][0], virtual_ref[0][1],
5503 virtual_ref[1][0], virtual_ref[1][1]
5504 );
5505
5506 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5507 s->sprite_offset[0][0], s->sprite_offset[0][1],
5508 s->sprite_delta[0][0], s->sprite_delta[0][1],
5509 s->sprite_delta[1][0], s->sprite_delta[1][1],
5510 s->sprite_shift[0]
5511 );
5512 #endif
5513 }
5514
5515 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5516 int hours, minutes, seconds;
5517
5518 hours= get_bits(gb, 5);
5519 minutes= get_bits(gb, 6);
5520 skip_bits1(gb);
5521 seconds= get_bits(gb, 6);
5522
5523 s->time_base= seconds + 60*(minutes + 60*hours);
5524
5525 skip_bits1(gb);
5526 skip_bits1(gb);
5527
5528 return 0;
5529 }
5530
5531 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5532 int width, height, vo_ver_id;
5533
5534 /* vol header */
5535 skip_bits(gb, 1); /* random access */
5536 s->vo_type= get_bits(gb, 8);
5537 if (get_bits1(gb) != 0) { /* is_ol_id */
5538 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5539 skip_bits(gb, 3); /* vo_priority */
5540 } else {
5541 vo_ver_id = 1;
5542 }
5543 //printf("vo type:%d\n",s->vo_type);
5544 s->aspect_ratio_info= get_bits(gb, 4);
5545 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5546 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5547 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5548 }else{
5549 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5550 }
5551
5552 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5553 int chroma_format= get_bits(gb, 2);
5554 if(chroma_format!=CHROMA_420){
5555 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5556 }
5557 s->low_delay= get_bits1(gb);
5558 if(get_bits1(gb)){ /* vbv parameters */
5559 get_bits(gb, 15); /* first_half_bitrate */
5560 skip_bits1(gb); /* marker */
5561 get_bits(gb, 15); /* latter_half_bitrate */
5562 skip_bits1(gb); /* marker */
5563 get_bits(gb, 15); /* first_half_vbv_buffer_size */
5564 skip_bits1(gb); /* marker */
5565 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5566 get_bits(gb, 11); /* first_half_vbv_occupancy */
5567 skip_bits1(gb); /* marker */
5568 get_bits(gb, 15); /* latter_half_vbv_occupancy */
5569 skip_bits1(gb); /* marker */
5570 }
5571 }else{
5572 // set low delay flag only once the smartest? low delay detection won't be overriden
5573 if(s->picture_number==0)
5574 s->low_delay=0;
5575 }
5576
5577 s->shape = get_bits(gb, 2); /* vol shape */
5578 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5579 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5580 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5581 skip_bits(gb, 4); //video_object_layer_shape_extension
5582 }
5583
5584 check_marker(gb, "before time_increment_resolution");
5585
5586 s->avctx->time_base.den = get_bits(gb, 16);
5587 if(!s->avctx->time_base.den){
5588 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5589 return -1;
5590 }
5591
5592 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5593 if (s->time_increment_bits < 1)
5594 s->time_increment_bits = 1;
5595
5596 check_marker(gb, "before fixed_vop_rate");
5597
5598 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
5599 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5600 }else
5601 s->avctx->time_base.num = 1;
5602
5603 s->t_frame=0;
5604
5605 if (s->shape != BIN_ONLY_SHAPE) {
5606 if (s->shape == RECT_SHAPE) {
5607 skip_bits1(gb); /* marker */
5608 width = get_bits(gb, 13);
5609 skip_bits1(gb); /* marker */
5610 height = get_bits(gb, 13);
5611 skip_bits1(gb); /* marker */
5612 if(width && height && !(s->width && s->codec_tag == AV_RL32("MP4S"))){ /* they should be non zero but who knows ... */
5613 s->width = width;
5614 s->height = height;
5615 // printf("width/height: %d %d\n", width, height);
5616 }
5617 }
5618
5619 s->progressive_sequence=
5620 s->progressive_frame= get_bits1(gb)^1;
5621 s->interlaced_dct=0;
5622 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5623 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
5624 if (vo_ver_id == 1) {
5625 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5626 } else {
5627 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5628 }
5629 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5630 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5631 if(s->vol_sprite_usage==STATIC_SPRITE){
5632 s->sprite_width = get_bits(gb, 13);
5633 skip_bits1(gb); /* marker */
5634 s->sprite_height= get_bits(gb, 13);
5635 skip_bits1(gb); /* marker */
5636 s->sprite_left = get_bits(gb, 13);
5637 skip_bits1(gb); /* marker */
5638 s->sprite_top = get_bits(gb, 13);
5639 skip_bits1(gb); /* marker */
5640 }
5641 s->num_sprite_warping_points= get_bits(gb, 6);
5642 if(s->num_sprite_warping_points > 3){
5643 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points);
5644 s->num_sprite_warping_points= 0;
5645 return -1;
5646 }
5647 s->sprite_warping_accuracy = get_bits(gb, 2);
5648 s->sprite_brightness_change= get_bits1(gb);
5649 if(s->vol_sprite_usage==STATIC_SPRITE)
5650 s->low_latency_sprite= get_bits1(gb);
5651 }
5652 // FIXME sadct disable bit if verid!=1 && shape not rect
5653
5654 if (get_bits1(gb) == 1) { /* not_8_bit */
5655 s->quant_precision = get_bits(gb, 4); /* quant_precision */
5656 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5657 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5658 } else {
5659 s->quant_precision = 5;
5660 }
5661
5662 // FIXME a bunch of grayscale shape things
5663
5664 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5665 int i, v;
5666
5667 /* load default matrixes */
5668 for(i=0; i<64; i++){
5669 int j= s->dsp.idct_permutation[i];
5670 v= ff_mpeg4_default_intra_matrix[i];
5671 s->intra_matrix[j]= v;
5672 s->chroma_intra_matrix[j]= v;
5673
5674 v= ff_mpeg4_default_non_intra_matrix[i];
5675 s->inter_matrix[j]= v;
5676 s->chroma_inter_matrix[j]= v;
5677 }
5678
5679 /* load custom intra matrix */
5680 if(get_bits1(gb)){
5681 int last=0;
5682 for(i=0; i<64; i++){
5683 int j;
5684 v= get_bits(gb, 8);
5685 if(v==0) break;
5686
5687 last= v;
5688 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5689 s->intra_matrix[j]= v;
5690 s->chroma_intra_matrix[j]= v;
5691 }
5692
5693 /* replicate last value */
5694 for(; i<64; i++){
5695 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5696 s->intra_matrix[j]= last;
5697 s->chroma_intra_matrix[j]= last;
5698 }
5699 }
5700
5701 /* load custom non intra matrix */
5702 if(get_bits1(gb)){
5703 int last=0;
5704 for(i=0; i<64; i++){
5705 int j;
5706 v= get_bits(gb, 8);
5707 if(v==0) break;
5708
5709 last= v;
5710 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5711 s->inter_matrix[j]= v;
5712 s->chroma_inter_matrix[j]= v;
5713 }
5714
5715 /* replicate last value */
5716 for(; i<64; i++){
5717 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5718 s->inter_matrix[j]= last;
5719 s->chroma_inter_matrix[j]= last;
5720 }
5721 }
5722
5723 // FIXME a bunch of grayscale shape things
5724 }
5725
5726 if(vo_ver_id != 1)
5727 s->quarter_sample= get_bits1(gb);
5728 else s->quarter_sample=0;
5729
5730 if(!get_bits1(gb)){
5731 int pos= get_bits_count(gb);
5732 int estimation_method= get_bits(gb, 2);
5733 if(estimation_method<2){
5734 if(!get_bits1(gb)){
5735 s->cplx_estimation_trash_i += 8*get_bits1(gb); //opaque
5736 s->cplx_estimation_trash_i += 8*get_bits1(gb); //transparent
5737 s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_cae
5738 s->cplx_estimation_trash_i += 8*get_bits1(gb); //inter_cae
5739 s->cplx_estimation_trash_i += 8*get_bits1(gb); //no_update
5740 s->cplx_estimation_trash_i += 8*get_bits1(gb); //upampling
5741 }
5742 if(!get_bits1(gb)){
5743 s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_blocks
5744 s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter_blocks
5745 s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter4v_blocks
5746 s->cplx_estimation_trash_i += 8*get_bits1(gb); //not coded blocks
5747 }
5748 if(!check_marker(gb, "in complexity estimation part 1")){
5749 skip_bits_long(gb, pos - get_bits_count(gb));
5750 goto no_cplx_est;
5751 }
5752 if(!get_bits1(gb)){
5753 s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_coeffs
5754 s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_lines
5755 s->cplx_estimation_trash_i += 8*get_bits1(gb); //vlc_syms
5756 s->cplx_estimation_trash_i += 4*get_bits1(gb); //vlc_bits
5757 }
5758 if(!get_bits1(gb)){
5759 s->cplx_estimation_trash_p += 8*get_bits1(gb); //apm
5760 s->cplx_estimation_trash_p += 8*get_bits1(gb); //npm
5761 s->cplx_estimation_trash_b += 8*get_bits1(gb); //interpolate_mc_q
5762 s->cplx_estimation_trash_p += 8*get_bits1(gb); //forwback_mc_q
5763 s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel2
5764 s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel4
5765 }
5766 if(!check_marker(gb, "in complexity estimation part 2")){
5767 skip_bits_long(gb, pos - get_bits_count(gb));
5768 goto no_cplx_est;
5769 }
5770 if(estimation_method==1){
5771 s->cplx_estimation_trash_i += 8*get_bits1(gb); //sadct
5772 s->cplx_estimation_trash_p += 8*get_bits1(gb); //qpel
5773 }
5774 }else
5775 av_log(s->avctx, AV_LOG_ERROR, "Invalid Complexity estimation method %d\n", estimation_method);
5776 }else{
5777 no_cplx_est:
5778 s->cplx_estimation_trash_i=
5779 s->cplx_estimation_trash_p=
5780 s->cplx_estimation_trash_b= 0;
5781 }
5782
5783 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5784
5785 s->data_partitioning= get_bits1(gb);
5786 if(s->data_partitioning){
5787 s->rvlc= get_bits1(gb);
5788 }
5789
5790 if(vo_ver_id != 1) {
5791 s->new_pred= get_bits1(gb);
5792 if(s->new_pred){
5793 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5794 skip_bits(gb, 2); /* requested upstream message type */
5795 skip_bits1(gb); /* newpred segment type */
5796 }
5797 s->reduced_res_vop= get_bits1(gb);
5798 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5799 }
5800 else{
5801 s->new_pred=0;
5802 s->reduced_res_vop= 0;
5803 }
5804
5805 s->scalability= get_bits1(gb);
5806
5807 if (s->scalability) {
5808 GetBitContext bak= *gb;
5809 int ref_layer_id;
5810 int ref_layer_sampling_dir;
5811 int h_sampling_factor_n;
5812 int h_sampling_factor_m;
5813 int v_sampling_factor_n;
5814 int v_sampling_factor_m;
5815
5816 s->hierachy_type= get_bits1(gb);
5817 ref_layer_id= get_bits(gb, 4);
5818 ref_layer_sampling_dir= get_bits1(gb);
5819 h_sampling_factor_n= get_bits(gb, 5);
5820 h_sampling_factor_m= get_bits(gb, 5);
5821 v_sampling_factor_n= get_bits(gb, 5);
5822 v_sampling_factor_m= get_bits(gb, 5);
5823 s->enhancement_type= get_bits1(gb);
5824
5825 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
5826 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5827
5828 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5829 s->scalability=0;
5830
5831 *gb= bak;
5832 }else
5833 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5834
5835 // bin shape stuff FIXME
5836 }
5837 }
5838 return 0;
5839 }
5840
5841 /**
5842 * decodes the user data stuff in the header.
5843 * Also initializes divx/xvid/lavc_version/build.
5844 */
5845 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5846 char buf[256];
5847 int i;
5848 int e;
5849 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5850 char last;
5851
5852 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
5853 if(show_bits(gb, 23) == 0) break;
5854 buf[i]= get_bits(gb, 8);
5855 }
5856 buf[i]=0;
5857
5858 /* divx detection */
5859 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5860 if(e<2)
5861 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5862 if(e>=2){
5863 s->divx_version= ver;
5864 s->divx_build= build;
5865 s->divx_packed= e==3 && last=='p';
5866 if(s->divx_packed && !s->showed_packed_warning) {
5867 av_log(s->avctx, AV_LOG_WARNING, "Invalid and inefficient vfw-avi packed B frames detected\n");
5868 s->showed_packed_warning=1;
5869 }
5870 }
5871
5872 /* ffmpeg detection */
5873 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5874 if(e!=4)
5875 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5876 if(e!=4){
5877 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5878 if (e>1)
5879 build= (ver<<16) + (ver2<<8) + ver3;
5880 }
5881 if(e!=4){
5882 if(strcmp(buf, "ffmpeg")==0){
5883 s->lavc_build= 4600;
5884 }
5885 }
5886 if(e==4){
5887 s->lavc_build= build;
5888 }
5889
5890 /* Xvid detection */
5891 e=sscanf(buf, "XviD%d", &build);
5892 if(e==1){
5893 s->xvid_build= build;
5894 }
5895
5896 //printf("User Data: %s\n", buf);
5897 return 0;
5898 }
5899
5900 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5901 int time_incr, time_increment;
5902
5903 s->pict_type = get_bits(gb, 2) + FF_I_TYPE; /* pict type: I = 0 , P = 1 */
5904 if(s->pict_type==FF_B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5905 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5906 s->low_delay=0;
5907 }
5908
5909 s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE;
5910 if(s->partitioned_frame)
5911 s->decode_mb= mpeg4_decode_partitioned_mb;
5912 else
5913 s->decode_mb= ff_mpeg4_decode_mb;
5914
5915 time_incr=0;
5916 while (get_bits1(gb) != 0)
5917 time_incr++;
5918
5919 check_marker(gb, "before time_increment");
5920
5921 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5922 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5923
5924 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5925 if(show_bits(gb, s->time_increment_bits+1)&1) break;
5926 }
5927
5928 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5929 }
5930
5931 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5932 else time_increment= get_bits(gb, s->time_increment_bits);
5933
5934 // printf("%d %X\n", s->time_increment_bits, time_increment);
5935 //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);
5936 if(s->pict_type!=FF_B_TYPE){
5937 s->last_time_base= s->time_base;
5938 s->time_base+= time_incr;
5939 s->time= s->time_base*s->avctx->time_base.den + time_increment;
5940 if(s->workaround_bugs&FF_BUG_UMP4){
5941 if(s->time < s->last_non_b_time){
5942 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5943 s->time_base++;
5944 s->time+= s->avctx->time_base.den;
5945 }
5946 }
5947 s->pp_time= s->time - s->last_non_b_time;
5948 s->last_non_b_time= s->time;
5949 }else{
5950 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5951 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5952 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5953 // printf("messed up order, maybe after seeking? skipping current b frame\n");
5954 return FRAME_SKIPPED;
5955 }
5956 ff_mpeg4_init_direct_mv(s);
5957
5958 if(s->t_frame==0) s->t_frame= s->pb_time;
5959 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5960 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5961 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5962 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
5963 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5964 if(!s->progressive_sequence){
5965 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
5966 return FRAME_SKIPPED;
5967 }
5968 }
5969 //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);
5970
5971 if(s->avctx->time_base.num)
5972 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5973 else
5974 s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5975 if(s->avctx->debug&FF_DEBUG_PTS)
5976 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5977
5978 check_marker(gb, "before vop_coded");
5979
5980 /* vop coded */
5981 if (get_bits1(gb) != 1){
5982 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5983 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5984 return FRAME_SKIPPED;
5985 }
5986 //printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5987 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5988 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == FF_P_TYPE
5989 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5990 /* rounding type for motion estimation */
5991 s->no_rounding = get_bits1(gb);
5992 } else {
5993 s->no_rounding = 0;
5994 }
5995 //FIXME reduced res stuff
5996
5997 if (s->shape != RECT_SHAPE) {
5998 if (s->vol_sprite_usage != 1 || s->pict_type != FF_I_TYPE) {
5999 int width, height, hor_spat_ref, ver_spat_ref;
6000
6001 width = get_bits(gb, 13);
6002 skip_bits1(gb); /* marker */
6003 height = get_bits(gb, 13);
6004 skip_bits1(gb); /* marker */
6005 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
6006 skip_bits1(gb); /* marker */
6007 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
6008 }
6009 skip_bits1(gb); /* change_CR_disable */
6010
6011 if (get_bits1(gb) != 0) {
6012 skip_bits(gb, 8); /* constant_alpha_value */
6013 }
6014 }
6015 //FIXME complexity estimation stuff
6016
6017 if (s->shape != BIN_ONLY_SHAPE) {
6018 skip_bits_long(gb, s->cplx_estimation_trash_i);
6019 if(s->pict_type != FF_I_TYPE)
6020 skip_bits_long(gb, s->cplx_estimation_trash_p);
6021 if(s->pict_type == FF_B_TYPE)
6022 skip_bits_long(gb, s->cplx_estimation_trash_b);
6023
6024 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
6025 if(!s->progressive_sequence){
6026 s->top_field_first= get_bits1(gb);
6027 s->alternate_scan= get_bits1(gb);
6028 }else
6029 s->alternate_scan= 0;
6030 }
6031
6032 if(s->alternate_scan){
6033 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
6034 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
6035 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
6036 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
6037 } else{
6038 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
6039 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
6040 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
6041 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
6042 }
6043
6044 if(s->pict_type == FF_S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
6045 mpeg4_decode_sprite_trajectory(s, gb);
6046 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
6047 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
6048 }
6049
6050 if (s->shape != BIN_ONLY_SHAPE) {
6051 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
6052 if(s->qscale==0){
6053 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
6054 return -1; // makes no sense to continue, as there is nothing left from the image then
6055 }
6056
6057 if (s->pict_type != FF_I_TYPE) {
6058 s->f_code = get_bits(gb, 3); /* fcode_for */
6059 if(s->f_code==0){
6060 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
6061 return -1; // makes no sense to continue, as the MV decoding will break very quickly
6062 }
6063 }else
6064 s->f_code=1;
6065
6066 if (s->pict_type == FF_B_TYPE) {
6067 s->b_code = get_bits(gb, 3);
6068 }else
6069 s->b_code=1;
6070
6071 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
6072 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",
6073 s->qscale, s->f_code, s->b_code,
6074 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")),
6075 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
6076 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
6077 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);
6078 }
6079
6080 if(!s->scalability){
6081 if (s->shape!=RECT_SHAPE && s->pict_type!=FF_I_TYPE) {
6082 skip_bits1(gb); // vop shape coding type
6083 }
6084 }else{
6085 if(s->enhancement_type){
6086 int load_backward_shape= get_bits1(gb);
6087 if(load_backward_shape){
6088 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
6089 }
6090 }
6091 skip_bits(gb, 2); //ref_select_code
6092 }
6093 }
6094 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
6095 // note we cannot detect divx5 without b-frames easily (although it's buggy too)
6096 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
6097 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
6098 s->low_delay=1;
6099 }
6100
6101 s->picture_number++; // better than pic number==0 always ;)
6102
6103 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
6104 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
6105
6106 if(s->workaround_bugs&FF_BUG_EDGE){
6107 s->h_edge_pos= s->width;
6108 s->v_edge_pos= s->height;
6109 }
6110 return 0;
6111 }
6112
6113 /**
6114 * decode mpeg4 headers
6115 * @return <0 if no VOP found (or a damaged one)
6116 * FRAME_SKIPPED if a not coded VOP is found
6117 * 0 if a VOP is found
6118 */
6119 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6120 {
6121 int startcode, v;
6122
6123 /* search next start code */
6124 align_get_bits(gb);
6125
6126 if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){
6127 skip_bits(gb, 24);
6128 if(get_bits(gb, 8) == 0xF0)
6129 goto end;
6130 }
6131
6132 startcode = 0xff;
6133 for(;;) {
6134 if(get_bits_count(gb) >= gb->size_in_bits){
6135 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6136 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6137 return FRAME_SKIPPED; //divx bug
6138 }else
6139 return -1; //end of stream
6140 }
6141
6142 /* use the bits after the test */
6143 v = get_bits(gb, 8);
6144 startcode = ((startcode << 8) | v) & 0xffffffff;
6145
6146 if((startcode&0xFFFFFF00) != 0x100)
6147 continue; //no startcode
6148
6149 if(s->avctx->debug&FF_DEBUG_STARTCODE){
6150 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6151 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6152 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6153 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6154 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6155 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6156 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6157 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6158 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6159 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6160 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6161 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6162 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6163 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6164 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6165 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6166 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6167 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6168 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6169 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6170 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6171 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6172 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6173 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6174 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6175 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6176 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6177 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6178 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6179 }
6180
6181 if(startcode >= 0x120 && startcode <= 0x12F){
6182 if(decode_vol_header(s, gb) < 0)
6183 return -1;
6184 }
6185 else if(startcode == USER_DATA_STARTCODE){
6186 decode_user_data(s, gb);
6187 }
6188 else if(startcode == GOP_STARTCODE){
6189 mpeg4_decode_gop_header(s, gb);
6190 }
6191 else if(startcode == VOP_STARTCODE){
6192 break;
6193 }
6194
6195 align_get_bits(gb);
6196 startcode = 0xff;
6197 }
6198 end:
6199 if(s->flags& CODEC_FLAG_LOW_DELAY)
6200 s->low_delay=1;
6201 s->avctx->has_b_frames= !s->low_delay;
6202 return decode_vop_header(s, gb);
6203 }
6204
6205 /* don't understand why they choose a different header ! */
6206 int intel_h263_decode_picture_header(MpegEncContext *s)
6207 {
6208 int format;
6209
6210 /* picture header */
6211 if (get_bits_long(&s->gb, 22) != 0x20) {
6212 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6213 return -1;
6214 }
6215 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6216
6217 if (get_bits1(&s->gb) != 1) {
6218 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6219 return -1; /* marker */
6220 }
6221 if (get_bits1(&s->gb) != 0) {
6222 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6223 return -1; /* h263 id */
6224 }
6225 skip_bits1(&s->gb); /* split screen off */
6226 skip_bits1(&s->gb); /* camera off */
6227 skip_bits1(&s->gb); /* freeze picture release off */
6228
6229 format = get_bits(&s->gb, 3);
6230 if (format != 7) {
6231 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6232 return -1;
6233 }
6234 s->h263_plus = 0;
6235
6236 s->pict_type = FF_I_TYPE + get_bits1(&s->gb);
6237
6238 s->unrestricted_mv = get_bits1(&s->gb);
6239 s->h263_long_vectors = s->unrestricted_mv;
6240
6241 if (get_bits1(&s->gb) != 0) {
6242 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6243 return -1; /* SAC: off */
6244 }
6245 s->obmc= get_bits1(&s->gb);
6246 s->pb_frame = get_bits1(&s->gb);
6247
6248 if(format == 7){
6249 format = get_bits(&s->gb, 3);
6250 if(format == 0 || format == 7){
6251 av_log(s->avctx, AV_LOG_ERROR, "Wrong Intel H263 format\n");
6252 return -1;
6253 }
6254 if(get_bits(&s->gb, 2))
6255 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
6256 s->loop_filter = get_bits1(&s->gb);
6257 if(get_bits1(&s->gb))
6258 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
6259 if(get_bits1(&s->gb))
6260 s->pb_frame = 2;
6261 if(get_bits(&s->gb, 5))
6262 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
6263 if(get_bits(&s->gb, 5) != 1)
6264 av_log(s->avctx, AV_LOG_ERROR, "Invalid marker\n");
6265 }
6266 if(format == 6){
6267 int ar = get_bits(&s->gb, 4);
6268 skip_bits(&s->gb, 9); // display width
6269 skip_bits1(&s->gb);
6270 skip_bits(&s->gb, 9); // display height
6271 if(ar == 15){
6272 skip_bits(&s->gb, 8); // aspect ratio - width
6273 skip_bits(&s->gb, 8); // aspect ratio - height
6274 }
6275 }
6276
6277 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6278 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6279
6280 if(s->pb_frame){
6281 skip_bits(&s->gb, 3); //temporal reference for B-frame
6282 skip_bits(&s->gb, 2); //dbquant
6283 }
6284
6285 /* PEI */
6286 while (get_bits1(&s->gb) != 0) {
6287 skip_bits(&s->gb, 8);
6288 }
6289 s->f_code = 1;
6290
6291 s->y_dc_scale_table=
6292 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6293
6294 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
6295 show_pict_info(s);
6296
6297 return 0;
6298 }
6299
6300 int flv_h263_decode_picture_header(MpegEncContext *s)
6301 {
6302 int format, width, height;
6303
6304 /* picture header */
6305 if (get_bits_long(&s->gb, 17) != 1) {
6306 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6307 return -1;
6308 }
6309 format = get_bits(&s->gb, 5);
6310 if (format != 0 && format != 1) {
6311 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6312 return -1;
6313 }
6314 s->h263_flv = format+1;
6315 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6316 format = get_bits(&s->gb, 3);
6317 switch (format) {
6318 case 0:
6319 width = get_bits(&s->gb, 8);
6320 height = get_bits(&s->gb, 8);
6321 break;
6322 case 1:
6323 width = get_bits(&s->gb, 16);
6324 height = get_bits(&s->gb, 16);
6325 break;
6326 case 2:
6327 width = 352;
6328 height = 288;
6329 break;
6330 case 3:
6331 width = 176;
6332 height = 144;
6333 break;
6334 case 4:
6335 width = 128;
6336 height = 96;
6337 break;
6338 case 5:
6339 width = 320;
6340 height = 240;
6341 break;
6342 case 6:
6343 width = 160;
6344 height = 120;
6345 break;
6346 default:
6347 width = height = 0;
6348 break;
6349 }
6350 if(avcodec_check_dimensions(s->avctx, width, height))
6351 return -1;
6352 s->width = width;
6353 s->height = height;
6354
6355 s->pict_type = FF_I_TYPE + get_bits(&s->gb, 2);
6356 s->dropable= s->pict_type > FF_P_TYPE;
6357 if (s->dropable)
6358 s->pict_type = FF_P_TYPE;
6359
6360 skip_bits1(&s->gb); /* deblocking flag */
6361 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6362
6363 s->h263_plus = 0;
6364
6365 s->unrestricted_mv = 1;
6366 s->h263_long_vectors = 0;
6367
6368 /* PEI */
6369 while (get_bits1(&s->gb) != 0) {
6370 skip_bits(&s->gb, 8);
6371 }
6372 s->f_code = 1;
6373
6374 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6375 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6376 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6377 }
6378
6379 s->y_dc_scale_table=
6380 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6381
6382 return 0;
6383 }
lucabe's unfinished and experimental patches for ffmpeg