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