?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r105: This commit was manufactured by cvs2svn to create tag
[cinelerra_cv/mob.git] / hvirtual / quicktime / libavcodec / h263.c
blobbbeea3abd4cce03f47da1d9573abaf21dd4d6d75
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 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * ac prediction encoding, b-frame support, error resilience, optimizations,
22 * qpel decoding, gmc decoding, interlaced decoding,
23 * by Michael Niedermayer <michaelni@gmx.at>
24 */
25
26 //#define DEBUG
27 #include "common.h"
28 #include "dsputil.h"
29 #include "avcodec.h"
30 #include "mpegvideo.h"
31 #include "h263data.h"
32 #include "mpeg4data.h"
33
34 //#undef NDEBUG
35 //#include <assert.h>
36
37 #if 1
38 #define PRINT_MB_TYPE(a) {}
39 #else
40 #define PRINT_MB_TYPE(a) printf(a)
41 #endif
42
43 #define INTRA_MCBPC_VLC_BITS 6
44 #define INTER_MCBPC_VLC_BITS 6
45 #define CBPY_VLC_BITS 6
46 #define MV_VLC_BITS 9
47 #define DC_VLC_BITS 9
48 #define SPRITE_TRAJ_VLC_BITS 6
49 #define MB_TYPE_B_VLC_BITS 4
50 #define TEX_VLC_BITS 9
51
52 #ifdef CONFIG_ENCODERS
53 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
54 int n);
55 static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
56 static void h263p_encode_umotion(MpegEncContext * s, int val);
57 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
58 int n, int dc, UINT8 *scan_table,
59 PutBitContext *dc_pb, PutBitContext *ac_pb);
60 #endif
61
62 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
63 static int h263p_decode_umotion(MpegEncContext * s, int pred);
64 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
65 int n, int coded);
66 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
67 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
68 int n, int coded, int intra);
69 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
70 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
71 int dir);
72 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
73 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
74
75 extern UINT32 inverse[256];
76
77 static UINT16 uni_DCtab_lum [512][2];
78 static UINT16 uni_DCtab_chrom[512][2];
79
80 #ifdef CONFIG_ENCODERS
81 static UINT16 (*mv_penalty)[MAX_MV*2+1]= NULL;
82 static UINT8 fcode_tab[MAX_MV*2+1];
83 static UINT8 umv_fcode_tab[MAX_MV*2+1];
84
85 static UINT32 uni_mpeg4_intra_rl_bits[64*64*2*2];
86 static UINT8 uni_mpeg4_intra_rl_len [64*64*2*2];
87 static UINT32 uni_mpeg4_inter_rl_bits[64*64*2*2];
88 static UINT8 uni_mpeg4_inter_rl_len [64*64*2*2];
89 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
90 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
91
92 /* mpeg4
93 inter
94 max level: 24/6
95 max run: 53/63
96
97 intra
98 max level: 53/16
99 max run: 29/41
100 */
101 #endif
102
103
104 int h263_get_picture_format(int width, int height)
105 {
106 int format;
107
108 if (width == 128 && height == 96)
109 format = 1;
110 else if (width == 176 && height == 144)
111 format = 2;
112 else if (width == 352 && height == 288)
113 format = 3;
114 else if (width == 704 && height == 576)
115 format = 4;
116 else if (width == 1408 && height == 1152)
117 format = 5;
118 else
119 format = 7;
120 return format;
121 }
122
123 static void float_aspect_to_info(MpegEncContext * s, float aspect){
124 int i;
125
126 aspect*= s->height/(double)s->width;
127 //printf("%f\n", aspect);
128
129 if(aspect==0) aspect= 1.0;
130
131 ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
132
133 //printf("%d %d\n", s->aspected_width, s->aspected_height);
134 for(i=1; i<6; i++){
135 if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
136 s->aspect_ratio_info=i;
137 return;
138 }
139 }
140
141 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
142 }
143
144 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
145 {
146 int format;
147
148 align_put_bits(&s->pb);
149
150 /* Update the pointer to last GOB */
151 s->ptr_lastgob = pbBufPtr(&s->pb);
152 s->gob_number = 0;
153
154 put_bits(&s->pb, 22, 0x20); /* PSC */
155 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
156 s->frame_rate) & 0xff);
157
158 put_bits(&s->pb, 1, 1); /* marker */
159 put_bits(&s->pb, 1, 0); /* h263 id */
160 put_bits(&s->pb, 1, 0); /* split screen off */
161 put_bits(&s->pb, 1, 0); /* camera off */
162 put_bits(&s->pb, 1, 0); /* freeze picture release off */
163
164 format = h263_get_picture_format(s->width, s->height);
165 if (!s->h263_plus) {
166 /* H.263v1 */
167 put_bits(&s->pb, 3, format);
168 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
169 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
170 of H.263v1 UMV implies to check the predicted MV after
171 calculation of the current MB to see if we're on the limits */
172 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
173 put_bits(&s->pb, 1, 0); /* SAC: off */
174 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
175 put_bits(&s->pb, 1, 0); /* not PB frame */
176 put_bits(&s->pb, 5, s->qscale);
177 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
178 } else {
179 /* H.263v2 */
180 /* H.263 Plus PTYPE */
181 put_bits(&s->pb, 3, 7);
182 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
183 if (format == 7)
184 put_bits(&s->pb,3,6); /* Custom Source Format */
185 else
186 put_bits(&s->pb, 3, format);
187
188 put_bits(&s->pb,1,0); /* Custom PCF: off */
189 s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
190 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
191 put_bits(&s->pb,1,0); /* SAC: off */
192 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
193 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
194 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
195 put_bits(&s->pb,1,0); /* Slice Structured: off */
196 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
197 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
198 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
199 put_bits(&s->pb,1,0); /* Modified Quantization: off */
200 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
201 put_bits(&s->pb,3,0); /* Reserved */
202
203 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
204
205 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
206 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
207 if (s->pict_type == I_TYPE)
208 s->no_rounding = 0;
209 else
210 s->no_rounding ^= 1;
211 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
212 put_bits(&s->pb,2,0); /* Reserved */
213 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
214
215 /* This should be here if PLUSPTYPE */
216 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
217
218 if (format == 7) {
219 /* Custom Picture Format (CPFMT) */
220 float_aspect_to_info(s, s->avctx->aspect_ratio);
221
222 put_bits(&s->pb,4,s->aspect_ratio_info);
223 put_bits(&s->pb,9,(s->width >> 2) - 1);
224 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
225 put_bits(&s->pb,9,(s->height >> 2));
226 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
227 {
228 put_bits(&s->pb, 8, s->aspected_width);
229 put_bits(&s->pb, 8, s->aspected_height);
230 }
231 }
232
233 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
234 if (s->umvplus)
235 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
236 put_bits(&s->pb, 5, s->qscale);
237 }
238
239 put_bits(&s->pb, 1, 0); /* no PEI */
240
241 if(s->h263_aic){
242 s->y_dc_scale_table=
243 s->c_dc_scale_table= h263_aic_dc_scale_table;
244 }else{
245 s->y_dc_scale_table=
246 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
247 }
248 }
249
250 /**
251 * Encodes a group of blocks header.
252 */
253 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
254 {
255 align_put_bits(&s->pb);
256 flush_put_bits(&s->pb);
257 /* Call the RTP callback to send the last GOB */
258 if (s->rtp_callback) {
259 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
260 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
261 }
262 put_bits(&s->pb, 17, 1); /* GBSC */
263 s->gob_number = mb_line / s->gob_index;
264 put_bits(&s->pb, 5, s->gob_number); /* GN */
265 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
266 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
267 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
268 return 0;
269 }
270
271 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
272 {
273 int score0=0, score1=0;
274 int i, n;
275 int8_t * const qscale_table= s->current_picture.qscale_table;
276
277 for(n=0; n<6; n++){
278 INT16 *ac_val, *ac_val1;
279
280 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
281 ac_val1= ac_val;
282 if(dir[n]){
283 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
284 /* top prediction */
285 ac_val-= s->block_wrap[n]*16;
286 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
287 /* same qscale */
288 for(i=1; i<8; i++){
289 const int level= block[n][s->idct_permutation[i ]];
290 score0+= ABS(level);
291 score1+= ABS(level - ac_val[i+8]);
292 ac_val1[i ]= block[n][s->idct_permutation[i<<3]];
293 ac_val1[i+8]= level;
294 }
295 }else{
296 /* different qscale, we must rescale */
297 for(i=1; i<8; i++){
298 const int level= block[n][s->idct_permutation[i ]];
299 score0+= ABS(level);
300 score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale));
301 ac_val1[i ]= block[n][s->idct_permutation[i<<3]];
302 ac_val1[i+8]= level;
303 }
304 }
305 }else{
306 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
307 /* left prediction */
308 ac_val-= 16;
309 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
310 /* same qscale */
311 for(i=1; i<8; i++){
312 const int level= block[n][s->idct_permutation[i<<3]];
313 score0+= ABS(level);
314 score1+= ABS(level - ac_val[i]);
315 ac_val1[i ]= level;
316 ac_val1[i+8]= block[n][s->idct_permutation[i ]];
317 }
318 }else{
319 /* different qscale, we must rescale */
320 for(i=1; i<8; i++){
321 const int level= block[n][s->idct_permutation[i<<3]];
322 score0+= ABS(level);
323 score1+= ABS(level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale));
324 ac_val1[i ]= level;
325 ac_val1[i+8]= block[n][s->idct_permutation[i ]];
326 }
327 }
328 }
329 }
330
331 return score0 > score1 ? 1 : 0;
332 }
333
334 /**
335 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
336 */
337 void ff_clean_h263_qscales(MpegEncContext *s){
338 int i;
339 int8_t * const qscale_table= s->current_picture.qscale_table;
340
341 for(i=1; i<s->mb_num; i++){
342 if(qscale_table[i] - qscale_table[i-1] >2)
343 qscale_table[i]= qscale_table[i-1]+2;
344 }
345 for(i=s->mb_num-2; i>=0; i--){
346 if(qscale_table[i] - qscale_table[i+1] >2)
347 qscale_table[i]= qscale_table[i+1]+2;
348 }
349 }
350
351 /**
352 * modify mb_type & qscale so that encoding is acually possible in mpeg4
353 */
354 void ff_clean_mpeg4_qscales(MpegEncContext *s){
355 int i;
356 int8_t * const qscale_table= s->current_picture.qscale_table;
357
358 ff_clean_h263_qscales(s);
359
360 for(i=1; i<s->mb_num; i++){
361 if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_INTER4V)){
362 s->mb_type[i]&= ~MB_TYPE_INTER4V;
363 s->mb_type[i]|= MB_TYPE_INTER;
364 }
365 }
366
367 if(s->pict_type== B_TYPE){
368 int odd=0;
369 /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
370 for the actual adaptive quantization */
371
372 for(i=0; i<s->mb_num; i++){
373 odd += qscale_table[i]&1;
374 }
375
376 if(2*odd > s->mb_num) odd=1;
377 else odd=0;
378
379 for(i=0; i<s->mb_num; i++){
380 if((qscale_table[i]&1) != odd)
381 qscale_table[i]++;
382 if(qscale_table[i] > 31)
383 qscale_table[i]= 31;
384 }
385
386 for(i=1; i<s->mb_num; i++){
387 if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_DIRECT)){
388 s->mb_type[i]&= ~MB_TYPE_DIRECT;
389 s->mb_type[i]|= MB_TYPE_BIDIR;
390 }
391 }
392 }
393 }
394
395 #ifdef CONFIG_ENCODERS
396 void mpeg4_encode_mb(MpegEncContext * s,
397 DCTELEM block[6][64],
398 int motion_x, int motion_y)
399 {
400 int cbpc, cbpy, i, pred_x, pred_y;
401 int bits;
402 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
403 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
404 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
405 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
406 const int dquant_code[5]= {1,0,9,2,3};
407
408 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
409 if (!s->mb_intra) {
410 /* compute cbp */
411 int cbp = 0;
412 for (i = 0; i < 6; i++) {
413 if (s->block_last_index[i] >= 0)
414 cbp |= 1 << (5 - i);
415 }
416
417 if(s->pict_type==B_TYPE){
418 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
419 int mb_type= mb_type_table[s->mv_dir];
420
421 if(s->mb_x==0){
422 s->last_mv[0][0][0]=
423 s->last_mv[0][0][1]=
424 s->last_mv[1][0][0]=
425 s->last_mv[1][0][1]= 0;
426 }
427
428 assert(s->dquant>=-2 && s->dquant<=2);
429 assert((s->dquant&1)==0);
430 assert(mb_type>=0);
431
432 /* nothing to do if this MB was skiped in the next P Frame */
433 if(s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x]){ //FIXME avoid DCT & ...
434 s->skip_count++;
435 s->mv[0][0][0]=
436 s->mv[0][0][1]=
437 s->mv[1][0][0]=
438 s->mv[1][0][1]= 0;
439 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
440 s->qscale -= s->dquant;
441 // s->mb_skiped=1;
442
443 return;
444 }
445
446 if ((cbp | motion_x | motion_y | mb_type) ==0) {
447 /* direct MB with MV={0,0} */
448 assert(s->dquant==0);
449
450 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
451
452 if(interleaved_stats){
453 s->misc_bits++;
454 s->last_bits++;
455 }
456 s->skip_count++;
457 return;
458 }
459
460 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
461 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
462 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
463 if(cbp) put_bits(&s->pb, 6, cbp);
464
465 if(cbp && mb_type){
466 if(s->dquant)
467 put_bits(&s->pb, 2, (s->dquant>>2)+3);
468 else
469 put_bits(&s->pb, 1, 0);
470 }else
471 s->qscale -= s->dquant;
472
473 if(!s->progressive_sequence){
474 if(cbp)
475 put_bits(&s->pb, 1, s->interlaced_dct);
476 if(mb_type) // not diect mode
477 put_bits(&s->pb, 1, 0); // no interlaced ME yet
478 }
479
480 if(interleaved_stats){
481 bits= get_bit_count(&s->pb);
482 s->misc_bits+= bits - s->last_bits;
483 s->last_bits=bits;
484 }
485
486 switch(mb_type)
487 {
488 case 0: /* direct */
489 h263_encode_motion(s, motion_x, 1);
490 h263_encode_motion(s, motion_y, 1);
491 s->b_count++;
492 s->f_count++;
493 break;
494 case 1: /* bidir */
495 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
496 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
497 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
498 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
499 s->last_mv[0][0][0]= s->mv[0][0][0];
500 s->last_mv[0][0][1]= s->mv[0][0][1];
501 s->last_mv[1][0][0]= s->mv[1][0][0];
502 s->last_mv[1][0][1]= s->mv[1][0][1];
503 s->b_count++;
504 s->f_count++;
505 break;
506 case 2: /* backward */
507 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
508 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
509 s->last_mv[1][0][0]= motion_x;
510 s->last_mv[1][0][1]= motion_y;
511 s->b_count++;
512 break;
513 case 3: /* forward */
514 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
515 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
516 s->last_mv[0][0][0]= motion_x;
517 s->last_mv[0][0][1]= motion_y;
518 s->f_count++;
519 break;
520 default:
521 printf("unknown mb type\n");
522 return;
523 }
524
525 if(interleaved_stats){
526 bits= get_bit_count(&s->pb);
527 s->mv_bits+= bits - s->last_bits;
528 s->last_bits=bits;
529 }
530
531 /* encode each block */
532 for (i = 0; i < 6; i++) {
533 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
534 }
535
536 if(interleaved_stats){
537 bits= get_bit_count(&s->pb);
538 s->p_tex_bits+= bits - s->last_bits;
539 s->last_bits=bits;
540 }
541 }else{ /* s->pict_type==B_TYPE */
542 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
543 /* check if the B frames can skip it too, as we must skip it if we skip here
544 why didnt they just compress the skip-mb bits instead of reusing them ?! */
545 if(s->max_b_frames>0){
546 int i;
547 int x,y, offset;
548 uint8_t *p_pic;
549
550 x= s->mb_x*16;
551 y= s->mb_y*16;
552 if(x+16 > s->width) x= s->width-16;
553 if(y+16 > s->height) y= s->height-16;
554
555 offset= x + y*s->linesize;
556 p_pic= s->new_picture.data[0] + offset;
557
558 s->mb_skiped=1;
559 for(i=0; i<s->max_b_frames; i++){
560 uint8_t *b_pic;
561 int diff;
562 Picture *pic= s->reordered_input_picture[i+1];
563
564 if(pic==NULL || pic->pict_type!=B_TYPE) break;
565
566 b_pic= pic->data[0] + offset + 16; //FIXME +16
567 diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
568 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
569 s->mb_skiped=0;
570 break;
571 }
572 }
573 }else
574 s->mb_skiped=1;
575
576 if(s->mb_skiped==1){
577 /* skip macroblock */
578 put_bits(&s->pb, 1, 1);
579
580 if(interleaved_stats){
581 s->misc_bits++;
582 s->last_bits++;
583 }
584 s->skip_count++;
585 return;
586 }
587 }
588
589 put_bits(&s->pb, 1, 0); /* mb coded */
590 if(s->mv_type==MV_TYPE_16X16){
591 cbpc = cbp & 3;
592 if(s->dquant) cbpc+= 8;
593 put_bits(&s->pb,
594 inter_MCBPC_bits[cbpc],
595 inter_MCBPC_code[cbpc]);
596
597 cbpy = cbp >> 2;
598 cbpy ^= 0xf;
599 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
600 if(s->dquant)
601 put_bits(pb2, 2, dquant_code[s->dquant+2]);
602
603 if(!s->progressive_sequence){
604 if(cbp)
605 put_bits(pb2, 1, s->interlaced_dct);
606 put_bits(pb2, 1, 0); // no interlaced ME yet
607 }
608
609 if(interleaved_stats){
610 bits= get_bit_count(&s->pb);
611 s->misc_bits+= bits - s->last_bits;
612 s->last_bits=bits;
613 }
614
615 /* motion vectors: 16x16 mode */
616 h263_pred_motion(s, 0, &pred_x, &pred_y);
617
618 h263_encode_motion(s, motion_x - pred_x, s->f_code);
619 h263_encode_motion(s, motion_y - pred_y, s->f_code);
620 }else{
621 cbpc = (cbp & 3)+16;
622 put_bits(&s->pb,
623 inter_MCBPC_bits[cbpc],
624 inter_MCBPC_code[cbpc]);
625 cbpy = cbp >> 2;
626 cbpy ^= 0xf;
627 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
628
629 if(!s->progressive_sequence){
630 if(cbp)
631 put_bits(pb2, 1, s->interlaced_dct);
632 }
633
634 if(interleaved_stats){
635 bits= get_bit_count(&s->pb);
636 s->misc_bits+= bits - s->last_bits;
637 s->last_bits=bits;
638 }
639
640 for(i=0; i<4; i++){
641 /* motion vectors: 8x8 mode*/
642 h263_pred_motion(s, i, &pred_x, &pred_y);
643
644 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
645 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
646 }
647 }
648
649 if(interleaved_stats){
650 bits= get_bit_count(&s->pb);
651 s->mv_bits+= bits - s->last_bits;
652 s->last_bits=bits;
653 }
654
655 /* encode each block */
656 for (i = 0; i < 6; i++) {
657 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
658 }
659
660 if(interleaved_stats){
661 bits= get_bit_count(&s->pb);
662 s->p_tex_bits+= bits - s->last_bits;
663 s->last_bits=bits;
664 }
665 s->f_count++;
666 }
667 } else {
668 int cbp;
669 int dc_diff[6]; //dc values with the dc prediction subtracted
670 int dir[6]; //prediction direction
671 int zigzag_last_index[6];
672 UINT8 *scan_table[6];
673
674 for(i=0; i<6; i++){
675 const int level= block[i][0];
676 UINT16 *dc_ptr;
677
678 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
679 if (i < 4) {
680 *dc_ptr = level * s->y_dc_scale;
681 } else {
682 *dc_ptr = level * s->c_dc_scale;
683 }
684 }
685
686 s->ac_pred= decide_ac_pred(s, block, dir);
687
688 if(s->ac_pred){
689 for(i=0; i<6; i++){
690 UINT8 *st;
691 int last_index;
692
693 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
694 if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
695 else st = s->intra_h_scantable.permutated; /* top */
696
697 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
698 if(block[i][st[last_index]]) break;
699 zigzag_last_index[i]= s->block_last_index[i];
700 s->block_last_index[i]= last_index;
701 scan_table[i]= st;
702 }
703 }else{
704 for(i=0; i<6; i++)
705 scan_table[i]= s->intra_scantable.permutated;
706 }
707
708 /* compute cbp */
709 cbp = 0;
710 for (i = 0; i < 6; i++) {
711 if (s->block_last_index[i] >= 1)
712 cbp |= 1 << (5 - i);
713 }
714
715 cbpc = cbp & 3;
716 if (s->pict_type == I_TYPE) {
717 if(s->dquant) cbpc+=4;
718 put_bits(&s->pb,
719 intra_MCBPC_bits[cbpc],
720 intra_MCBPC_code[cbpc]);
721 } else {
722 if(s->dquant) cbpc+=8;
723 put_bits(&s->pb, 1, 0); /* mb coded */
724 put_bits(&s->pb,
725 inter_MCBPC_bits[cbpc + 4],
726 inter_MCBPC_code[cbpc + 4]);
727 }
728 put_bits(pb2, 1, s->ac_pred);
729 cbpy = cbp >> 2;
730 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
731 if(s->dquant)
732 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
733
734 if(!s->progressive_sequence){
735 put_bits(dc_pb, 1, s->interlaced_dct);
736 }
737
738 if(interleaved_stats){
739 bits= get_bit_count(&s->pb);
740 s->misc_bits+= bits - s->last_bits;
741 s->last_bits=bits;
742 }
743
744 /* encode each block */
745 for (i = 0; i < 6; i++) {
746 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
747 }
748
749 if(interleaved_stats){
750 bits= get_bit_count(&s->pb);
751 s->i_tex_bits+= bits - s->last_bits;
752 s->last_bits=bits;
753 }
754 s->i_count++;
755
756 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
757 if(s->ac_pred){
758 for(i=0; i<6; i++){
759 int j;
760 INT16 *ac_val;
761
762 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
763
764 if(dir[i]){
765 for(j=1; j<8; j++)
766 block[i][s->idct_permutation[j ]]= ac_val[j+8];
767 }else{
768 for(j=1; j<8; j++)
769 block[i][s->idct_permutation[j<<3]]= ac_val[j ];
770 }
771 s->block_last_index[i]= zigzag_last_index[i];
772 }
773 }
774 }
775 }
776
777 void h263_encode_mb(MpegEncContext * s,
778 DCTELEM block[6][64],
779 int motion_x, int motion_y)
780 {
781 int cbpc, cbpy, i, cbp, pred_x, pred_y;
782 INT16 pred_dc;
783 INT16 rec_intradc[6];
784 UINT16 *dc_ptr[6];
785 const int dquant_code[5]= {1,0,9,2,3};
786
787 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
788 if (!s->mb_intra) {
789 /* compute cbp */
790 cbp = 0;
791 for (i = 0; i < 6; i++) {
792 if (s->block_last_index[i] >= 0)
793 cbp |= 1 << (5 - i);
794 }
795 if ((cbp | motion_x | motion_y | s->dquant) == 0) {
796 /* skip macroblock */
797 put_bits(&s->pb, 1, 1);
798 return;
799 }
800 put_bits(&s->pb, 1, 0); /* mb coded */
801 cbpc = cbp & 3;
802 if(s->dquant) cbpc+= 8;
803 put_bits(&s->pb,
804 inter_MCBPC_bits[cbpc],
805 inter_MCBPC_code[cbpc]);
806 cbpy = cbp >> 2;
807 cbpy ^= 0xf;
808 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
809 if(s->dquant)
810 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
811
812 /* motion vectors: 16x16 mode only now */
813 h263_pred_motion(s, 0, &pred_x, &pred_y);
814
815 if (!s->umvplus) {
816 h263_encode_motion(s, motion_x - pred_x, s->f_code);
817 h263_encode_motion(s, motion_y - pred_y, s->f_code);
818 }
819 else {
820 h263p_encode_umotion(s, motion_x - pred_x);
821 h263p_encode_umotion(s, motion_y - pred_y);
822 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
823 /* To prevent Start Code emulation */
824 put_bits(&s->pb,1,1);
825 }
826 } else {
827 int li = s->h263_aic ? 0 : 1;
828
829 cbp = 0;
830 for(i=0; i<6; i++) {
831 /* Predict DC */
832 if (s->h263_aic && s->mb_intra) {
833 INT16 level = block[i][0];
834
835 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
836 level -= pred_dc;
837 /* Quant */
838 if (level < 0)
839 level = (level + (s->qscale >> 1))/(s->y_dc_scale);
840 else
841 level = (level - (s->qscale >> 1))/(s->y_dc_scale);
842
843 /* AIC can change CBP */
844 if (level == 0 && s->block_last_index[i] == 0)
845 s->block_last_index[i] = -1;
846 else if (level < -127)
847 level = -127;
848 else if (level > 127)
849 level = 127;
850
851 block[i][0] = level;
852 /* Reconstruction */
853 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
854 /* Oddify */
855 rec_intradc[i] |= 1;
856 //if ((rec_intradc[i] % 2) == 0)
857 // rec_intradc[i]++;
858 /* Clipping */
859 if (rec_intradc[i] < 0)
860 rec_intradc[i] = 0;
861 else if (rec_intradc[i] > 2047)
862 rec_intradc[i] = 2047;
863
864 /* Update AC/DC tables */
865 *dc_ptr[i] = rec_intradc[i];
866 }
867 /* compute cbp */
868 if (s->block_last_index[i] >= li)
869 cbp |= 1 << (5 - i);
870 }
871
872 cbpc = cbp & 3;
873 if (s->pict_type == I_TYPE) {
874 if(s->dquant) cbpc+=4;
875 put_bits(&s->pb,
876 intra_MCBPC_bits[cbpc],
877 intra_MCBPC_code[cbpc]);
878 } else {
879 if(s->dquant) cbpc+=8;
880 put_bits(&s->pb, 1, 0); /* mb coded */
881 put_bits(&s->pb,
882 inter_MCBPC_bits[cbpc + 4],
883 inter_MCBPC_code[cbpc + 4]);
884 }
885 if (s->h263_aic) {
886 /* XXX: currently, we do not try to use ac prediction */
887 put_bits(&s->pb, 1, 0); /* no AC prediction */
888 }
889 cbpy = cbp >> 2;
890 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
891 if(s->dquant)
892 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
893 }
894
895 for(i=0; i<6; i++) {
896 /* encode each block */
897 h263_encode_block(s, block[i], i);
898
899 /* Update INTRADC for decoding */
900 if (s->h263_aic && s->mb_intra) {
901 block[i][0] = rec_intradc[i];
902
903 }
904 }
905 }
906 #endif
907
908 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
909 {
910 int x, y, wrap, a, c, pred_dc, scale;
911 INT16 *dc_val, *ac_val;
912
913 /* find prediction */
914 if (n < 4) {
915 x = 2 * s->mb_x + 1 + (n & 1);
916 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
917 wrap = s->mb_width * 2 + 2;
918 dc_val = s->dc_val[0];
919 ac_val = s->ac_val[0][0];
920 scale = s->y_dc_scale;
921 } else {
922 x = s->mb_x + 1;
923 y = s->mb_y + 1;
924 wrap = s->mb_width + 2;
925 dc_val = s->dc_val[n - 4 + 1];
926 ac_val = s->ac_val[n - 4 + 1][0];
927 scale = s->c_dc_scale;
928 }
929 /* B C
930 * A X
931 */
932 a = dc_val[(x - 1) + (y) * wrap];
933 c = dc_val[(x) + (y - 1) * wrap];
934
935 /* No prediction outside GOB boundary */
936 if (s->first_slice_line && ((n < 2) || (n > 3)))
937 c = 1024;
938 pred_dc = 1024;
939 /* just DC prediction */
940 if (a != 1024 && c != 1024)
941 pred_dc = (a + c) >> 1;
942 else if (a != 1024)
943 pred_dc = a;
944 else
945 pred_dc = c;
946
947 /* we assume pred is positive */
948 //pred_dc = (pred_dc + (scale >> 1)) / scale;
949 *dc_val_ptr = &dc_val[x + y * wrap];
950 return pred_dc;
951 }
952
953
954 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
955 {
956 int x, y, wrap, a, c, pred_dc, scale, i;
957 INT16 *dc_val, *ac_val, *ac_val1;
958
959 /* find prediction */
960 if (n < 4) {
961 x = 2 * s->mb_x + 1 + (n & 1);
962 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
963 wrap = s->mb_width * 2 + 2;
964 dc_val = s->dc_val[0];
965 ac_val = s->ac_val[0][0];
966 scale = s->y_dc_scale;
967 } else {
968 x = s->mb_x + 1;
969 y = s->mb_y + 1;
970 wrap = s->mb_width + 2;
971 dc_val = s->dc_val[n - 4 + 1];
972 ac_val = s->ac_val[n - 4 + 1][0];
973 scale = s->c_dc_scale;
974 }
975
976 ac_val += ((y) * wrap + (x)) * 16;
977 ac_val1 = ac_val;
978
979 /* B C
980 * A X
981 */
982 a = dc_val[(x - 1) + (y) * wrap];
983 c = dc_val[(x) + (y - 1) * wrap];
984
985 /* No prediction outside GOB boundary */
986 if (s->first_slice_line && ((n < 2) || (n > 3)))
987 c = 1024;
988 pred_dc = 1024;
989 if (s->ac_pred) {
990 if (s->h263_aic_dir) {
991 /* left prediction */
992 if (a != 1024) {
993 ac_val -= 16;
994 for(i=1;i<8;i++) {
995 block[s->idct_permutation[i<<3]] += ac_val[i];
996 }
997 pred_dc = a;
998 }
999 } else {
1000 /* top prediction */
1001 if (c != 1024) {
1002 ac_val -= 16 * wrap;
1003 for(i=1;i<8;i++) {
1004 block[s->idct_permutation[i ]] += ac_val[i + 8];
1005 }
1006 pred_dc = c;
1007 }
1008 }
1009 } else {
1010 /* just DC prediction */
1011 if (a != 1024 && c != 1024)
1012 pred_dc = (a + c) >> 1;
1013 else if (a != 1024)
1014 pred_dc = a;
1015 else
1016 pred_dc = c;
1017 }
1018
1019 /* we assume pred is positive */
1020 block[0]=block[0]*scale + pred_dc;
1021
1022 if (block[0] < 0)
1023 block[0] = 0;
1024 else if (!(block[0] & 1))
1025 block[0]++;
1026
1027 /* Update AC/DC tables */
1028 dc_val[(x) + (y) * wrap] = block[0];
1029
1030 /* left copy */
1031 for(i=1;i<8;i++)
1032 ac_val1[i ] = block[s->idct_permutation[i<<3]];
1033 /* top copy */
1034 for(i=1;i<8;i++)
1035 ac_val1[8 + i] = block[s->idct_permutation[i ]];
1036 }
1037
1038 INT16 *h263_pred_motion(MpegEncContext * s, int block,
1039 int *px, int *py)
1040 {
1041 int xy, wrap;
1042 INT16 *A, *B, *C, *mot_val;
1043 static const int off[4]= {2, 1, 1, -1};
1044
1045 wrap = s->block_wrap[0];
1046 xy = s->block_index[block];
1047
1048 mot_val = s->motion_val[xy];
1049
1050 A = s->motion_val[xy - 1];
1051 /* special case for first (slice) line */
1052 if (s->first_slice_line && block<3) {
1053 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1054 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1055 if(block==0){ //most common case
1056 if(s->mb_x == s->resync_mb_x){ //rare
1057 *px= *py = 0;
1058 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1059 C = s->motion_val[xy + off[block] - wrap];
1060 if(s->mb_x==0){
1061 *px = C[0];
1062 *py = C[1];
1063 }else{
1064 *px = mid_pred(A[0], 0, C[0]);
1065 *py = mid_pred(A[1], 0, C[1]);
1066 }
1067 }else{
1068 *px = A[0];
1069 *py = A[1];
1070 }
1071 }else if(block==1){
1072 if(s->mb_x + 1 == s->resync_mb_x){ //rare
1073 C = s->motion_val[xy + off[block] - wrap];
1074 *px = mid_pred(A[0], 0, C[0]);
1075 *py = mid_pred(A[1], 0, C[1]);
1076 }else{
1077 *px = A[0];
1078 *py = A[1];
1079 }
1080 }else{ /* block==2*/
1081 B = s->motion_val[xy - wrap];
1082 C = s->motion_val[xy + off[block] - wrap];
1083 if(s->mb_x == s->resync_mb_x) //rare
1084 A[0]=A[1]=0;
1085
1086 *px = mid_pred(A[0], B[0], C[0]);
1087 *py = mid_pred(A[1], B[1], C[1]);
1088 }
1089 } else {
1090 B = s->motion_val[xy - wrap];
1091 C = s->motion_val[xy + off[block] - wrap];
1092 *px = mid_pred(A[0], B[0], C[0]);
1093 *py = mid_pred(A[1], B[1], C[1]);
1094 }
1095 return mot_val;
1096 }
1097
1098 #ifdef CONFIG_ENCODERS
1099 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1100 {
1101 int range, l, bit_size, sign, code, bits;
1102
1103 if (val == 0) {
1104 /* zero vector */
1105 code = 0;
1106 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1107 } else {
1108 bit_size = f_code - 1;
1109 range = 1 << bit_size;
1110 /* modulo encoding */
1111 l = range * 32;
1112 #if 1
1113 val+= l;
1114 val&= 2*l-1;
1115 val-= l;
1116 sign = val>>31;
1117 val= (val^sign)-sign;
1118 sign&=1;
1119 #else
1120 if (val < -l) {
1121 val += 2*l;
1122 } else if (val >= l) {
1123 val -= 2*l;
1124 }
1125
1126 assert(val>=-l && val<l);
1127
1128 if (val >= 0) {
1129 sign = 0;
1130 } else {
1131 val = -val;
1132 sign = 1;
1133 }
1134 #endif
1135 val--;
1136 code = (val >> bit_size) + 1;
1137 bits = val & (range - 1);
1138
1139 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1140 if (bit_size > 0) {
1141 put_bits(&s->pb, bit_size, bits);
1142 }
1143 }
1144
1145 }
1146
1147 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1148 static void h263p_encode_umotion(MpegEncContext * s, int val)
1149 {
1150 short sval = 0;
1151 short i = 0;
1152 short n_bits = 0;
1153 short temp_val;
1154 int code = 0;
1155 int tcode;
1156
1157 if ( val == 0)
1158 put_bits(&s->pb, 1, 1);
1159 else if (val == 1)
1160 put_bits(&s->pb, 3, 0);
1161 else if (val == -1)
1162 put_bits(&s->pb, 3, 2);
1163 else {
1164
1165 sval = ((val < 0) ? (short)(-val):(short)val);
1166 temp_val = sval;
1167
1168 while (temp_val != 0) {
1169 temp_val = temp_val >> 1;
1170 n_bits++;
1171 }
1172
1173 i = n_bits - 1;
1174 while (i > 0) {
1175 tcode = (sval & (1 << (i-1))) >> (i-1);
1176 tcode = (tcode << 1) | 1;
1177 code = (code << 2) | tcode;
1178 i--;
1179 }
1180 code = ((code << 1) | (val < 0)) << 1;
1181 put_bits(&s->pb, (2*n_bits)+1, code);
1182 //printf("\nVal = %d\tCode = %d", sval, code);
1183 }
1184 }
1185
1186 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1187 {
1188 int f_code;
1189 int mv;
1190
1191 if(mv_penalty==NULL)
1192 mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1193
1194 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1195 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1196 int len;
1197
1198 if(mv==0) len= mvtab[0][1];
1199 else{
1200 int val, bit_size, range, code;
1201
1202 bit_size = s->f_code - 1;
1203 range = 1 << bit_size;
1204
1205 val=mv;
1206 if (val < 0)
1207 val = -val;
1208 val--;
1209 code = (val >> bit_size) + 1;
1210 if(code<33){
1211 len= mvtab[code][1] + 1 + bit_size;
1212 }else{
1213 len= mvtab[32][1] + 2 + bit_size;
1214 }
1215 }
1216
1217 mv_penalty[f_code][mv+MAX_MV]= len;
1218 }
1219 }
1220
1221 for(f_code=MAX_FCODE; f_code>0; f_code--){
1222 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1223 fcode_tab[mv+MAX_MV]= f_code;
1224 }
1225 }
1226
1227 for(mv=0; mv<MAX_MV*2+1; mv++){
1228 umv_fcode_tab[mv]= 1;
1229 }
1230 }
1231 #endif
1232
1233 static void init_uni_dc_tab(void)
1234 {
1235 int level, uni_code, uni_len;
1236
1237 for(level=-256; level<256; level++){
1238 int size, v, l;
1239 /* find number of bits */
1240 size = 0;
1241 v = abs(level);
1242 while (v) {
1243 v >>= 1;
1244 size++;
1245 }
1246
1247 if (level < 0)
1248 l= (-level) ^ ((1 << size) - 1);
1249 else
1250 l= level;
1251
1252 /* luminance */
1253 uni_code= DCtab_lum[size][0];
1254 uni_len = DCtab_lum[size][1];
1255
1256 if (size > 0) {
1257 uni_code<<=size; uni_code|=l;
1258 uni_len+=size;
1259 if (size > 8){
1260 uni_code<<=1; uni_code|=1;
1261 uni_len++;
1262 }
1263 }
1264 uni_DCtab_lum[level+256][0]= uni_code;
1265 uni_DCtab_lum[level+256][1]= uni_len;
1266
1267 /* chrominance */
1268 uni_code= DCtab_chrom[size][0];
1269 uni_len = DCtab_chrom[size][1];
1270
1271 if (size > 0) {
1272 uni_code<<=size; uni_code|=l;
1273 uni_len+=size;
1274 if (size > 8){
1275 uni_code<<=1; uni_code|=1;
1276 uni_len++;
1277 }
1278 }
1279 uni_DCtab_chrom[level+256][0]= uni_code;
1280 uni_DCtab_chrom[level+256][1]= uni_len;
1281
1282 }
1283 }
1284
1285 #ifdef CONFIG_ENCODERS
1286 static void init_uni_mpeg4_rl_tab(RLTable *rl, UINT32 *bits_tab, UINT8 *len_tab){
1287 int slevel, run, last;
1288
1289 assert(MAX_LEVEL >= 64);
1290 assert(MAX_RUN >= 63);
1291
1292 for(slevel=-64; slevel<64; slevel++){
1293 if(slevel==0) continue;
1294 for(run=0; run<64; run++){
1295 for(last=0; last<=1; last++){
1296 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1297 int level= slevel < 0 ? -slevel : slevel;
1298 int sign= slevel < 0 ? 1 : 0;
1299 int bits, len, code;
1300 int level1, run1;
1301
1302 len_tab[index]= 100;
1303
1304 /* ESC0 */
1305 code= get_rl_index(rl, last, run, level);
1306 bits= rl->table_vlc[code][0];
1307 len= rl->table_vlc[code][1];
1308 bits=bits*2+sign; len++;
1309
1310 if(code!=rl->n && len < len_tab[index]){
1311 bits_tab[index]= bits;
1312 len_tab [index]= len;
1313 }
1314 #if 1
1315 /* ESC1 */
1316 bits= rl->table_vlc[rl->n][0];
1317 len= rl->table_vlc[rl->n][1];
1318 bits=bits*2; len++; //esc1
1319 level1= level - rl->max_level[last][run];
1320 if(level1>0){
1321 code= get_rl_index(rl, last, run, level1);
1322 bits<<= rl->table_vlc[code][1];
1323 len += rl->table_vlc[code][1];
1324 bits += rl->table_vlc[code][0];
1325 bits=bits*2+sign; len++;
1326
1327 if(code!=rl->n && len < len_tab[index]){
1328 bits_tab[index]= bits;
1329 len_tab [index]= len;
1330 }
1331 }
1332 #endif
1333 #if 1
1334 /* ESC2 */
1335 bits= rl->table_vlc[rl->n][0];
1336 len= rl->table_vlc[rl->n][1];
1337 bits=bits*4+2; len+=2; //esc2
1338 run1 = run - rl->max_run[last][level] - 1;
1339 if(run1>=0){
1340 code= get_rl_index(rl, last, run1, level);
1341 bits<<= rl->table_vlc[code][1];
1342 len += rl->table_vlc[code][1];
1343 bits += rl->table_vlc[code][0];
1344 bits=bits*2+sign; len++;
1345
1346 if(code!=rl->n && len < len_tab[index]){
1347 bits_tab[index]= bits;
1348 len_tab [index]= len;
1349 }
1350 }
1351 #endif
1352 /* ESC3 */
1353 bits= rl->table_vlc[rl->n][0];
1354 len = rl->table_vlc[rl->n][1];
1355 bits=bits*4+3; len+=2; //esc3
1356 bits=bits*2+last; len++;
1357 bits=bits*64+run; len+=6;
1358 bits=bits*2+1; len++; //marker
1359 bits=bits*4096+(slevel&0xfff); len+=12;
1360 bits=bits*2+1; len++; //marker
1361
1362 if(len < len_tab[index]){
1363 bits_tab[index]= bits;
1364 len_tab [index]= len;
1365 }
1366 }
1367 }
1368 }
1369 }
1370
1371 void h263_encode_init(MpegEncContext *s)
1372 {
1373 static int done = 0;
1374
1375 if (!done) {
1376 done = 1;
1377
1378 init_uni_dc_tab();
1379
1380 init_rl(&rl_inter);
1381 init_rl(&rl_intra);
1382 init_rl(&rl_intra_aic);
1383
1384 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1385 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1386
1387 init_mv_penalty_and_fcode(s);
1388 }
1389 s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1390
1391 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1392 switch(s->codec_id){
1393 case CODEC_ID_MPEG4:
1394 s->fcode_tab= fcode_tab;
1395 s->min_qcoeff= -2048;
1396 s->max_qcoeff= 2047;
1397 break;
1398 case CODEC_ID_H263P:
1399 s->fcode_tab= umv_fcode_tab;
1400 s->min_qcoeff= -128;
1401 s->max_qcoeff= 127;
1402 break;
1403 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1404 default: //nothing needed default table allready set in mpegvideo.c
1405 s->min_qcoeff= -128;
1406 s->max_qcoeff= 127;
1407 s->y_dc_scale_table=
1408 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1409 }
1410
1411 if(s->mpeg_quant){
1412 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1413 s->inter_quant_bias= 0;
1414 }else{
1415 s->intra_quant_bias=0;
1416 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1417 }
1418 }
1419
1420 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1421 {
1422 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1423 RLTable *rl;
1424
1425 rl = &rl_inter;
1426 if (s->mb_intra && !s->h263_aic) {
1427 /* DC coef */
1428 level = block[0];
1429 /* 255 cannot be represented, so we clamp */
1430 if (level > 254) {
1431 level = 254;
1432 block[0] = 254;
1433 }
1434 /* 0 cannot be represented also */
1435 else if (!level) {
1436 level = 1;
1437 block[0] = 1;
1438 }
1439 if (level == 128)
1440 put_bits(&s->pb, 8, 0xff);
1441 else
1442 put_bits(&s->pb, 8, level & 0xff);
1443 i = 1;
1444 } else {
1445 i = 0;
1446 if (s->h263_aic && s->mb_intra)
1447 rl = &rl_intra_aic;
1448 }
1449
1450 /* AC coefs */
1451 last_index = s->block_last_index[n];
1452 last_non_zero = i - 1;
1453 for (; i <= last_index; i++) {
1454 j = s->intra_scantable.permutated[i];
1455 level = block[j];
1456 if (level) {
1457 run = i - last_non_zero - 1;
1458 last = (i == last_index);
1459 sign = 0;
1460 slevel = level;
1461 if (level < 0) {
1462 sign = 1;
1463 level = -level;
1464 }
1465 code = get_rl_index(rl, last, run, level);
1466 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1467 if (code == rl->n) {
1468 put_bits(&s->pb, 1, last);
1469 put_bits(&s->pb, 6, run);
1470 put_bits(&s->pb, 8, slevel & 0xff);
1471 } else {
1472 put_bits(&s->pb, 1, sign);
1473 }
1474 last_non_zero = i;
1475 }
1476 }
1477 }
1478 #endif
1479
1480 /***************************************************/
1481 /**
1482 * add mpeg4 stuffing bits (01...1)
1483 */
1484 void ff_mpeg4_stuffing(PutBitContext * pbc)
1485 {
1486 int length;
1487 put_bits(pbc, 1, 0);
1488 length= (-get_bit_count(pbc))&7;
1489 if(length) put_bits(pbc, length, (1<<length)-1);
1490 }
1491
1492 /* must be called before writing the header */
1493 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1494 int time_div, time_mod;
1495
1496 if(s->pict_type==I_TYPE){ //we will encode a vol header
1497 s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1498 if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1499
1500 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1501 }
1502
1503 if(s->current_picture.pts)
1504 s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1505 else
1506 s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1507 time_div= s->time/s->time_increment_resolution;
1508 time_mod= s->time%s->time_increment_resolution;
1509
1510 if(s->pict_type==B_TYPE){
1511 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1512 }else{
1513 s->last_time_base= s->time_base;
1514 s->time_base= time_div;
1515 s->pp_time= s->time - s->last_non_b_time;
1516 s->last_non_b_time= s->time;
1517 }
1518 }
1519
1520 static void mpeg4_encode_vol_header(MpegEncContext * s)
1521 {
1522 int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1523 char buf[255];
1524
1525 if(s->max_b_frames){
1526 s->vo_type= ADV_SIMPLE_VO_TYPE;
1527 }else{
1528 s->vo_type= SIMPLE_VO_TYPE;
1529 }
1530
1531 put_bits(&s->pb, 16, 0);
1532 put_bits(&s->pb, 16, 0x100); /* video obj */
1533 put_bits(&s->pb, 16, 0);
1534 put_bits(&s->pb, 16, 0x120); /* video obj layer */
1535
1536 put_bits(&s->pb, 1, 0); /* random access vol */
1537 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
1538 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
1539 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
1540 put_bits(&s->pb, 3, 1); /* is obj layer priority */
1541
1542 float_aspect_to_info(s, s->avctx->aspect_ratio);
1543
1544 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1545 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1546 {
1547 put_bits(&s->pb, 8, s->aspected_width);
1548 put_bits(&s->pb, 8, s->aspected_height);
1549 }
1550
1551 if(s->low_delay){
1552 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
1553 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
1554 put_bits(&s->pb, 1, s->low_delay);
1555 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
1556 }else{
1557 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
1558 }
1559
1560 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
1561 put_bits(&s->pb, 1, 1); /* marker bit */
1562
1563 put_bits(&s->pb, 16, s->time_increment_resolution);
1564 if (s->time_increment_bits < 1)
1565 s->time_increment_bits = 1;
1566 put_bits(&s->pb, 1, 1); /* marker bit */
1567 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
1568 put_bits(&s->pb, 1, 1); /* marker bit */
1569 put_bits(&s->pb, 13, s->width); /* vol width */
1570 put_bits(&s->pb, 1, 1); /* marker bit */
1571 put_bits(&s->pb, 13, s->height); /* vol height */
1572 put_bits(&s->pb, 1, 1); /* marker bit */
1573 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1574 put_bits(&s->pb, 1, 1); /* obmc disable */
1575 if (vo_ver_id == 1) {
1576 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
1577 }else{ /* vo_ver_id == 2 */
1578 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
1579 }
1580
1581 s->quant_precision=5;
1582 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
1583 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
1584 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1585
1586 if (vo_ver_id != 1)
1587 put_bits(&s->pb, 1, s->quarter_sample=0);
1588 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
1589 s->resync_marker= s->rtp_mode;
1590 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1591 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1592 if(s->data_partitioning){
1593 put_bits(&s->pb, 1, 0); /* no rvlc */
1594 }
1595
1596 if (vo_ver_id != 1){
1597 put_bits(&s->pb, 1, 0); /* newpred */
1598 put_bits(&s->pb, 1, 0); /* reduced res vop */
1599 }
1600 put_bits(&s->pb, 1, 0); /* scalability */
1601
1602 ff_mpeg4_stuffing(&s->pb);
1603
1604 /* user data */
1605 if(!ff_bit_exact){
1606 put_bits(&s->pb, 16, 0);
1607 put_bits(&s->pb, 16, 0x1B2); /* user_data */
1608 sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1609 put_string(&s->pb, buf);
1610 ff_mpeg4_stuffing(&s->pb);
1611 }
1612 }
1613
1614 /* write mpeg4 VOP header */
1615 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1616 {
1617 int time_incr;
1618 int time_div, time_mod;
1619
1620 if(s->pict_type==I_TYPE){
1621 s->no_rounding=0;
1622 if(picture_number==0 || !s->strict_std_compliance)
1623 mpeg4_encode_vol_header(s);
1624 }
1625
1626 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1627
1628 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1629
1630 put_bits(&s->pb, 16, 0); /* vop header */
1631 put_bits(&s->pb, 16, 0x1B6); /* vop header */
1632 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
1633
1634 time_div= s->time/s->time_increment_resolution;
1635 time_mod= s->time%s->time_increment_resolution;
1636 time_incr= time_div - s->last_time_base;
1637 while(time_incr--)
1638 put_bits(&s->pb, 1, 1);
1639
1640 put_bits(&s->pb, 1, 0);
1641
1642 put_bits(&s->pb, 1, 1); /* marker */
1643 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
1644 put_bits(&s->pb, 1, 1); /* marker */
1645 put_bits(&s->pb, 1, 1); /* vop coded */
1646 if ( s->pict_type == P_TYPE
1647 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1648 s->no_rounding ^= 1;
1649 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
1650 }
1651 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
1652 if(!s->progressive_sequence){
1653 put_bits(&s->pb, 1, s->top_field_first);
1654 put_bits(&s->pb, 1, s->alternate_scan);
1655 }
1656 //FIXME sprite stuff
1657
1658 put_bits(&s->pb, 5, s->qscale);
1659
1660 if (s->pict_type != I_TYPE)
1661 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
1662 if (s->pict_type == B_TYPE)
1663 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
1664 // printf("****frame %d\n", picture_number);
1665
1666 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
1667 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1668 s->h_edge_pos= s->width;
1669 s->v_edge_pos= s->height;
1670 }
1671
1672 /**
1673 * change qscale by given dquant and update qscale dependant variables.
1674 */
1675 static void change_qscale(MpegEncContext * s, int dquant)
1676 {
1677 s->qscale += dquant;
1678
1679 if (s->qscale < 1)
1680 s->qscale = 1;
1681 else if (s->qscale > 31)
1682 s->qscale = 31;
1683
1684 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1685 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1686 }
1687
1688 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1689 {
1690 int a, b, c, wrap, pred, scale;
1691 UINT16 *dc_val;
1692 int dummy;
1693
1694 /* find prediction */
1695 if (n < 4) {
1696 scale = s->y_dc_scale;
1697 } else {
1698 scale = s->c_dc_scale;
1699 }
1700 wrap= s->block_wrap[n];
1701 dc_val = s->dc_val[0] + s->block_index[n];
1702
1703 /* B C
1704 * A X
1705 */
1706 a = dc_val[ - 1];
1707 b = dc_val[ - 1 - wrap];
1708 c = dc_val[ - wrap];
1709
1710 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1711 if(s->first_slice_line && n!=3){
1712 if(n!=2) b=c= 1024;
1713 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1714 }
1715 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1716 if(n==0 || n==4 || n==5)
1717 b=1024;
1718 }
1719
1720 if (abs(a - b) < abs(b - c)) {
1721 pred = c;
1722 *dir_ptr = 1; /* top */
1723 } else {
1724 pred = a;
1725 *dir_ptr = 0; /* left */
1726 }
1727 /* we assume pred is positive */
1728 #ifdef ARCH_X86
1729 asm volatile (
1730 "xorl %%edx, %%edx \n\t"
1731 "mul %%ecx \n\t"
1732 : "=d" (pred), "=a"(dummy)
1733 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1734 );
1735 #else
1736 pred = (pred + (scale >> 1)) / scale;
1737 #endif
1738
1739 /* prepare address for prediction update */
1740 *dc_val_ptr = &dc_val[0];
1741
1742 return pred;
1743 }
1744
1745 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1746 int dir)
1747 {
1748 int i;
1749 INT16 *ac_val, *ac_val1;
1750 int8_t * const qscale_table= s->current_picture.qscale_table;
1751
1752 /* find prediction */
1753 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1754 ac_val1 = ac_val;
1755 if (s->ac_pred) {
1756 if (dir == 0) {
1757 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1758 /* left prediction */
1759 ac_val -= 16;
1760
1761 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1762 /* same qscale */
1763 for(i=1;i<8;i++) {
1764 block[s->idct_permutation[i<<3]] += ac_val[i];
1765 }
1766 }else{
1767 /* different qscale, we must rescale */
1768 for(i=1;i<8;i++) {
1769 block[s->idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1770 }
1771 }
1772 } else {
1773 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1774 /* top prediction */
1775 ac_val -= 16 * s->block_wrap[n];
1776
1777 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1778 /* same qscale */
1779 for(i=1;i<8;i++) {
1780 block[s->idct_permutation[i]] += ac_val[i + 8];
1781 }
1782 }else{
1783 /* different qscale, we must rescale */
1784 for(i=1;i<8;i++) {
1785 block[s->idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1786 }
1787 }
1788 }
1789 }
1790 /* left copy */
1791 for(i=1;i<8;i++)
1792 ac_val1[i ] = block[s->idct_permutation[i<<3]];
1793
1794 /* top copy */
1795 for(i=1;i<8;i++)
1796 ac_val1[8 + i] = block[s->idct_permutation[i ]];
1797
1798 }
1799
1800 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1801 int dir)
1802 {
1803 int i;
1804 INT16 *ac_val;
1805 int8_t * const qscale_table= s->current_picture.qscale_table;
1806
1807 /* find prediction */
1808 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1809
1810 if (dir == 0) {
1811 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1812 /* left prediction */
1813 ac_val -= 16;
1814 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1815 /* same qscale */
1816 for(i=1;i<8;i++) {
1817 block[s->idct_permutation[i<<3]] -= ac_val[i];
1818 }
1819 }else{
1820 /* different qscale, we must rescale */
1821 for(i=1;i<8;i++) {
1822 block[s->idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1823 }
1824 }
1825 } else {
1826 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1827 /* top prediction */
1828 ac_val -= 16 * s->block_wrap[n];
1829 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1830 /* same qscale */
1831 for(i=1;i<8;i++) {
1832 block[s->idct_permutation[i]] -= ac_val[i + 8];
1833 }
1834 }else{
1835 /* different qscale, we must rescale */
1836 for(i=1;i<8;i++) {
1837 block[s->idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1838 }
1839 }
1840 }
1841 }
1842
1843 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1844 {
1845 #if 1
1846 // if(level<-255 || level>255) printf("dc overflow\n");
1847 level+=256;
1848 if (n < 4) {
1849 /* luminance */
1850 put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1851 } else {
1852 /* chrominance */
1853 put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1854 }
1855 #else
1856 int size, v;
1857 /* find number of bits */
1858 size = 0;
1859 v = abs(level);
1860 while (v) {
1861 v >>= 1;
1862 size++;
1863 }
1864
1865 if (n < 4) {
1866 /* luminance */
1867 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1868 } else {
1869 /* chrominance */
1870 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1871 }
1872
1873 /* encode remaining bits */
1874 if (size > 0) {
1875 if (level < 0)
1876 level = (-level) ^ ((1 << size) - 1);
1877 put_bits(&s->pb, size, level);
1878 if (size > 8)
1879 put_bits(&s->pb, 1, 1);
1880 }
1881 #endif
1882 }
1883 #ifdef CONFIG_ENCODERS
1884 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
1885 UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
1886 {
1887 int i, last_non_zero;
1888 #if 0 //variables for the outcommented version
1889 int code, sign, last;
1890 #endif
1891 const RLTable *rl;
1892 UINT32 *bits_tab;
1893 UINT8 *len_tab;
1894 const int last_index = s->block_last_index[n];
1895
1896 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
1897 /* mpeg4 based DC predictor */
1898 mpeg4_encode_dc(dc_pb, intra_dc, n);
1899 if(last_index<1) return;
1900 i = 1;
1901 rl = &rl_intra;
1902 bits_tab= uni_mpeg4_intra_rl_bits;
1903 len_tab = uni_mpeg4_intra_rl_len;
1904 } else {
1905 if(last_index<0) return;
1906 i = 0;
1907 rl = &rl_inter;
1908 bits_tab= uni_mpeg4_inter_rl_bits;
1909 len_tab = uni_mpeg4_inter_rl_len;
1910 }
1911
1912 /* AC coefs */
1913 last_non_zero = i - 1;
1914 #if 1
1915 for (; i < last_index; i++) {
1916 int level = block[ scan_table[i] ];
1917 if (level) {
1918 int run = i - last_non_zero - 1;
1919 level+=64;
1920 if((level&(~127)) == 0){
1921 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
1922 put_bits(ac_pb, len_tab[index], bits_tab[index]);
1923 }else{ //ESC3
1924 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);
1925 }
1926 last_non_zero = i;
1927 }
1928 }
1929 /*if(i<=last_index)*/{
1930 int level = block[ scan_table[i] ];
1931 int run = i - last_non_zero - 1;
1932 level+=64;
1933 if((level&(~127)) == 0){
1934 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
1935 put_bits(ac_pb, len_tab[index], bits_tab[index]);
1936 }else{ //ESC3
1937 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);
1938 }
1939 }
1940 #else
1941 for (; i <= last_index; i++) {
1942 const int slevel = block[ scan_table[i] ];
1943 if (slevel) {
1944 int level;
1945 int run = i - last_non_zero - 1;
1946 last = (i == last_index);
1947 sign = 0;
1948 level = slevel;
1949 if (level < 0) {
1950 sign = 1;
1951 level = -level;
1952 }
1953 code = get_rl_index(rl, last, run, level);
1954 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1955 if (code == rl->n) {
1956 int level1, run1;
1957 level1 = level - rl->max_level[last][run];
1958 if (level1 < 1)
1959 goto esc2;
1960 code = get_rl_index(rl, last, run, level1);
1961 if (code == rl->n) {
1962 esc2:
1963 put_bits(ac_pb, 1, 1);
1964 if (level > MAX_LEVEL)
1965 goto esc3;
1966 run1 = run - rl->max_run[last][level] - 1;
1967 if (run1 < 0)
1968 goto esc3;
1969 code = get_rl_index(rl, last, run1, level);
1970 if (code == rl->n) {
1971 esc3:
1972 /* third escape */
1973 put_bits(ac_pb, 1, 1);
1974 put_bits(ac_pb, 1, last);
1975 put_bits(ac_pb, 6, run);
1976 put_bits(ac_pb, 1, 1);
1977 put_bits(ac_pb, 12, slevel & 0xfff);
1978 put_bits(ac_pb, 1, 1);
1979 } else {
1980 /* second escape */
1981 put_bits(ac_pb, 1, 0);
1982 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1983 put_bits(ac_pb, 1, sign);
1984 }
1985 } else {
1986 /* first escape */
1987 put_bits(ac_pb, 1, 0);
1988 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1989 put_bits(ac_pb, 1, sign);
1990 }
1991 } else {
1992 put_bits(ac_pb, 1, sign);
1993 }
1994 last_non_zero = i;
1995 }
1996 }
1997 #endif
1998 }
1999 #endif
2000
2001
2002 /***********************************************/
2003 /* decoding */
2004
2005 static VLC intra_MCBPC_vlc;
2006 static VLC inter_MCBPC_vlc;
2007 static VLC cbpy_vlc;
2008 static VLC mv_vlc;
2009 static VLC dc_lum, dc_chrom;
2010 static VLC sprite_trajectory;
2011 static VLC mb_type_b_vlc;
2012
2013 void init_rl(RLTable *rl)
2014 {
2015 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
2016 UINT8 index_run[MAX_RUN+1];
2017 int last, run, level, start, end, i;
2018
2019 /* compute max_level[], max_run[] and index_run[] */
2020 for(last=0;last<2;last++) {
2021 if (last == 0) {
2022 start = 0;
2023 end = rl->last;
2024 } else {
2025 start = rl->last;
2026 end = rl->n;
2027 }
2028
2029 memset(max_level, 0, MAX_RUN + 1);
2030 memset(max_run, 0, MAX_LEVEL + 1);
2031 memset(index_run, rl->n, MAX_RUN + 1);
2032 for(i=start;i<end;i++) {
2033 run = rl->table_run[i];
2034 level = rl->table_level[i];
2035 if (index_run[run] == rl->n)
2036 index_run[run] = i;
2037 if (level > max_level[run])
2038 max_level[run] = level;
2039 if (run > max_run[level])
2040 max_run[level] = run;
2041 }
2042 rl->max_level[last] = av_malloc(MAX_RUN + 1);
2043 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
2044 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
2045 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
2046 rl->index_run[last] = av_malloc(MAX_RUN + 1);
2047 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
2048 }
2049 }
2050
2051 void init_vlc_rl(RLTable *rl)
2052 {
2053 int i, q;
2054
2055 init_vlc(&rl->vlc, 9, rl->n + 1,
2056 &rl->table_vlc[0][1], 4, 2,
2057 &rl->table_vlc[0][0], 4, 2);
2058
2059
2060 for(q=0; q<32; q++){
2061 int qmul= q*2;
2062 int qadd= (q-1)|1;
2063
2064 if(q==0){
2065 qmul=1;
2066 qadd=0;
2067 }
2068
2069 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2070 for(i=0; i<rl->vlc.table_size; i++){
2071 int code= rl->vlc.table[i][0];
2072 int len = rl->vlc.table[i][1];
2073 int level, run;
2074
2075 if(len==0){ // illegal code
2076 run= 66;
2077 level= MAX_LEVEL;
2078 }else if(len<0){ //more bits needed
2079 run= 0;
2080 level= code;
2081 }else{
2082 if(code==rl->n){ //esc
2083 run= 66;
2084 level= 0;
2085 }else{
2086 run= rl->table_run [code] + 1;
2087 level= rl->table_level[code] * qmul + qadd;
2088 if(code >= rl->last) run+=192;
2089 }
2090 }
2091 rl->rl_vlc[q][i].len= len;
2092 rl->rl_vlc[q][i].level= level;
2093 rl->rl_vlc[q][i].run= run;
2094 }
2095 }
2096 }
2097
2098 /* init vlcs */
2099
2100 /* XXX: find a better solution to handle static init */
2101 void h263_decode_init_vlc(MpegEncContext *s)
2102 {
2103 static int done = 0;
2104
2105 if (!done) {
2106 done = 1;
2107
2108 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
2109 intra_MCBPC_bits, 1, 1,
2110 intra_MCBPC_code, 1, 1);
2111 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
2112 inter_MCBPC_bits, 1, 1,
2113 inter_MCBPC_code, 1, 1);
2114 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2115 &cbpy_tab[0][1], 2, 1,
2116 &cbpy_tab[0][0], 2, 1);
2117 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2118 &mvtab[0][1], 2, 1,
2119 &mvtab[0][0], 2, 1);
2120 init_rl(&rl_inter);
2121 init_rl(&rl_intra);
2122 init_rl(&rl_intra_aic);
2123 init_vlc_rl(&rl_inter);
2124 init_vlc_rl(&rl_intra);
2125 init_vlc_rl(&rl_intra_aic);
2126 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2127 &DCtab_lum[0][1], 2, 1,
2128 &DCtab_lum[0][0], 2, 1);
2129 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2130 &DCtab_chrom[0][1], 2, 1,
2131 &DCtab_chrom[0][0], 2, 1);
2132 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2133 &sprite_trajectory_tab[0][1], 4, 2,
2134 &sprite_trajectory_tab[0][0], 4, 2);
2135 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2136 &mb_type_b_tab[0][1], 2, 1,
2137 &mb_type_b_tab[0][0], 2, 1);
2138 }
2139 }
2140
2141 /**
2142 * Get the GOB height based on picture height.
2143 */
2144 int ff_h263_get_gob_height(MpegEncContext *s){
2145 if (s->height <= 400)
2146 return 1;
2147 else if (s->height <= 800)
2148 return 2;
2149 else
2150 return 4;
2151 }
2152
2153 /**
2154 * decodes the group of blocks header.
2155 * @return <0 if an error occured
2156 */
2157 static int h263_decode_gob_header(MpegEncContext *s)
2158 {
2159 unsigned int val, gfid;
2160 int left;
2161
2162 /* Check for GOB Start Code */
2163 val = show_bits(&s->gb, 16);
2164 if(val)
2165 return -1;
2166
2167 /* We have a GBSC probably with GSTUFF */
2168 skip_bits(&s->gb, 16); /* Drop the zeros */
2169 left= s->gb.size*8 - get_bits_count(&s->gb);
2170 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2171 for(;left>13; left--){
2172 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2173 }
2174 if(left<=13)
2175 return -1;
2176
2177 #ifdef DEBUG
2178 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2179 #endif
2180 s->gob_number = get_bits(&s->gb, 5); /* GN */
2181 gfid = get_bits(&s->gb, 2); /* GFID */
2182 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2183 if(s->qscale==0)
2184 return -1;
2185 s->mb_x= 0;
2186 s->mb_y= s->gob_index* s->gob_number;
2187 #ifdef DEBUG
2188 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2189 #endif
2190 return 0;
2191 }
2192
2193 static inline void memsetw(short *tab, int val, int n)
2194 {
2195 int i;
2196 for(i=0;i<n;i++)
2197 tab[i] = val;
2198 }
2199
2200 void ff_mpeg4_init_partitions(MpegEncContext *s)
2201 {
2202 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2203 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
2204 }
2205
2206 void ff_mpeg4_merge_partitions(MpegEncContext *s)
2207 {
2208 const int pb2_len = get_bit_count(&s->pb2 );
2209 const int tex_pb_len= get_bit_count(&s->tex_pb);
2210 const int bits= get_bit_count(&s->pb);
2211
2212 if(s->pict_type==I_TYPE){
2213 put_bits(&s->pb, 19, DC_MARKER);
2214 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2215 s->i_tex_bits+= tex_pb_len;
2216 }else{
2217 put_bits(&s->pb, 17, MOTION_MARKER);
2218 s->misc_bits+=17 + pb2_len;
2219 s->mv_bits+= bits - s->last_bits;
2220 s->p_tex_bits+= tex_pb_len;
2221 }
2222
2223 flush_put_bits(&s->pb2);
2224 flush_put_bits(&s->tex_pb);
2225
2226 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
2227 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2228 s->last_bits= get_bit_count(&s->pb);
2229 }
2230
2231 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2232 switch(s->pict_type){
2233 case I_TYPE:
2234 return 16;
2235 case P_TYPE:
2236 case S_TYPE:
2237 return s->f_code+15;
2238 case B_TYPE:
2239 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2240 default:
2241 return -1;
2242 }
2243 }
2244
2245 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2246 {
2247 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2248
2249 ff_mpeg4_stuffing(&s->pb);
2250 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2251 put_bits(&s->pb, 1, 1);
2252
2253 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2254 put_bits(&s->pb, s->quant_precision, s->qscale);
2255 put_bits(&s->pb, 1, 0); /* no HEC */
2256 }
2257
2258 /**
2259 * check if the next stuff is a resync marker or the end.
2260 * @return 0 if not
2261 */
2262 static inline int mpeg4_is_resync(MpegEncContext *s){
2263 const int bits_count= get_bits_count(&s->gb);
2264
2265 if(s->workaround_bugs&FF_BUG_NO_PADDING){
2266 return 0;
2267 }
2268
2269 if(bits_count + 8 >= s->gb.size*8){
2270 int v= show_bits(&s->gb, 8);
2271 v|= 0x7F >> (7-(bits_count&7));
2272
2273 if(v==0x7F)
2274 return 1;
2275 }else{
2276 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2277 int len;
2278 GetBitContext gb= s->gb;
2279
2280 skip_bits(&s->gb, 1);
2281 align_get_bits(&s->gb);
2282
2283 for(len=0; len<32; len++){
2284 if(get_bits1(&s->gb)) break;
2285 }
2286
2287 s->gb= gb;
2288
2289 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2290 return 1;
2291 }
2292 }
2293 return 0;
2294 }
2295
2296 /**
2297 * decodes the next video packet.
2298 * @return <0 if something went wrong
2299 */
2300 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2301 {
2302 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2303 int header_extension=0, mb_num, len;
2304
2305 /* is there enough space left for a video packet + header */
2306 if( get_bits_count(&s->gb) > s->gb.size*8-20) return -1;
2307
2308 for(len=0; len<32; len++){
2309 if(get_bits1(&s->gb)) break;
2310 }
2311
2312 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2313 printf("marker does not match f_code\n");
2314 return -1;
2315 }
2316
2317 if(s->shape != RECT_SHAPE){
2318 header_extension= get_bits1(&s->gb);
2319 //FIXME more stuff here
2320 }
2321
2322 mb_num= get_bits(&s->gb, mb_num_bits);
2323 if(mb_num>=s->mb_num){
2324 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2325 return -1;
2326 }
2327 s->mb_x= mb_num % s->mb_width;
2328 s->mb_y= mb_num / s->mb_width;
2329
2330 if(s->shape != BIN_ONLY_SHAPE){
2331 int qscale= get_bits(&s->gb, s->quant_precision);
2332 if(qscale)
2333 s->qscale= qscale;
2334 }
2335
2336 if(s->shape == RECT_SHAPE){
2337 header_extension= get_bits1(&s->gb);
2338 }
2339 if(header_extension){
2340 int time_increment;
2341 int time_incr=0;
2342
2343 while (get_bits1(&s->gb) != 0)
2344 time_incr++;
2345
2346 check_marker(&s->gb, "before time_increment in video packed header");
2347 time_increment= get_bits(&s->gb, s->time_increment_bits);
2348 check_marker(&s->gb, "before vop_coding_type in video packed header");
2349
2350 skip_bits(&s->gb, 2); /* vop coding type */
2351 //FIXME not rect stuff here
2352
2353 if(s->shape != BIN_ONLY_SHAPE){
2354 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2355 //FIXME dont just ignore everything
2356 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2357 mpeg4_decode_sprite_trajectory(s);
2358 fprintf(stderr, "untested\n");
2359 }
2360
2361 //FIXME reduced res stuff here
2362
2363 if (s->pict_type != I_TYPE) {
2364 int f_code = get_bits(&s->gb, 3); /* fcode_for */
2365 if(f_code==0){
2366 printf("Error, video packet header damaged (f_code=0)\n");
2367 }
2368 }
2369 if (s->pict_type == B_TYPE) {
2370 int b_code = get_bits(&s->gb, 3);
2371 if(b_code==0){
2372 printf("Error, video packet header damaged (b_code=0)\n");
2373 }
2374 }
2375 }
2376 }
2377 //FIXME new-pred stuff
2378
2379 //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));
2380
2381 return 0;
2382 }
2383
2384 void ff_mpeg4_clean_buffers(MpegEncContext *s)
2385 {
2386 int c_wrap, c_xy, l_wrap, l_xy;
2387
2388 l_wrap= s->block_wrap[0];
2389 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2390 c_wrap= s->block_wrap[4];
2391 c_xy= s->mb_y*c_wrap + s->mb_x;
2392
2393 #if 0
2394 /* clean DC */
2395 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2396 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2397 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2398 #endif
2399
2400 /* clean AC */
2401 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
2402 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
2403 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
2404
2405 /* clean MV */
2406 // we cant clear the MVs as they might be needed by a b frame
2407 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
2408 // memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2409 s->last_mv[0][0][0]=
2410 s->last_mv[0][0][1]=
2411 s->last_mv[1][0][0]=
2412 s->last_mv[1][0][1]= 0;
2413 }
2414
2415 /**
2416 * decodes the group of blocks / video packet header.
2417 * @return <0 if no resync found
2418 */
2419 int ff_h263_resync(MpegEncContext *s){
2420 int left, ret;
2421
2422 if(s->codec_id==CODEC_ID_MPEG4)
2423 skip_bits1(&s->gb);
2424
2425 align_get_bits(&s->gb);
2426
2427 if(show_bits(&s->gb, 16)==0){
2428 if(s->codec_id==CODEC_ID_MPEG4)
2429 ret= mpeg4_decode_video_packet_header(s);
2430 else
2431 ret= h263_decode_gob_header(s);
2432 if(ret>=0)
2433 return 0;
2434 }
2435 //ok, its not where its supposed to be ...
2436 s->gb= s->last_resync_gb;
2437 align_get_bits(&s->gb);
2438 left= s->gb.size*8 - get_bits_count(&s->gb);
2439
2440 for(;left>16+1+5+5; left-=8){
2441 if(show_bits(&s->gb, 16)==0){
2442 GetBitContext bak= s->gb;
2443
2444 if(s->codec_id==CODEC_ID_MPEG4)
2445 ret= mpeg4_decode_video_packet_header(s);
2446 else
2447 ret= h263_decode_gob_header(s);
2448 if(ret>=0)
2449 return 0;
2450
2451 s->gb= bak;
2452 }
2453 skip_bits(&s->gb, 8);
2454 }
2455
2456 return -1;
2457 }
2458
2459 /**
2460 * @param n either 0 for the x component or 1 for y
2461 * @returns the average MV for a GMC MB
2462 */
2463 static inline int get_amv(MpegEncContext *s, int n){
2464 int x, y, mb_v, sum, dx, dy, shift;
2465 int len = 1 << (s->f_code + 4);
2466 const int a= s->sprite_warping_accuracy;
2467
2468 if(s->real_sprite_warping_points==1){
2469 if(s->divx_version==500 && s->divx_build==413)
2470 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2471 else
2472 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2473 }else{
2474 dx= s->sprite_delta[n][0];
2475 dy= s->sprite_delta[n][1];
2476 shift= s->sprite_shift[0];
2477 if(n) dy -= 1<<(shift + a + 1);
2478 else dx -= 1<<(shift + a + 1);
2479 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2480
2481 sum=0;
2482 for(y=0; y<16; y++){
2483 int v;
2484
2485 v= mb_v + dy*y;
2486 //XXX FIXME optimize
2487 for(x=0; x<16; x++){
2488 sum+= v>>shift;
2489 v+= dx;
2490 }
2491 }
2492 sum /= 256;
2493 sum= RSHIFT(sum<<s->quarter_sample, a);
2494 }
2495
2496 if (sum < -len) sum= -len;
2497 else if (sum >= len) sum= len-1;
2498
2499 return sum;
2500 }
2501
2502 /**
2503 * decodes first partition.
2504 * @return number of MBs decoded or <0 if an error occured
2505 */
2506 static int mpeg4_decode_partition_a(MpegEncContext *s){
2507 int mb_num;
2508 static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2509
2510 /* decode first partition */
2511 mb_num=0;
2512 s->first_slice_line=1;
2513 for(; s->mb_y<s->mb_height; s->mb_y++){
2514 ff_init_block_index(s);
2515 for(; s->mb_x<s->mb_width; s->mb_x++){
2516 const int xy= s->mb_x + s->mb_y*s->mb_width;
2517 int cbpc;
2518 int dir=0;
2519
2520 mb_num++;
2521 ff_update_block_index(s);
2522 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2523 s->first_slice_line=0;
2524
2525 if(s->mb_x==0) PRINT_MB_TYPE("\n");
2526
2527 if(s->pict_type==I_TYPE){
2528 int i;
2529
2530 if(show_bits(&s->gb, 19)==DC_MARKER){
2531 return mb_num-1;
2532 }
2533
2534 PRINT_MB_TYPE("I");
2535 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2536 if (cbpc < 0){
2537
2538 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2539 return -1;
2540 }
2541 s->cbp_table[xy]= cbpc & 3;
2542 s->mb_type[xy]= MB_TYPE_INTRA;
2543 s->mb_intra = 1;
2544
2545 if(cbpc & 4) {
2546 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2547 }
2548 s->current_picture.qscale_table[xy]= s->qscale;
2549
2550 s->mbintra_table[xy]= 1;
2551 for(i=0; i<6; i++){
2552 int dc_pred_dir;
2553 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2554 if(dc < 0){
2555 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2556 return -1;
2557 }
2558 dir<<=1;
2559 if(dc_pred_dir) dir|=1;
2560 }
2561 s->pred_dir_table[xy]= dir;
2562
2563 s->error_status_table[xy]= AC_ERROR;
2564 }else{ /* P/S_TYPE */
2565 int mx, my, pred_x, pred_y, bits;
2566 INT16 * const mot_val= s->motion_val[s->block_index[0]];
2567 const int stride= s->block_wrap[0]*2;
2568
2569 bits= show_bits(&s->gb, 17);
2570 if(bits==MOTION_MARKER){
2571 return mb_num-1;
2572 }
2573 skip_bits1(&s->gb);
2574 if(bits&0x10000){
2575 /* skip mb */
2576 s->mb_type[xy]= MB_TYPE_SKIPED;
2577 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2578 PRINT_MB_TYPE("G");
2579 mx= get_amv(s, 0);
2580 my= get_amv(s, 1);
2581 }else{
2582 PRINT_MB_TYPE("S");
2583 mx=my=0;
2584 }
2585 mot_val[0 ]= mot_val[2 ]=
2586 mot_val[0+stride]= mot_val[2+stride]= mx;
2587 mot_val[1 ]= mot_val[3 ]=
2588 mot_val[1+stride]= mot_val[3+stride]= my;
2589
2590 if(s->mbintra_table[xy])
2591 ff_clean_intra_table_entries(s);
2592
2593 s->error_status_table[xy]= AC_ERROR;
2594 continue;
2595 }
2596 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2597 if (cbpc < 0){
2598 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2599 return -1;
2600 }
2601 if (cbpc > 20)
2602 cbpc+=3;
2603 else if (cbpc == 20)
2604 fprintf(stderr, "Stuffing !");
2605 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2606
2607 s->mb_intra = ((cbpc & 4) != 0);
2608
2609 if(s->mb_intra){
2610 PRINT_MB_TYPE("I");
2611 s->mbintra_table[xy]= 1;
2612 s->mb_type[xy]= MB_TYPE_INTRA;
2613 mot_val[0 ]= mot_val[2 ]=
2614 mot_val[0+stride]= mot_val[2+stride]= 0;
2615 mot_val[1 ]= mot_val[3 ]=
2616 mot_val[1+stride]= mot_val[3+stride]= 0;
2617 s->error_status_table[xy]= DC_ERROR|AC_ERROR;
2618 }else{
2619 if(s->mbintra_table[xy])
2620 ff_clean_intra_table_entries(s);
2621
2622 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2623 s->mcsel= get_bits1(&s->gb);
2624 else s->mcsel= 0;
2625
2626 if ((cbpc & 16) == 0) {
2627 PRINT_MB_TYPE("P");
2628 /* 16x16 motion prediction */
2629 s->mb_type[xy]= MB_TYPE_INTER;
2630
2631 h263_pred_motion(s, 0, &pred_x, &pred_y);
2632 if(!s->mcsel){
2633 mx = h263_decode_motion(s, pred_x, s->f_code);
2634 if (mx >= 0xffff)
2635 return -1;
2636
2637 my = h263_decode_motion(s, pred_y, s->f_code);
2638 if (my >= 0xffff)
2639 return -1;
2640 } else {
2641 mx = get_amv(s, 0);
2642 my = get_amv(s, 1);
2643 }
2644
2645 mot_val[0 ]= mot_val[2 ] =
2646 mot_val[0+stride]= mot_val[2+stride]= mx;
2647 mot_val[1 ]= mot_val[3 ]=
2648 mot_val[1+stride]= mot_val[3+stride]= my;
2649 } else {
2650 int i;
2651 PRINT_MB_TYPE("4");
2652 s->mb_type[xy]= MB_TYPE_INTER4V;
2653 for(i=0;i<4;i++) {
2654 INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2655 mx = h263_decode_motion(s, pred_x, s->f_code);
2656 if (mx >= 0xffff)
2657 return -1;
2658
2659 my = h263_decode_motion(s, pred_y, s->f_code);
2660 if (my >= 0xffff)
2661 return -1;
2662 mot_val[0] = mx;
2663 mot_val[1] = my;
2664 }
2665 }
2666 s->error_status_table[xy]= AC_ERROR;
2667 }
2668 }
2669 }
2670 s->mb_x= 0;
2671 }
2672
2673 return mb_num;
2674 }
2675
2676 /**
2677 * decode second partition.
2678 * @return <0 if an error occured
2679 */
2680 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
2681 int mb_num=0;
2682 static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2683
2684 s->mb_x= s->resync_mb_x;
2685 s->first_slice_line=1;
2686 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2687 ff_init_block_index(s);
2688 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
2689 const int xy= s->mb_x + s->mb_y*s->mb_width;
2690
2691 mb_num++;
2692 ff_update_block_index(s);
2693 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2694 s->first_slice_line=0;
2695
2696 if(s->pict_type==I_TYPE){
2697 int ac_pred= get_bits1(&s->gb);
2698 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2699 if(cbpy<0){
2700 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2701 return -1;
2702 }
2703
2704 s->cbp_table[xy]|= cbpy<<2;
2705 s->pred_dir_table[xy]|= ac_pred<<7;
2706 }else{ /* P || S_TYPE */
2707 if(s->mb_type[xy]&MB_TYPE_INTRA){
2708 int dir=0,i;
2709 int ac_pred = get_bits1(&s->gb);
2710 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2711
2712 if(cbpy<0){
2713 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2714 return -1;
2715 }
2716
2717 if(s->cbp_table[xy] & 8) {
2718 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2719 }
2720 s->current_picture.qscale_table[xy]= s->qscale;
2721
2722 for(i=0; i<6; i++){
2723 int dc_pred_dir;
2724 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2725 if(dc < 0){
2726 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2727 return -1;
2728 }
2729 dir<<=1;
2730 if(dc_pred_dir) dir|=1;
2731 }
2732 s->cbp_table[xy]&= 3; //remove dquant
2733 s->cbp_table[xy]|= cbpy<<2;
2734 s->pred_dir_table[xy]= dir | (ac_pred<<7);
2735 s->error_status_table[xy]&= ~DC_ERROR;
2736 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
2737 s->current_picture.qscale_table[xy]= s->qscale;
2738 s->cbp_table[xy]= 0;
2739 }else{
2740 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2741
2742 if(cbpy<0){
2743 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2744 return -1;
2745 }
2746
2747 if(s->cbp_table[xy] & 8) {
2748 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2749 }
2750 s->current_picture.qscale_table[xy]= s->qscale;
2751
2752 s->cbp_table[xy]&= 3; //remove dquant
2753 s->cbp_table[xy]|= (cbpy^0xf)<<2;
2754 }
2755 }
2756 }
2757 if(mb_num >= mb_count) return 0;
2758 s->mb_x= 0;
2759 }
2760 return 0;
2761 }
2762
2763 /**
2764 * decodes the first & second partition
2765 * @return <0 if error (and sets error type in the error_status_table)
2766 */
2767 int ff_mpeg4_decode_partitions(MpegEncContext *s)
2768 {
2769 int mb_num;
2770
2771 mb_num= mpeg4_decode_partition_a(s);
2772 if(mb_num<0)
2773 return -1;
2774
2775 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
2776 fprintf(stderr, "slice below monitor ...\n");
2777 return -1;
2778 }
2779
2780 s->mb_num_left= mb_num;
2781
2782 if(s->pict_type==I_TYPE){
2783 if(get_bits(&s->gb, 19)!=DC_MARKER){
2784 fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
2785 return -1;
2786 }else
2787 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END|DC_END;
2788 }else{
2789 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
2790 fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
2791 return -1;
2792 }else
2793 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END;
2794 }
2795
2796 if( mpeg4_decode_partition_b(s, mb_num) < 0){
2797 return -1;
2798 }
2799
2800 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= DC_END;
2801
2802 return 0;
2803 }
2804
2805 /**
2806 * decode partition C of one MB.
2807 * @return <0 if an error occured
2808 */
2809 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
2810 {
2811 int cbp, mb_type;
2812 const int xy= s->mb_x + s->mb_y*s->mb_width;
2813
2814 mb_type= s->mb_type[xy];
2815 cbp = s->cbp_table[xy];
2816
2817 if(s->current_picture.qscale_table[xy] != s->qscale){
2818 s->qscale= s->current_picture.qscale_table[xy];
2819 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2820 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2821 }
2822
2823 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2824 int i;
2825 for(i=0; i<4; i++){
2826 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
2827 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
2828 }
2829 s->mb_intra = mb_type&MB_TYPE_INTRA;
2830
2831 if (mb_type&MB_TYPE_SKIPED) {
2832 /* skip mb */
2833 for(i=0;i<6;i++)
2834 s->block_last_index[i] = -1;
2835 s->mv_dir = MV_DIR_FORWARD;
2836 s->mv_type = MV_TYPE_16X16;
2837 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2838 s->mcsel=1;
2839 s->mb_skiped = 0;
2840 }else{
2841 s->mcsel=0;
2842 s->mb_skiped = 1;
2843 }
2844 }else if(s->mb_intra){
2845 s->ac_pred = s->pred_dir_table[xy]>>7;
2846
2847 /* decode each block */
2848 for (i = 0; i < 6; i++) {
2849 if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
2850 fprintf(stderr, "texture corrupted at %d %d\n", s->mb_x, s->mb_y);
2851 return -1;
2852 }
2853 cbp+=cbp;
2854 }
2855 }else if(!s->mb_intra){
2856 // s->mcsel= 0; //FIXME do we need to init that
2857
2858 s->mv_dir = MV_DIR_FORWARD;
2859 if (mb_type&MB_TYPE_INTER4V) {
2860 s->mv_type = MV_TYPE_8X8;
2861 } else {
2862 s->mv_type = MV_TYPE_16X16;
2863 }
2864 /* decode each block */
2865 for (i = 0; i < 6; i++) {
2866 if(mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0){
2867 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2868 return -1;
2869 }
2870 cbp+=cbp;
2871 }
2872 }
2873 } else { /* I-Frame */
2874 int i;
2875 s->mb_intra = 1;
2876 s->ac_pred = s->pred_dir_table[xy]>>7;
2877
2878 /* decode each block */
2879 for (i = 0; i < 6; i++) {
2880 if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
2881 fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
2882 return -1;
2883 }
2884 cbp+=cbp;
2885 }
2886 }
2887
2888 s->error_status_table[xy]&= ~AC_ERROR;
2889
2890 /* per-MB end of slice check */
2891
2892 if(--s->mb_num_left <= 0){
2893 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size*8 - get_bits_count(&s->gb));
2894 if(mpeg4_is_resync(s))
2895 return SLICE_END;
2896 else
2897 return SLICE_NOEND;
2898 }else{
2899 if(s->cbp_table[xy+1] && mpeg4_is_resync(s))
2900 return SLICE_END;
2901 else
2902 return SLICE_OK;
2903 }
2904 }
2905
2906 int ff_h263_decode_mb(MpegEncContext *s,
2907 DCTELEM block[6][64])
2908 {
2909 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
2910 INT16 *mot_val;
2911 static INT8 quant_tab[4] = { -1, -2, 1, 2 };
2912
2913 s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
2914
2915 if(s->mb_x==0) PRINT_MB_TYPE("\n");
2916
2917 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2918 if (get_bits1(&s->gb)) {
2919 /* skip mb */
2920 s->mb_intra = 0;
2921 for(i=0;i<6;i++)
2922 s->block_last_index[i] = -1;
2923 s->mv_dir = MV_DIR_FORWARD;
2924 s->mv_type = MV_TYPE_16X16;
2925 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2926 PRINT_MB_TYPE("G");
2927 s->mcsel=1;
2928 s->mv[0][0][0]= get_amv(s, 0);
2929 s->mv[0][0][1]= get_amv(s, 1);
2930
2931 s->mb_skiped = 0;
2932 }else{
2933 PRINT_MB_TYPE("S");
2934 s->mcsel=0;
2935 s->mv[0][0][0] = 0;
2936 s->mv[0][0][1] = 0;
2937 s->mb_skiped = 1;
2938 }
2939 goto end;
2940 }
2941 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2942 //fprintf(stderr, "\tCBPC: %d", cbpc);
2943 if (cbpc < 0)
2944 return -1;
2945 if (cbpc > 20)
2946 cbpc+=3;
2947 else if (cbpc == 20)
2948 fprintf(stderr, "Stuffing !");
2949
2950 dquant = cbpc & 8;
2951 s->mb_intra = ((cbpc & 4) != 0);
2952 if (s->mb_intra) goto intra;
2953
2954 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2955 s->mcsel= get_bits1(&s->gb);
2956 else s->mcsel= 0;
2957 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2958 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
2959 if (dquant) {
2960 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2961 }
2962 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
2963 s->interlaced_dct= get_bits1(&s->gb);
2964
2965 s->mv_dir = MV_DIR_FORWARD;
2966 if ((cbpc & 16) == 0) {
2967 if(s->mcsel){
2968 PRINT_MB_TYPE("G");
2969 /* 16x16 global motion prediction */
2970 s->mv_type = MV_TYPE_16X16;
2971 mx= get_amv(s, 0);
2972 my= get_amv(s, 1);
2973 s->mv[0][0][0] = mx;
2974 s->mv[0][0][1] = my;
2975 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
2976 PRINT_MB_TYPE("f");
2977 /* 16x8 field motion prediction */
2978 s->mv_type= MV_TYPE_FIELD;
2979
2980 s->field_select[0][0]= get_bits1(&s->gb);
2981 s->field_select[0][1]= get_bits1(&s->gb);
2982
2983 h263_pred_motion(s, 0, &pred_x, &pred_y);
2984
2985 for(i=0; i<2; i++){
2986 mx = h263_decode_motion(s, pred_x, s->f_code);
2987 if (mx >= 0xffff)
2988 return -1;
2989
2990 my = h263_decode_motion(s, pred_y/2, s->f_code);
2991 if (my >= 0xffff)
2992 return -1;
2993
2994 s->mv[0][i][0] = mx;
2995 s->mv[0][i][1] = my;
2996 }
2997 }else{
2998 PRINT_MB_TYPE("P");
2999 /* 16x16 motion prediction */
3000 s->mv_type = MV_TYPE_16X16;
3001 h263_pred_motion(s, 0, &pred_x, &pred_y);
3002 if (s->umvplus_dec)
3003 mx = h263p_decode_umotion(s, pred_x);
3004 else
3005 mx = h263_decode_motion(s, pred_x, s->f_code);
3006
3007 if (mx >= 0xffff)
3008 return -1;
3009
3010 if (s->umvplus_dec)
3011 my = h263p_decode_umotion(s, pred_y);
3012 else
3013 my = h263_decode_motion(s, pred_y, s->f_code);
3014
3015 if (my >= 0xffff)
3016 return -1;
3017 s->mv[0][0][0] = mx;
3018 s->mv[0][0][1] = my;
3019
3020 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
3021 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3022 }
3023 } else {
3024 PRINT_MB_TYPE("4");
3025 s->mv_type = MV_TYPE_8X8;
3026 for(i=0;i<4;i++) {
3027 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3028 if (s->umvplus_dec)
3029 mx = h263p_decode_umotion(s, pred_x);
3030 else
3031 mx = h263_decode_motion(s, pred_x, s->f_code);
3032 if (mx >= 0xffff)
3033 return -1;
3034
3035 if (s->umvplus_dec)
3036 my = h263p_decode_umotion(s, pred_y);
3037 else
3038 my = h263_decode_motion(s, pred_y, s->f_code);
3039 if (my >= 0xffff)
3040 return -1;
3041 s->mv[0][i][0] = mx;
3042 s->mv[0][i][1] = my;
3043 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
3044 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3045 mot_val[0] = mx;
3046 mot_val[1] = my;
3047 }
3048 }
3049 } else if(s->pict_type==B_TYPE) {
3050 int modb1; // first bit of modb
3051 int modb2; // second bit of modb
3052 int mb_type;
3053 uint16_t time_pp;
3054 uint16_t time_pb;
3055 int xy;
3056
3057 s->mb_intra = 0; //B-frames never contain intra blocks
3058 s->mcsel=0; // ... true gmc blocks
3059
3060 if(s->mb_x==0){
3061 for(i=0; i<2; i++){
3062 s->last_mv[i][0][0]=
3063 s->last_mv[i][0][1]=
3064 s->last_mv[i][1][0]=
3065 s->last_mv[i][1][1]= 0;
3066 }
3067 }
3068
3069 /* if we skipped it in the future P Frame than skip it now too */
3070 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
3071
3072 if(s->mb_skiped){
3073 /* skip mb */
3074 for(i=0;i<6;i++)
3075 s->block_last_index[i] = -1;
3076
3077 s->mv_dir = MV_DIR_FORWARD;
3078 s->mv_type = MV_TYPE_16X16;
3079 s->mv[0][0][0] = 0;
3080 s->mv[0][0][1] = 0;
3081 s->mv[1][0][0] = 0;
3082 s->mv[1][0][1] = 0;
3083 PRINT_MB_TYPE("s");
3084 goto end;
3085 }
3086
3087 modb1= get_bits1(&s->gb);
3088 if(modb1){
3089 mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
3090 cbp=0;
3091 }else{
3092 int field_mv;
3093
3094 modb2= get_bits1(&s->gb);
3095 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3096 if(modb2) cbp= 0;
3097 else cbp= get_bits(&s->gb, 6);
3098
3099 if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
3100 if(get_bits1(&s->gb)){
3101 change_qscale(s, get_bits1(&s->gb)*4 - 2);
3102 }
3103 }
3104 field_mv=0;
3105
3106 if(!s->progressive_sequence){
3107 if(cbp)
3108 s->interlaced_dct= get_bits1(&s->gb);
3109
3110 if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
3111 field_mv=1;
3112
3113 if(mb_type!=MB_TYPE_B_BACKW){
3114 s->field_select[0][0]= get_bits1(&s->gb);
3115 s->field_select[0][1]= get_bits1(&s->gb);
3116 }
3117 if(mb_type!=MB_TYPE_B_FORW){
3118 s->field_select[1][0]= get_bits1(&s->gb);
3119 s->field_select[1][1]= get_bits1(&s->gb);
3120 }
3121 }
3122 }
3123
3124 s->mv_dir = 0;
3125 if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
3126 s->mv_type= MV_TYPE_16X16;
3127 if(mb_type!=MB_TYPE_B_BACKW){
3128 s->mv_dir = MV_DIR_FORWARD;
3129
3130 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3131 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3132 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3133 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3134 }
3135
3136 if(mb_type!=MB_TYPE_B_FORW){
3137 s->mv_dir |= MV_DIR_BACKWARD;
3138
3139 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3140 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3141 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3142 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3143 }
3144 if(mb_type!=MB_TYPE_B_DIRECT)
3145 PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
3146 }else if(mb_type!=MB_TYPE_B_DIRECT){
3147 s->mv_type= MV_TYPE_FIELD;
3148
3149 if(mb_type!=MB_TYPE_B_BACKW){
3150 s->mv_dir = MV_DIR_FORWARD;
3151
3152 for(i=0; i<2; i++){
3153 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
3154 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3155 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
3156 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3157 }
3158 }
3159
3160 if(mb_type!=MB_TYPE_B_FORW){
3161 s->mv_dir |= MV_DIR_BACKWARD;
3162
3163 for(i=0; i<2; i++){
3164 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
3165 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3166 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
3167 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3168 }
3169 }
3170 if(mb_type!=MB_TYPE_B_DIRECT)
3171 PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "f" : (mb_type==MB_TYPE_B_BACKW ? "b" : "t"));
3172 }
3173 }
3174
3175 if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
3176 int mb_index= s->mb_x + s->mb_y*s->mb_width;
3177 int i;
3178
3179 if(mb_type==4)
3180 mx=my=0;
3181 else{
3182 mx = h263_decode_motion(s, 0, 1);
3183 my = h263_decode_motion(s, 0, 1);
3184 }
3185
3186 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3187 xy= s->block_index[0];
3188 time_pp= s->pp_time;
3189 time_pb= s->pb_time;
3190
3191 //FIXME avoid divides
3192 switch(s->co_located_type_table[mb_index]){
3193 case 0:
3194 s->mv_type= MV_TYPE_16X16;
3195 s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
3196 s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
3197 s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
3198 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
3199 s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
3200 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
3201 PRINT_MB_TYPE(mb_type==4 ? "D" : "S");
3202 break;
3203 case CO_LOCATED_TYPE_4MV:
3204 s->mv_type = MV_TYPE_8X8;
3205 for(i=0; i<4; i++){
3206 xy= s->block_index[i];
3207 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
3208 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
3209 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
3210 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
3211 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
3212 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
3213 }
3214 PRINT_MB_TYPE("4");
3215 break;
3216 case CO_LOCATED_TYPE_FIELDMV:
3217 s->mv_type = MV_TYPE_FIELD;
3218 for(i=0; i<2; i++){
3219 if(s->top_field_first){
3220 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
3221 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
3222 }else{
3223 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
3224 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
3225 }
3226 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
3227 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
3228 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
3229 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
3230 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
3231 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
3232 }
3233 PRINT_MB_TYPE("=");
3234 break;
3235 }
3236 }
3237
3238 if(mb_type<0 || mb_type>4){
3239 printf("illegal MB_type\n");
3240 return -1;
3241 }
3242 } else { /* I-Frame */
3243 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
3244 if (cbpc < 0)
3245 return -1;
3246 dquant = cbpc & 4;
3247 s->mb_intra = 1;
3248 intra:
3249 s->ac_pred = 0;
3250 if (s->h263_pred || s->h263_aic) {
3251 s->ac_pred = get_bits1(&s->gb);
3252 if (s->ac_pred && s->h263_aic)
3253 s->h263_aic_dir = get_bits1(&s->gb);
3254 }
3255 PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
3256
3257 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3258 if(cbpy<0) return -1;
3259 cbp = (cbpc & 3) | (cbpy << 2);
3260 if (dquant) {
3261 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3262 }
3263
3264 if(!s->progressive_sequence)
3265 s->interlaced_dct= get_bits1(&s->gb);
3266
3267 /* decode each block */
3268 if (s->h263_pred) {
3269 for (i = 0; i < 6; i++) {
3270 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0)
3271 return -1;
3272 cbp+=cbp;
3273 }
3274 } else {
3275 for (i = 0; i < 6; i++) {
3276 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3277 return -1;
3278 cbp+=cbp;
3279 }
3280 }
3281 goto end;
3282 }
3283
3284 /* decode each block */
3285 if (s->h263_pred) {
3286 for (i = 0; i < 6; i++) {
3287 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0)
3288 return -1;
3289 cbp+=cbp;
3290 }
3291 } else {
3292 for (i = 0; i < 6; i++) {
3293 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3294 return -1;
3295 cbp+=cbp;
3296 }
3297 }
3298 end:
3299
3300 /* per-MB end of slice check */
3301 if(s->codec_id==CODEC_ID_MPEG4){
3302 if(mpeg4_is_resync(s)){
3303 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x+1])
3304 return SLICE_OK;
3305 return SLICE_END;
3306 }
3307 }else{
3308 int v= show_bits(&s->gb, 16);
3309
3310 if(get_bits_count(&s->gb) + 16 > s->gb.size*8){
3311 v>>= get_bits_count(&s->gb) + 16 - s->gb.size*8;
3312 }
3313
3314 if(v==0)
3315 return SLICE_END;
3316 }
3317
3318 return SLICE_OK;
3319 }
3320
3321 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3322 {
3323 int code, val, sign, shift, l;
3324 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3325 if (code < 0)
3326 return 0xffff;
3327
3328 if (code == 0)
3329 return pred;
3330
3331 sign = get_bits1(&s->gb);
3332 shift = f_code - 1;
3333 val = (code - 1) << shift;
3334 if (shift > 0)
3335 val |= get_bits(&s->gb, shift);
3336 val++;
3337 if (sign)
3338 val = -val;
3339 val += pred;
3340
3341 /* modulo decoding */
3342 if (!s->h263_long_vectors) {
3343 l = 1 << (f_code + 4);
3344 if (val < -l) {
3345 val += l<<1;
3346 } else if (val >= l) {
3347 val -= l<<1;
3348 }
3349 } else {
3350 /* horrible h263 long vector mode */
3351 if (pred < -31 && val < -63)
3352 val += 64;
3353 if (pred > 32 && val > 63)
3354 val -= 64;
3355
3356 }
3357 return val;
3358 }
3359
3360 /* Decodes RVLC of H.263+ UMV */
3361 static int h263p_decode_umotion(MpegEncContext * s, int pred)
3362 {
3363 int code = 0, sign;
3364
3365 if (get_bits1(&s->gb)) /* Motion difference = 0 */
3366 return pred;
3367
3368 code = 2 + get_bits1(&s->gb);
3369
3370 while (get_bits1(&s->gb))
3371 {
3372 code <<= 1;
3373 code += get_bits1(&s->gb);
3374 }
3375 sign = code & 1;
3376 code >>= 1;
3377
3378 code = (sign) ? (pred - code) : (pred + code);
3379 #ifdef DEBUG
3380 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3381 #endif
3382 return code;
3383
3384 }
3385
3386 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3387 int n, int coded)
3388 {
3389 int code, level, i, j, last, run;
3390 RLTable *rl = &rl_inter;
3391 const UINT8 *scan_table;
3392
3393 scan_table = s->intra_scantable.permutated;
3394 if (s->h263_aic && s->mb_intra) {
3395 rl = &rl_intra_aic;
3396 i = 0;
3397 if (s->ac_pred) {
3398 if (s->h263_aic_dir)
3399 scan_table = s->intra_v_scantable.permutated; /* left */
3400 else
3401 scan_table = s->intra_h_scantable.permutated; /* top */
3402 }
3403 } else if (s->mb_intra) {
3404 /* DC coef */
3405 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
3406 int component, diff;
3407 component = (n <= 3 ? 0 : n - 4 + 1);
3408 level = s->last_dc[component];
3409 if (s->rv10_first_dc_coded[component]) {
3410 diff = rv_decode_dc(s, n);
3411 if (diff == 0xffff)
3412 return -1;
3413 level += diff;
3414 level = level & 0xff; /* handle wrap round */
3415 s->last_dc[component] = level;
3416 } else {
3417 s->rv10_first_dc_coded[component] = 1;
3418 }
3419 } else {
3420 level = get_bits(&s->gb, 8);
3421 if (level == 255)
3422 level = 128;
3423 }
3424 block[0] = level;
3425 i = 1;
3426 } else {
3427 i = 0;
3428 }
3429 if (!coded) {
3430 if (s->mb_intra && s->h263_aic)
3431 goto not_coded;
3432 s->block_last_index[n] = i - 1;
3433 return 0;
3434 }
3435
3436 for(;;) {
3437 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3438 if (code < 0){
3439 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3440 return -1;
3441 }
3442 if (code == rl->n) {
3443 /* escape */
3444 last = get_bits1(&s->gb);
3445 run = get_bits(&s->gb, 6);
3446 level = (INT8)get_bits(&s->gb, 8);
3447 if (s->h263_rv10 && level == -128) {
3448 /* XXX: should patch encoder too */
3449 level = get_bits(&s->gb, 12);
3450 level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
3451 }
3452 } else {
3453 run = rl->table_run[code];
3454 level = rl->table_level[code];
3455 last = code >= rl->last;
3456 if (get_bits1(&s->gb))
3457 level = -level;
3458 }
3459 i += run;
3460 if (i >= 64){
3461 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3462 return -1;
3463 }
3464 j = scan_table[i];
3465 block[j] = level;
3466 if (last)
3467 break;
3468 i++;
3469 }
3470 not_coded:
3471 if (s->mb_intra && s->h263_aic) {
3472 h263_pred_acdc(s, block, n);
3473 i = 63;
3474 }
3475 s->block_last_index[n] = i;
3476 return 0;
3477 }
3478
3479 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3480 {
3481 int level, pred, code;
3482 UINT16 *dc_val;
3483
3484 if (n < 4)
3485 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3486 else
3487 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3488 if (code < 0 || code > 9 /* && s->nbit<9 */){
3489 fprintf(stderr, "illegal dc vlc\n");
3490 return -1;
3491 }
3492 if (code == 0) {
3493 level = 0;
3494 } else {
3495 level = get_bits(&s->gb, code);
3496 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
3497 level = - (level ^ ((1 << code) - 1));
3498 if (code > 8){
3499 if(get_bits1(&s->gb)==0){ /* marker */
3500 if(s->error_resilience>=2){
3501 fprintf(stderr, "dc marker bit missing\n");
3502 return -1;
3503 }
3504 }
3505 }
3506 }
3507 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3508 level += pred;
3509 if (level < 0){
3510 if(s->error_resilience>=3){
3511 fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3512 return -1;
3513 }
3514 level = 0;
3515 }
3516 if (n < 4) {
3517 *dc_val = level * s->y_dc_scale;
3518 } else {
3519 *dc_val = level * s->c_dc_scale;
3520 }
3521 if(s->error_resilience>=3){
3522 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3523 fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3524 return -1;
3525 }
3526 }
3527 return level;
3528 }
3529
3530 /**
3531 * decodes a block.
3532 * @return <0 if an error occured
3533 */
3534 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3535 int n, int coded, int intra)
3536 {
3537 int level, i, last, run;
3538 int dc_pred_dir;
3539 RLTable * rl;
3540 RL_VLC_ELEM * rl_vlc;
3541 const UINT8 * scan_table;
3542 int qmul, qadd;
3543
3544 if(intra) {
3545 /* DC coef */
3546 if(s->partitioned_frame){
3547 level = s->dc_val[0][ s->block_index[n] ];
3548 if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
3549 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
3550 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
3551 }else{
3552 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3553 if (level < 0)
3554 return -1;
3555 }
3556 block[0] = level;
3557 i = 0;
3558 if (!coded)
3559 goto not_coded;
3560 rl = &rl_intra;
3561 rl_vlc = rl_intra.rl_vlc[0];
3562 if (s->ac_pred) {
3563 if (dc_pred_dir == 0)
3564 scan_table = s->intra_v_scantable.permutated; /* left */
3565 else
3566 scan_table = s->intra_h_scantable.permutated; /* top */
3567 } else {
3568 scan_table = s->intra_scantable.permutated;
3569 }
3570 qmul=1;
3571 qadd=0;
3572 } else {
3573 i = -1;
3574 if (!coded) {
3575 s->block_last_index[n] = i;
3576 return 0;
3577 }
3578 rl = &rl_inter;
3579
3580 scan_table = s->intra_scantable.permutated;
3581
3582 if(s->mpeg_quant){
3583 qmul=1;
3584 qadd=0;
3585 rl_vlc = rl_inter.rl_vlc[0];
3586 }else{
3587 qmul = s->qscale << 1;
3588 qadd = (s->qscale - 1) | 1;
3589 rl_vlc = rl_inter.rl_vlc[s->qscale];
3590 }
3591 }
3592 {
3593 OPEN_READER(re, &s->gb);
3594 for(;;) {
3595 UPDATE_CACHE(re, &s->gb);
3596 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3597 if (level==0) {
3598 int cache;
3599 cache= GET_CACHE(re, &s->gb);
3600 /* escape */
3601 if (cache&0x80000000) {
3602 if (cache&0x40000000) {
3603 /* third escape */
3604 SKIP_CACHE(re, &s->gb, 2);
3605 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3606 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3607 SKIP_COUNTER(re, &s->gb, 2+1+6);
3608 UPDATE_CACHE(re, &s->gb);
3609
3610 if(SHOW_UBITS(re, &s->gb, 1)==0){
3611 fprintf(stderr, "1. marker bit missing in 3. esc\n");
3612 return -1;
3613 }; SKIP_CACHE(re, &s->gb, 1);
3614
3615 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3616
3617 if(SHOW_UBITS(re, &s->gb, 1)==0){
3618 fprintf(stderr, "2. marker bit missing in 3. esc\n");
3619 return -1;
3620 }; LAST_SKIP_CACHE(re, &s->gb, 1);
3621
3622 SKIP_COUNTER(re, &s->gb, 1+12+1);
3623
3624 if(level*s->qscale>1024 || level*s->qscale<-1024){
3625 fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3626 return -1;
3627 }
3628 #if 1
3629 {
3630 const int abs_level= ABS(level);
3631 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
3632 const int run1= run - rl->max_run[last][abs_level] - 1;
3633 if(abs_level <= rl->max_level[last][run]){
3634 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3635 return -1;
3636 }
3637 if(s->error_resilience > FF_ER_COMPLIANT){
3638 if(abs_level <= rl->max_level[last][run]*2){
3639 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3640 return -1;
3641 }
3642 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3643 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3644 return -1;
3645 }
3646 }
3647 }
3648 }
3649 #endif
3650 if (level>0) level= level * qmul + qadd;
3651 else level= level * qmul - qadd;
3652
3653 i+= run + 1;
3654 if(last) i+=192;
3655 } else {
3656 /* second escape */
3657 #if MIN_CACHE_BITS < 20
3658 LAST_SKIP_BITS(re, &s->gb, 2);
3659 UPDATE_CACHE(re, &s->gb);
3660 #else
3661 SKIP_BITS(re, &s->gb, 2);
3662 #endif
3663 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3664 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3665 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3666 LAST_SKIP_BITS(re, &s->gb, 1);
3667 }
3668 } else {
3669 /* first escape */
3670 #if MIN_CACHE_BITS < 19
3671 LAST_SKIP_BITS(re, &s->gb, 1);
3672 UPDATE_CACHE(re, &s->gb);
3673 #else
3674 SKIP_BITS(re, &s->gb, 1);
3675 #endif
3676 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3677 i+= run;
3678 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3679 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3680 LAST_SKIP_BITS(re, &s->gb, 1);
3681 }
3682 } else {
3683 i+= run;
3684 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3685 LAST_SKIP_BITS(re, &s->gb, 1);
3686 }
3687 if (i > 62){
3688 i-= 192;
3689 if(i&(~63)){
3690 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3691 return -1;
3692 }
3693
3694 block[scan_table[i]] = level;
3695 break;
3696 }
3697
3698 block[scan_table[i]] = level;
3699 }
3700 CLOSE_READER(re, &s->gb);
3701 }
3702 not_coded:
3703 if (s->mb_intra) {
3704 mpeg4_pred_ac(s, block, n, dc_pred_dir);
3705 if (s->ac_pred) {
3706 i = 63; /* XXX: not optimal */
3707 }
3708 }
3709 s->block_last_index[n] = i;
3710 return 0;
3711 }
3712
3713 /* most is hardcoded. should extend to handle all h263 streams */
3714 int h263_decode_picture_header(MpegEncContext *s)
3715 {
3716 int format, width, height;
3717
3718 /* picture start code */
3719 if (get_bits(&s->gb, 22) != 0x20) {
3720 fprintf(stderr, "Bad picture start code\n");
3721 return -1;
3722 }
3723 /* temporal reference */
3724 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3725
3726 /* PTYPE starts here */
3727 if (get_bits1(&s->gb) != 1) {
3728 /* marker */
3729 fprintf(stderr, "Bad marker\n");
3730 return -1;
3731 }
3732 if (get_bits1(&s->gb) != 0) {
3733 fprintf(stderr, "Bad H263 id\n");
3734 return -1; /* h263 id */
3735 }
3736 skip_bits1(&s->gb); /* split screen off */
3737 skip_bits1(&s->gb); /* camera off */
3738 skip_bits1(&s->gb); /* freeze picture release off */
3739
3740 /* Reset GOB number */
3741 s->gob_number = 0;
3742
3743 format = get_bits(&s->gb, 3);
3744 /*
3745 0 forbidden
3746 1 sub-QCIF
3747 10 QCIF
3748 7 extended PTYPE (PLUSPTYPE)
3749 */
3750
3751 if (format != 7 && format != 6) {
3752 s->h263_plus = 0;
3753 /* H.263v1 */
3754 width = h263_format[format][0];
3755 height = h263_format[format][1];
3756 if (!width)
3757 return -1;
3758
3759 s->width = width;
3760 s->height = height;
3761 s->pict_type = I_TYPE + get_bits1(&s->gb);
3762
3763 s->unrestricted_mv = get_bits1(&s->gb);
3764 s->h263_long_vectors = s->unrestricted_mv;
3765
3766 if (get_bits1(&s->gb) != 0) {
3767 fprintf(stderr, "H263 SAC not supported\n");
3768 return -1; /* SAC: off */
3769 }
3770 if (get_bits1(&s->gb) != 0) {
3771 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3772 }
3773
3774 if (get_bits1(&s->gb) != 0) {
3775 fprintf(stderr, "H263 PB frame not supported\n");
3776 return -1; /* not PB frame */
3777 }
3778 s->qscale = get_bits(&s->gb, 5);
3779 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
3780 } else {
3781 int ufep;
3782
3783 /* H.263v2 */
3784 s->h263_plus = 1;
3785 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3786
3787 /* ufep other than 0 and 1 are reserved */
3788 if (ufep == 1) {
3789 /* OPPTYPE */
3790 format = get_bits(&s->gb, 3);
3791 dprintf("ufep=1, format: %d\n", format);
3792 skip_bits(&s->gb,1); /* Custom PCF */
3793 s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3794 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3795 if (get_bits1(&s->gb) != 0) {
3796 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3797 }
3798 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3799 s->h263_aic = 1;
3800 }
3801
3802 skip_bits(&s->gb, 7);
3803 /* these are the 7 bits: (in order of appearence */
3804 /* Deblocking Filter */
3805 /* Slice Structured */
3806 /* Reference Picture Selection */
3807 /* Independent Segment Decoding */
3808 /* Alternative Inter VLC */
3809 /* Modified Quantization */
3810 /* Prevent start code emulation */
3811
3812 skip_bits(&s->gb, 3); /* Reserved */
3813 } else if (ufep != 0) {
3814 fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3815 return -1;
3816 }
3817
3818 /* MPPTYPE */
3819 s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3820 dprintf("pict_type: %d\n", s->pict_type);
3821 if (s->pict_type != I_TYPE &&
3822 s->pict_type != P_TYPE)
3823 return -1;
3824 skip_bits(&s->gb, 2);
3825 s->no_rounding = get_bits1(&s->gb);
3826 dprintf("RTYPE: %d\n", s->no_rounding);
3827 skip_bits(&s->gb, 4);
3828
3829 /* Get the picture dimensions */
3830 if (ufep) {
3831 if (format == 6) {
3832 /* Custom Picture Format (CPFMT) */
3833 s->aspect_ratio_info = get_bits(&s->gb, 4);
3834 dprintf("aspect: %d\n", s->aspect_ratio_info);
3835 /* aspect ratios:
3836 0 - forbidden
3837 1 - 1:1
3838 2 - 12:11 (CIF 4:3)
3839 3 - 10:11 (525-type 4:3)
3840 4 - 16:11 (CIF 16:9)
3841 5 - 40:33 (525-type 16:9)
3842 6-14 - reserved
3843 */
3844 width = (get_bits(&s->gb, 9) + 1) * 4;
3845 skip_bits1(&s->gb);
3846 height = get_bits(&s->gb, 9) * 4;
3847 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
3848 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
3849 /* aspected dimensions */
3850 s->aspected_width = get_bits(&s->gb, 8);
3851 s->aspected_height = get_bits(&s->gb, 8);
3852 }else{
3853 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
3854 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
3855 }
3856 } else {
3857 width = h263_format[format][0];
3858 height = h263_format[format][1];
3859 }
3860 if ((width == 0) || (height == 0))
3861 return -1;
3862 s->width = width;
3863 s->height = height;
3864 if (s->umvplus_dec) {
3865 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
3866 }
3867 }
3868
3869 s->qscale = get_bits(&s->gb, 5);
3870 }
3871 /* PEI */
3872 while (get_bits1(&s->gb) != 0) {
3873 skip_bits(&s->gb, 8);
3874 }
3875 s->f_code = 1;
3876
3877 if(s->h263_aic){
3878 s->y_dc_scale_table=
3879 s->c_dc_scale_table= h263_aic_dc_scale_table;
3880 }else{
3881 s->y_dc_scale_table=
3882 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
3883 }
3884
3885 return 0;
3886 }
3887
3888 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
3889 {
3890 int i;
3891 int a= 2<<s->sprite_warping_accuracy;
3892 int rho= 3-s->sprite_warping_accuracy;
3893 int r=16/a;
3894 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
3895 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
3896 int sprite_ref[4][2];
3897 int virtual_ref[2][2];
3898 int w2, h2, w3, h3;
3899 int alpha=0, beta=0;
3900 int w= s->width;
3901 int h= s->height;
3902 int min_ab;
3903
3904 for(i=0; i<s->num_sprite_warping_points; i++){
3905 int length;
3906 int x=0, y=0;
3907
3908 length= get_vlc(&s->gb, &sprite_trajectory);
3909 if(length){
3910 x= get_bits(&s->gb, length);
3911
3912 if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
3913 x = - (x ^ ((1 << length) - 1));
3914 }
3915 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
3916
3917 length= get_vlc(&s->gb, &sprite_trajectory);
3918 if(length){
3919 y=get_bits(&s->gb, length);
3920
3921 if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
3922 y = - (y ^ ((1 << length) - 1));
3923 }
3924 skip_bits1(&s->gb); /* marker bit */
3925 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
3926 d[i][0]= x;
3927 d[i][1]= y;
3928 }
3929
3930 while((1<<alpha)<w) alpha++;
3931 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
3932 w2= 1<<alpha;
3933 h2= 1<<beta;
3934
3935 // Note, the 4th point isnt used for GMC
3936 if(s->divx_version==500 && s->divx_build==413){
3937 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
3938 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
3939 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
3940 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
3941 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
3942 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
3943 } else {
3944 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
3945 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
3946 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
3947 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
3948 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
3949 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
3950 }
3951 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
3952 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
3953
3954 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
3955 // perhaps it should be reordered to be more readable ...
3956 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
3957 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
3958 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
3959 + 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);
3960 virtual_ref[0][1]= 16*vop_ref[0][1]
3961 + 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);
3962 virtual_ref[1][0]= 16*vop_ref[0][0]
3963 + 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);
3964 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
3965 + 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);
3966
3967 switch(s->num_sprite_warping_points)
3968 {
3969 case 0:
3970 s->sprite_offset[0][0]= 0;
3971 s->sprite_offset[0][1]= 0;
3972 s->sprite_offset[1][0]= 0;
3973 s->sprite_offset[1][1]= 0;
3974 s->sprite_delta[0][0]= a;
3975 s->sprite_delta[0][1]= 0;
3976 s->sprite_delta[1][0]= 0;
3977 s->sprite_delta[1][1]= a;
3978 s->sprite_shift[0]= 0;
3979 s->sprite_shift[1]= 0;
3980 break;
3981 case 1: //GMC only
3982 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
3983 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
3984 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
3985 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
3986 s->sprite_delta[0][0]= a;
3987 s->sprite_delta[0][1]= 0;
3988 s->sprite_delta[1][0]= 0;
3989 s->sprite_delta[1][1]= a;
3990 s->sprite_shift[0]= 0;
3991 s->sprite_shift[1]= 0;
3992 break;
3993 case 2:
3994 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
3995 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
3996 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
3997 + (1<<(alpha+rho-1));
3998 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
3999 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
4000 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
4001 + (1<<(alpha+rho-1));
4002 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4003 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4004 +2*w2*r*sprite_ref[0][0]
4005 - 16*w2
4006 + (1<<(alpha+rho+1)));
4007 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
4008 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4009 +2*w2*r*sprite_ref[0][1]
4010 - 16*w2
4011 + (1<<(alpha+rho+1)));
4012 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4013 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4014 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4015 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4016
4017 s->sprite_shift[0]= alpha+rho;
4018 s->sprite_shift[1]= alpha+rho+2;
4019 break;
4020 case 3:
4021 min_ab= FFMIN(alpha, beta);
4022 w3= w2>>min_ab;
4023 h3= h2>>min_ab;
4024 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
4025 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
4026 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
4027 + (1<<(alpha+beta+rho-min_ab-1));
4028 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
4029 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
4030 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
4031 + (1<<(alpha+beta+rho-min_ab-1));
4032 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
4033 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
4034 + 2*w2*h3*r*sprite_ref[0][0]
4035 - 16*w2*h3
4036 + (1<<(alpha+beta+rho-min_ab+1));
4037 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4038 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4039 + 2*w2*h3*r*sprite_ref[0][1]
4040 - 16*w2*h3
4041 + (1<<(alpha+beta+rho-min_ab+1));
4042 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4043 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4044 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4045 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4046
4047 s->sprite_shift[0]= alpha + beta + rho - min_ab;
4048 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4049 break;
4050 }
4051 /* try to simplify the situation */
4052 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4053 && s->sprite_delta[0][1] == 0
4054 && s->sprite_delta[1][0] == 0
4055 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4056 {
4057 s->sprite_offset[0][0]>>=s->sprite_shift[0];
4058 s->sprite_offset[0][1]>>=s->sprite_shift[0];
4059 s->sprite_offset[1][0]>>=s->sprite_shift[1];
4060 s->sprite_offset[1][1]>>=s->sprite_shift[1];
4061 s->sprite_delta[0][0]= a;
4062 s->sprite_delta[0][1]= 0;
4063 s->sprite_delta[1][0]= 0;
4064 s->sprite_delta[1][1]= a;
4065 s->sprite_shift[0]= 0;
4066 s->sprite_shift[1]= 0;
4067 s->real_sprite_warping_points=1;
4068 }
4069 else{
4070 int shift_y= 16 - s->sprite_shift[0];
4071 int shift_c= 16 - s->sprite_shift[1];
4072 //printf("shifts %d %d\n", shift_y, shift_c);
4073 for(i=0; i<2; i++){
4074 s->sprite_offset[0][i]<<= shift_y;
4075 s->sprite_offset[1][i]<<= shift_c;
4076 s->sprite_delta[0][i]<<= shift_y;
4077 s->sprite_delta[1][i]<<= shift_y;
4078 s->sprite_shift[i]= 16;
4079 }
4080 s->real_sprite_warping_points= s->num_sprite_warping_points;
4081 }
4082 #if 0
4083 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4084 vop_ref[0][0], vop_ref[0][1],
4085 vop_ref[1][0], vop_ref[1][1],
4086 vop_ref[2][0], vop_ref[2][1],
4087 sprite_ref[0][0], sprite_ref[0][1],
4088 sprite_ref[1][0], sprite_ref[1][1],
4089 sprite_ref[2][0], sprite_ref[2][1],
4090 virtual_ref[0][0], virtual_ref[0][1],
4091 virtual_ref[1][0], virtual_ref[1][1]
4092 );
4093
4094 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4095 s->sprite_offset[0][0], s->sprite_offset[0][1],
4096 s->sprite_delta[0][0], s->sprite_delta[0][1],
4097 s->sprite_delta[1][0], s->sprite_delta[1][1],
4098 s->sprite_shift[0]
4099 );
4100 #endif
4101 }
4102
4103 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4104 int width, height, vo_ver_id;
4105
4106 /* vol header */
4107 skip_bits(gb, 1); /* random access */
4108 s->vo_type= get_bits(gb, 8);
4109 if (get_bits1(gb) != 0) { /* is_ol_id */
4110 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4111 skip_bits(gb, 3); /* vo_priority */
4112 } else {
4113 vo_ver_id = 1;
4114 }
4115 //printf("vo type:%d\n",s->vo_type);
4116 s->aspect_ratio_info= get_bits(gb, 4);
4117 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
4118 s->aspected_width = get_bits(gb, 8); // par_width
4119 s->aspected_height = get_bits(gb, 8); // par_height
4120 }else{
4121 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4122 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4123 }
4124
4125 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4126 int chroma_format= get_bits(gb, 2);
4127 if(chroma_format!=1){
4128 printf("illegal chroma format\n");
4129 }
4130 s->low_delay= get_bits1(gb);
4131 if(get_bits1(gb)){ /* vbv parameters */
4132 get_bits(gb, 15); /* first_half_bitrate */
4133 skip_bits1(gb); /* marker */
4134 get_bits(gb, 15); /* latter_half_bitrate */
4135 skip_bits1(gb); /* marker */
4136 get_bits(gb, 15); /* first_half_vbv_buffer_size */
4137 skip_bits1(gb); /* marker */
4138 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
4139 get_bits(gb, 11); /* first_half_vbv_occupancy */
4140 skip_bits1(gb); /* marker */
4141 get_bits(gb, 15); /* latter_half_vbv_occupancy */
4142 skip_bits1(gb); /* marker */
4143 }
4144 }else{
4145 // set low delay flag only once so the smart? low delay detection wont be overriden
4146 if(s->picture_number==0)
4147 s->low_delay=0;
4148 }
4149
4150 s->shape = get_bits(gb, 2); /* vol shape */
4151 if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4152 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4153 printf("Gray shape not supported\n");
4154 skip_bits(gb, 4); //video_object_layer_shape_extension
4155 }
4156
4157 skip_bits1(gb); /* marker */
4158
4159 s->time_increment_resolution = get_bits(gb, 16);
4160
4161 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4162 if (s->time_increment_bits < 1)
4163 s->time_increment_bits = 1;
4164 skip_bits1(gb); /* marker */
4165
4166 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
4167 skip_bits(gb, s->time_increment_bits);
4168 }
4169
4170 if (s->shape != BIN_ONLY_SHAPE) {
4171 if (s->shape == RECT_SHAPE) {
4172 skip_bits1(gb); /* marker */
4173 width = get_bits(gb, 13);
4174 skip_bits1(gb); /* marker */
4175 height = get_bits(gb, 13);
4176 skip_bits1(gb); /* marker */
4177 if(width && height){ /* they should be non zero but who knows ... */
4178 s->width = width;
4179 s->height = height;
4180 // printf("width/height: %d %d\n", width, height);
4181 }
4182 }
4183
4184 s->progressive_sequence= get_bits1(gb)^1;
4185 if(!get_bits1(gb)) printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
4186 if (vo_ver_id == 1) {
4187 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4188 } else {
4189 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4190 }
4191 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4192 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4193 if(s->vol_sprite_usage==STATIC_SPRITE){
4194 s->sprite_width = get_bits(gb, 13);
4195 skip_bits1(gb); /* marker */
4196 s->sprite_height= get_bits(gb, 13);
4197 skip_bits1(gb); /* marker */
4198 s->sprite_left = get_bits(gb, 13);
4199 skip_bits1(gb); /* marker */
4200 s->sprite_top = get_bits(gb, 13);
4201 skip_bits1(gb); /* marker */
4202 }
4203 s->num_sprite_warping_points= get_bits(gb, 6);
4204 s->sprite_warping_accuracy = get_bits(gb, 2);
4205 s->sprite_brightness_change= get_bits1(gb);
4206 if(s->vol_sprite_usage==STATIC_SPRITE)
4207 s->low_latency_sprite= get_bits1(gb);
4208 }
4209 // FIXME sadct disable bit if verid!=1 && shape not rect
4210
4211 if (get_bits1(gb) == 1) { /* not_8_bit */
4212 s->quant_precision = get_bits(gb, 4); /* quant_precision */
4213 if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4214 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4215 } else {
4216 s->quant_precision = 5;
4217 }
4218
4219 // FIXME a bunch of grayscale shape things
4220
4221 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4222 int i, j, v;
4223
4224 /* load default matrixes */
4225 for(i=0; i<64; i++){
4226 int j= s->idct_permutation[i];
4227 v= ff_mpeg4_default_intra_matrix[i];
4228 s->intra_matrix[j]= v;
4229 s->chroma_intra_matrix[j]= v;
4230
4231 v= ff_mpeg4_default_non_intra_matrix[i];
4232 s->inter_matrix[j]= v;
4233 s->chroma_inter_matrix[j]= v;
4234 }
4235
4236 /* load custom intra matrix */
4237 if(get_bits1(gb)){
4238 int last=0;
4239 for(i=0; i<64; i++){
4240 v= get_bits(gb, 8);
4241 if(v==0) break;
4242
4243 last= v;
4244 j= s->idct_permutation[ ff_zigzag_direct[i] ];
4245 s->intra_matrix[j]= v;
4246 s->chroma_intra_matrix[j]= v;
4247 }
4248
4249 /* replicate last value */
4250 for(; i<64; i++){
4251 j= s->idct_permutation[ ff_zigzag_direct[i] ];
4252 s->intra_matrix[j]= v;
4253 s->chroma_intra_matrix[j]= v;
4254 }
4255 }
4256
4257 /* load custom non intra matrix */
4258 if(get_bits1(gb)){
4259 int last=0;
4260 for(i=0; i<64; i++){
4261 v= get_bits(gb, 8);
4262 if(v==0) break;
4263
4264 last= v;
4265 j= s->idct_permutation[ ff_zigzag_direct[i] ];
4266 s->inter_matrix[j]= v;
4267 s->chroma_inter_matrix[j]= v;
4268 }
4269
4270 /* replicate last value */
4271 for(; i<64; i++){
4272 j= s->idct_permutation[ ff_zigzag_direct[i] ];
4273 s->inter_matrix[j]= last;
4274 s->chroma_inter_matrix[j]= last;
4275 }
4276 }
4277
4278 // FIXME a bunch of grayscale shape things
4279 }
4280
4281 if(vo_ver_id != 1)
4282 s->quarter_sample= get_bits1(gb);
4283 else s->quarter_sample=0;
4284
4285 if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4286
4287 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4288
4289 s->data_partitioning= get_bits1(gb);
4290 if(s->data_partitioning){
4291 s->rvlc= get_bits1(gb);
4292 if(s->rvlc){
4293 printf("reversible vlc not supported\n");
4294 }
4295 }
4296
4297 if(vo_ver_id != 1) {
4298 s->new_pred= get_bits1(gb);
4299 if(s->new_pred){
4300 printf("new pred not supported\n");
4301 skip_bits(gb, 2); /* requested upstream message type */
4302 skip_bits1(gb); /* newpred segment type */
4303 }
4304 s->reduced_res_vop= get_bits1(gb);
4305 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4306 }
4307 else{
4308 s->new_pred=0;
4309 s->reduced_res_vop= 0;
4310 }
4311
4312 s->scalability= get_bits1(gb);
4313
4314 if (s->scalability) {
4315 GetBitContext bak= *gb;
4316 int ref_layer_id;
4317 int ref_layer_sampling_dir;
4318 int h_sampling_factor_n;
4319 int h_sampling_factor_m;
4320 int v_sampling_factor_n;
4321 int v_sampling_factor_m;
4322
4323 s->hierachy_type= get_bits1(gb);
4324 ref_layer_id= get_bits(gb, 4);
4325 ref_layer_sampling_dir= get_bits1(gb);
4326 h_sampling_factor_n= get_bits(gb, 5);
4327 h_sampling_factor_m= get_bits(gb, 5);
4328 v_sampling_factor_n= get_bits(gb, 5);
4329 v_sampling_factor_m= get_bits(gb, 5);
4330 s->enhancement_type= get_bits1(gb);
4331
4332 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
4333 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4334
4335 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4336 s->scalability=0;
4337
4338 *gb= bak;
4339 }else
4340 printf("scalability not supported\n");
4341
4342 // bin shape stuff FIXME
4343 }
4344 }
4345 return 0;
4346 }
4347
4348 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4349 char buf[256];
4350 int i;
4351 int e;
4352 int ver, build, ver2, ver3;
4353
4354 buf[0]= show_bits(gb, 8);
4355 for(i=1; i<256; i++){
4356 buf[i]= show_bits(gb, 16)&0xFF;
4357 if(buf[i]==0) break;
4358 skip_bits(gb, 8);
4359 }
4360 buf[255]=0;
4361
4362 /* divx detection */
4363 e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
4364 if(e!=2)
4365 e=sscanf(buf, "DivX%db%d", &ver, &build);
4366 if(e==2){
4367 s->divx_version= ver;
4368 s->divx_build= build;
4369 if(s->picture_number==0){
4370 printf("This file was encoded with DivX%d Build%d\n", ver, build);
4371 }
4372 }
4373
4374 /* ffmpeg detection */
4375 e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
4376 if(e!=4)
4377 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
4378 if(e!=4){
4379 if(strcmp(buf, "ffmpeg")==0){
4380 s->ffmpeg_version= 0x000406;
4381 s->lavc_build= 4600;
4382 }
4383 }
4384 if(e==4){
4385 s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4386 s->lavc_build= build;
4387 if(s->picture_number==0)
4388 printf("This file was encoded with libavcodec build %d\n", build);
4389 }
4390
4391 /* xvid detection */
4392 e=sscanf(buf, "XviD%d", &build);
4393 if(e==1){
4394 s->xvid_build= build;
4395 if(s->picture_number==0)
4396 printf("This file was encoded with XviD build %d\n", build);
4397 }
4398
4399 //printf("User Data: %s\n", buf);
4400 return 0;
4401 }
4402
4403 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4404 int time_incr, time_increment;
4405
4406 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
4407 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
4408 printf("low_delay flag set, but shouldnt, clearing it\n");
4409 s->low_delay=0;
4410 }
4411
4412 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4413 if(s->partitioned_frame)
4414 s->decode_mb= mpeg4_decode_partitioned_mb;
4415 else
4416 s->decode_mb= ff_h263_decode_mb;
4417
4418 if(s->time_increment_resolution==0){
4419 s->time_increment_resolution=1;
4420 // fprintf(stderr, "time_increment_resolution is illegal\n");
4421 }
4422 time_incr=0;
4423 while (get_bits1(gb) != 0)
4424 time_incr++;
4425
4426 check_marker(gb, "before time_increment");
4427 time_increment= get_bits(gb, s->time_increment_bits);
4428 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4429 if(s->pict_type!=B_TYPE){
4430 s->last_time_base= s->time_base;
4431 s->time_base+= time_incr;
4432 s->time= s->time_base*s->time_increment_resolution + time_increment;
4433 if(s->workaround_bugs&FF_BUG_UMP4){
4434 if(s->time < s->last_non_b_time){
4435 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4436 s->time_base++;
4437 s->time+= s->time_increment_resolution;
4438 }
4439 }
4440 s->pp_time= s->time - s->last_non_b_time;
4441 s->last_non_b_time= s->time;
4442 }else{
4443 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4444 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4445 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4446 // printf("messed up order, seeking?, skiping current b frame\n");
4447 return FRAME_SKIPED;
4448 }
4449
4450 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4451 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4452 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4453 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
4454 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4455 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
4456 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4457 }
4458
4459 s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4460
4461 if(check_marker(gb, "before vop_coded")==0 && s->picture_number==0){
4462 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4463 for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
4464 if(get_bits1(gb)) break;
4465 }
4466 printf("my guess is %d bits ;)\n",s->time_increment_bits);
4467 }
4468 /* vop coded */
4469 if (get_bits1(gb) != 1){
4470 printf("vop not coded\n");
4471 return FRAME_SKIPED;
4472 }
4473 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4474 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
4475 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4476 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4477 /* rounding type for motion estimation */
4478 s->no_rounding = get_bits1(gb);
4479 } else {
4480 s->no_rounding = 0;
4481 }
4482 //FIXME reduced res stuff
4483
4484 if (s->shape != RECT_SHAPE) {
4485 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4486 int width, height, hor_spat_ref, ver_spat_ref;
4487
4488 width = get_bits(gb, 13);
4489 skip_bits1(gb); /* marker */
4490 height = get_bits(gb, 13);
4491 skip_bits1(gb); /* marker */
4492 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
4493 skip_bits1(gb); /* marker */
4494 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
4495 }
4496 skip_bits1(gb); /* change_CR_disable */
4497
4498 if (get_bits1(gb) != 0) {
4499 skip_bits(gb, 8); /* constant_alpha_value */
4500 }
4501 }
4502 //FIXME complexity estimation stuff
4503
4504 if (s->shape != BIN_ONLY_SHAPE) {
4505 int t;
4506 t=get_bits(gb, 3); /* intra dc VLC threshold */
4507 //printf("threshold %d\n", t);
4508 if(!s->progressive_sequence){
4509 s->top_field_first= get_bits1(gb);
4510 s->alternate_scan= get_bits1(gb);
4511 }else
4512 s->alternate_scan= 0;
4513 }
4514
4515 if(s->alternate_scan){
4516 ff_init_scantable(s, &s->inter_scantable , ff_alternate_vertical_scan);
4517 ff_init_scantable(s, &s->intra_scantable , ff_alternate_vertical_scan);
4518 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
4519 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4520 } else{
4521 ff_init_scantable(s, &s->inter_scantable , ff_zigzag_direct);
4522 ff_init_scantable(s, &s->intra_scantable , ff_zigzag_direct);
4523 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
4524 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4525 }
4526
4527 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
4528 mpeg4_decode_sprite_trajectory(s);
4529 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4530 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
4531 }
4532
4533 if (s->shape != BIN_ONLY_SHAPE) {
4534 s->qscale = get_bits(gb, s->quant_precision);
4535 if(s->qscale==0){
4536 printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
4537 return -1; // makes no sense to continue, as there is nothing left from the image then
4538 }
4539
4540 if (s->pict_type != I_TYPE) {
4541 s->f_code = get_bits(gb, 3); /* fcode_for */
4542 if(s->f_code==0){
4543 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
4544 return -1; // makes no sense to continue, as the MV decoding will break very quickly
4545 }
4546 }else
4547 s->f_code=1;
4548
4549 if (s->pict_type == B_TYPE) {
4550 s->b_code = get_bits(gb, 3);
4551 }else
4552 s->b_code=1;
4553
4554 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4555 printf("qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d\n",
4556 s->qscale, s->f_code, s->b_code,
4557 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
4558 gb->size,s->progressive_sequence, s->alternate_scan, s->top_field_first,
4559 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
4560 s->sprite_warping_accuracy);
4561 }
4562
4563 if(!s->scalability){
4564 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
4565 skip_bits1(gb); // vop shape coding type
4566 }
4567 }else{
4568 if(s->enhancement_type){
4569 int load_backward_shape= get_bits1(gb);
4570 if(load_backward_shape){
4571 printf("load backward shape isnt supported\n");
4572 }
4573 }
4574 skip_bits(gb, 2); //ref_select_code
4575 }
4576 }
4577 /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
4578 // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
4579 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
4580 printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
4581 s->low_delay=1;
4582 }
4583
4584 s->picture_number++; // better than pic number==0 allways ;)
4585
4586 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
4587 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
4588
4589 if(s->divx_version==0 || s->divx_version < 500){
4590 s->h_edge_pos= s->width;
4591 s->v_edge_pos= s->height;
4592 }
4593 return 0;
4594 }
4595
4596 /**
4597 * decode mpeg4 headers
4598 * @return <0 if no VOP found (or a damaged one)
4599 * FRAME_SKIPPED if a not coded VOP is found
4600 * 0 if a VOP is found
4601 */
4602 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
4603 {
4604 int startcode, v;
4605
4606 /* search next start code */
4607 align_get_bits(gb);
4608 startcode = 0xff;
4609 for(;;) {
4610 v = get_bits(gb, 8);
4611 startcode = ((startcode << 8) | v) & 0xffffffff;
4612
4613 if(get_bits_count(gb) >= gb->size*8){
4614 if(gb->size==1 && s->divx_version){
4615 printf("frame skip %d\n", gb->size);
4616 return FRAME_SKIPED; //divx bug
4617 }else
4618 return -1; //end of stream
4619 }
4620
4621 if((startcode&0xFFFFFF00) != 0x100)
4622 continue; //no startcode
4623
4624 switch(startcode){
4625 case 0x120:
4626 decode_vol_header(s, gb);
4627 break;
4628 case 0x1b2:
4629 decode_user_data(s, gb);
4630 break;
4631 case 0x1b6:
4632 return decode_vop_header(s, gb);
4633 default:
4634 // printf("startcode %X found\n", startcode);
4635 break;
4636 }
4637
4638 align_get_bits(gb);
4639 startcode = 0xff;
4640 }
4641 }
4642
4643 /* don't understand why they choose a different header ! */
4644 int intel_h263_decode_picture_header(MpegEncContext *s)
4645 {
4646 int format;
4647
4648 /* picture header */
4649 if (get_bits(&s->gb, 22) != 0x20) {
4650 fprintf(stderr, "Bad picture start code\n");
4651 return -1;
4652 }
4653 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4654
4655 if (get_bits1(&s->gb) != 1) {
4656 fprintf(stderr, "Bad marker\n");
4657 return -1; /* marker */
4658 }
4659 if (get_bits1(&s->gb) != 0) {
4660 fprintf(stderr, "Bad H263 id\n");
4661 return -1; /* h263 id */
4662 }
4663 skip_bits1(&s->gb); /* split screen off */
4664 skip_bits1(&s->gb); /* camera off */
4665 skip_bits1(&s->gb); /* freeze picture release off */
4666
4667 format = get_bits(&s->gb, 3);
4668 if (format != 7) {
4669 fprintf(stderr, "Intel H263 free format not supported\n");
4670 return -1;
4671 }
4672 s->h263_plus = 0;
4673
4674 s->pict_type = I_TYPE + get_bits1(&s->gb);
4675
4676 s->unrestricted_mv = get_bits1(&s->gb);
4677 s->h263_long_vectors = s->unrestricted_mv;
4678
4679 if (get_bits1(&s->gb) != 0) {
4680 fprintf(stderr, "SAC not supported\n");
4681 return -1; /* SAC: off */
4682 }
4683 if (get_bits1(&s->gb) != 0) {
4684 fprintf(stderr, "Advanced Prediction Mode not supported\n");
4685 return -1; /* advanced prediction mode: off */
4686 }
4687 if (get_bits1(&s->gb) != 0) {
4688 fprintf(stderr, "PB frame mode no supported\n");
4689 return -1; /* PB frame mode */
4690 }
4691
4692 /* skip unknown header garbage */
4693 skip_bits(&s->gb, 41);
4694
4695 s->qscale = get_bits(&s->gb, 5);
4696 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
4697
4698 /* PEI */
4699 while (get_bits1(&s->gb) != 0) {
4700 skip_bits(&s->gb, 8);
4701 }
4702 s->f_code = 1;
4703
4704 s->y_dc_scale_table=
4705 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4706
4707 return 0;
4708 }
4709
mob repository