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