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