Mercurial > libavcodec.hg
comparison h263.c @ 453:69876443a723 libavcodec
error concealment / error resilience
data partitioning encoding/decoding
resync marker encoding
more correct headers
merging s->first_gob_line & s->first_slice_line
author | michaelni |
---|---|
date | Sun, 02 Jun 2002 12:15:17 +0000 |
parents | 718a22dc121f |
children | 1e23eae32087 |
comparison
equal
deleted
inserted
replaced
452:297eed976b20 | 453:69876443a723 |
---|---|
29 #include "h263data.h" | 29 #include "h263data.h" |
30 #include "mpeg4data.h" | 30 #include "mpeg4data.h" |
31 | 31 |
32 //rounded divison & shift | 32 //rounded divison & shift |
33 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b)) | 33 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b)) |
34 #define MAX(a,b) ((a) > (b) ? (a) : (b)) | |
35 #define MIN(a,b) ((a) < (b) ? (a) : (b)) | |
36 | 34 |
37 #define PRINT_MB_TYPE(a) ; | 35 #define PRINT_MB_TYPE(a) ; |
38 //#define PRINT_MB_TYPE(a) printf(a); | 36 //#define PRINT_MB_TYPE(a) printf(a); |
39 | 37 |
40 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, | 38 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, |
41 int n); | 39 int n); |
42 static void h263_encode_motion(MpegEncContext * s, int val, int fcode); | 40 static void h263_encode_motion(MpegEncContext * s, int val, int fcode); |
43 static void h263p_encode_umotion(MpegEncContext * s, int val); | 41 static void h263p_encode_umotion(MpegEncContext * s, int val); |
44 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, | 42 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, |
45 int n, int dc, UINT8 *scan_table); | 43 int n, int dc, UINT8 *scan_table, |
44 PutBitContext *dc_pb, PutBitContext *ac_pb); | |
46 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); | 45 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); |
47 static int h263p_decode_umotion(MpegEncContext * s, int pred); | 46 static int h263p_decode_umotion(MpegEncContext * s, int pred); |
48 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, | 47 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
49 int n, int coded); | 48 int n, int coded); |
50 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | 49 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
50 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
51 int n, int coded); | 51 int n, int coded); |
52 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr); | 52 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr); |
53 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr); | 53 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr); |
54 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n, | 54 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n, |
55 int dir); | 55 int dir); |
263 DCTELEM block[6][64], | 263 DCTELEM block[6][64], |
264 int motion_x, int motion_y) | 264 int motion_x, int motion_y) |
265 { | 265 { |
266 int cbpc, cbpy, i, pred_x, pred_y; | 266 int cbpc, cbpy, i, pred_x, pred_y; |
267 int bits; | 267 int bits; |
268 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; | |
269 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb; | |
270 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb; | |
271 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0; | |
268 | 272 |
269 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); | 273 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
270 if (!s->mb_intra) { | 274 if (!s->mb_intra) { |
271 /* compute cbp */ | 275 /* compute cbp */ |
272 int cbp = 0; | 276 int cbp = 0; |
298 } | 302 } |
299 | 303 |
300 if ((cbp | motion_x | motion_y | mb_type) ==0) { | 304 if ((cbp | motion_x | motion_y | mb_type) ==0) { |
301 /* direct MB with MV={0,0} */ | 305 /* direct MB with MV={0,0} */ |
302 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ | 306 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ |
303 s->misc_bits++; | 307 |
304 s->last_bits++; | 308 if(interleaved_stats){ |
309 s->misc_bits++; | |
310 s->last_bits++; | |
311 } | |
305 s->skip_count++; | 312 s->skip_count++; |
306 return; | 313 return; |
307 } | 314 } |
308 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ | 315 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
309 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge | 316 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge |
311 if(cbp) put_bits(&s->pb, 6, cbp); | 318 if(cbp) put_bits(&s->pb, 6, cbp); |
312 | 319 |
313 if(cbp && mb_type) | 320 if(cbp && mb_type) |
314 put_bits(&s->pb, 1, 0); /* no q-scale change */ | 321 put_bits(&s->pb, 1, 0); /* no q-scale change */ |
315 | 322 |
316 bits= get_bit_count(&s->pb); | 323 if(interleaved_stats){ |
317 s->misc_bits+= bits - s->last_bits; | 324 bits= get_bit_count(&s->pb); |
318 s->last_bits=bits; | 325 s->misc_bits+= bits - s->last_bits; |
326 s->last_bits=bits; | |
327 } | |
319 | 328 |
320 switch(mb_type) | 329 switch(mb_type) |
321 { | 330 { |
322 case 0: /* direct */ | 331 case 0: /* direct */ |
323 h263_encode_motion(s, motion_x, 1); | 332 h263_encode_motion(s, motion_x, 1); |
347 break; | 356 break; |
348 default: | 357 default: |
349 printf("unknown mb type\n"); | 358 printf("unknown mb type\n"); |
350 return; | 359 return; |
351 } | 360 } |
352 bits= get_bit_count(&s->pb); | 361 |
353 s->mv_bits+= bits - s->last_bits; | 362 if(interleaved_stats){ |
354 s->last_bits=bits; | 363 bits= get_bit_count(&s->pb); |
364 s->mv_bits+= bits - s->last_bits; | |
365 s->last_bits=bits; | |
366 } | |
355 | 367 |
356 /* encode each block */ | 368 /* encode each block */ |
357 for (i = 0; i < 6; i++) { | 369 for (i = 0; i < 6; i++) { |
358 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct); | 370 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, &s->pb); |
359 } | 371 } |
360 bits= get_bit_count(&s->pb); | 372 |
361 s->p_tex_bits+= bits - s->last_bits; | 373 if(interleaved_stats){ |
362 s->last_bits=bits; | 374 bits= get_bit_count(&s->pb); |
375 s->p_tex_bits+= bits - s->last_bits; | |
376 s->last_bits=bits; | |
377 } | |
363 }else{ /* s->pict_type==B_TYPE */ | 378 }else{ /* s->pict_type==B_TYPE */ |
364 if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) { | 379 if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) { |
365 /* check if the B frames can skip it too, as we must skip it if we skip here | 380 /* check if the B frames can skip it too, as we must skip it if we skip here |
366 why didnt they just compress the skip-mb bits instead of reusing them ?! */ | 381 why didnt they just compress the skip-mb bits instead of reusing them ?! */ |
367 if(s->max_b_frames>0){ | 382 if(s->max_b_frames>0){ |
395 s->mb_skiped=1; | 410 s->mb_skiped=1; |
396 | 411 |
397 if(s->mb_skiped==1){ | 412 if(s->mb_skiped==1){ |
398 /* skip macroblock */ | 413 /* skip macroblock */ |
399 put_bits(&s->pb, 1, 1); | 414 put_bits(&s->pb, 1, 1); |
400 s->misc_bits++; | 415 |
401 s->last_bits++; | 416 if(interleaved_stats){ |
417 s->misc_bits++; | |
418 s->last_bits++; | |
419 } | |
402 s->skip_count++; | 420 s->skip_count++; |
403 return; | 421 return; |
404 } | 422 } |
405 } | 423 } |
406 | 424 |
410 put_bits(&s->pb, | 428 put_bits(&s->pb, |
411 inter_MCBPC_bits[cbpc], | 429 inter_MCBPC_bits[cbpc], |
412 inter_MCBPC_code[cbpc]); | 430 inter_MCBPC_code[cbpc]); |
413 cbpy = cbp >> 2; | 431 cbpy = cbp >> 2; |
414 cbpy ^= 0xf; | 432 cbpy ^= 0xf; |
415 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | 433 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
416 | 434 |
417 bits= get_bit_count(&s->pb); | 435 if(interleaved_stats){ |
418 s->misc_bits+= bits - s->last_bits; | 436 bits= get_bit_count(&s->pb); |
419 s->last_bits=bits; | 437 s->misc_bits+= bits - s->last_bits; |
438 s->last_bits=bits; | |
439 } | |
420 | 440 |
421 /* motion vectors: 16x16 mode */ | 441 /* motion vectors: 16x16 mode */ |
422 h263_pred_motion(s, 0, &pred_x, &pred_y); | 442 h263_pred_motion(s, 0, &pred_x, &pred_y); |
423 | 443 |
424 h263_encode_motion(s, motion_x - pred_x, s->f_code); | 444 h263_encode_motion(s, motion_x - pred_x, s->f_code); |
428 put_bits(&s->pb, | 448 put_bits(&s->pb, |
429 inter_MCBPC_bits[cbpc], | 449 inter_MCBPC_bits[cbpc], |
430 inter_MCBPC_code[cbpc]); | 450 inter_MCBPC_code[cbpc]); |
431 cbpy = cbp >> 2; | 451 cbpy = cbp >> 2; |
432 cbpy ^= 0xf; | 452 cbpy ^= 0xf; |
433 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | 453 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
434 | 454 |
435 bits= get_bit_count(&s->pb); | 455 if(interleaved_stats){ |
436 s->misc_bits+= bits - s->last_bits; | 456 bits= get_bit_count(&s->pb); |
437 s->last_bits=bits; | 457 s->misc_bits+= bits - s->last_bits; |
458 s->last_bits=bits; | |
459 } | |
438 | 460 |
439 for(i=0; i<4; i++){ | 461 for(i=0; i<4; i++){ |
440 /* motion vectors: 8x8 mode*/ | 462 /* motion vectors: 8x8 mode*/ |
441 h263_pred_motion(s, i, &pred_x, &pred_y); | 463 h263_pred_motion(s, i, &pred_x, &pred_y); |
442 | 464 |
443 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code); | 465 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code); |
444 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code); | 466 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code); |
445 } | 467 } |
446 } | 468 } |
447 bits= get_bit_count(&s->pb); | 469 |
448 s->mv_bits+= bits - s->last_bits; | 470 if(interleaved_stats){ |
449 s->last_bits=bits; | 471 bits= get_bit_count(&s->pb); |
472 s->mv_bits+= bits - s->last_bits; | |
473 s->last_bits=bits; | |
474 } | |
450 | 475 |
451 /* encode each block */ | 476 /* encode each block */ |
452 for (i = 0; i < 6; i++) { | 477 for (i = 0; i < 6; i++) { |
453 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct); | 478 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, tex_pb); |
454 } | 479 } |
455 bits= get_bit_count(&s->pb); | 480 |
456 s->p_tex_bits+= bits - s->last_bits; | 481 if(interleaved_stats){ |
457 s->last_bits=bits; | 482 bits= get_bit_count(&s->pb); |
483 s->p_tex_bits+= bits - s->last_bits; | |
484 s->last_bits=bits; | |
485 } | |
458 s->p_count++; | 486 s->p_count++; |
459 } | 487 } |
460 } else { | 488 } else { |
461 int cbp; | 489 int cbp; |
462 int dc_diff[6]; //dc values with the dc prediction subtracted | 490 int dc_diff[6]; //dc values with the dc prediction subtracted |
514 put_bits(&s->pb, 1, 0); /* mb coded */ | 542 put_bits(&s->pb, 1, 0); /* mb coded */ |
515 put_bits(&s->pb, | 543 put_bits(&s->pb, |
516 inter_MCBPC_bits[cbpc + 4], | 544 inter_MCBPC_bits[cbpc + 4], |
517 inter_MCBPC_code[cbpc + 4]); | 545 inter_MCBPC_code[cbpc + 4]); |
518 } | 546 } |
519 put_bits(&s->pb, 1, s->ac_pred); | 547 put_bits(pb2, 1, s->ac_pred); |
520 cbpy = cbp >> 2; | 548 cbpy = cbp >> 2; |
521 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | 549 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
522 | 550 |
523 bits= get_bit_count(&s->pb); | 551 if(interleaved_stats){ |
524 s->misc_bits+= bits - s->last_bits; | 552 bits= get_bit_count(&s->pb); |
525 s->last_bits=bits; | 553 s->misc_bits+= bits - s->last_bits; |
554 s->last_bits=bits; | |
555 } | |
526 | 556 |
527 /* encode each block */ | 557 /* encode each block */ |
528 for (i = 0; i < 6; i++) { | 558 for (i = 0; i < 6; i++) { |
529 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]); | 559 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb); |
530 } | 560 } |
531 | 561 |
532 bits= get_bit_count(&s->pb); | 562 if(interleaved_stats){ |
533 s->i_tex_bits+= bits - s->last_bits; | 563 bits= get_bit_count(&s->pb); |
534 s->last_bits=bits; | 564 s->i_tex_bits+= bits - s->last_bits; |
565 s->last_bits=bits; | |
566 } | |
535 s->i_count++; | 567 s->i_count++; |
536 | 568 |
537 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ | 569 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ |
538 if(s->ac_pred){ | 570 if(s->ac_pred){ |
539 for(i=0; i<6; i++){ | 571 for(i=0; i<6; i++){ |
703 */ | 735 */ |
704 a = dc_val[(x - 1) + (y) * wrap]; | 736 a = dc_val[(x - 1) + (y) * wrap]; |
705 c = dc_val[(x) + (y - 1) * wrap]; | 737 c = dc_val[(x) + (y - 1) * wrap]; |
706 | 738 |
707 /* No prediction outside GOB boundary */ | 739 /* No prediction outside GOB boundary */ |
708 if (s->first_gob_line && ((n < 2) || (n > 3))) | 740 if (s->first_slice_line && ((n < 2) || (n > 3))) |
709 c = 1024; | 741 c = 1024; |
710 pred_dc = 1024; | 742 pred_dc = 1024; |
711 /* just DC prediction */ | 743 /* just DC prediction */ |
712 if (a != 1024 && c != 1024) | 744 if (a != 1024 && c != 1024) |
713 pred_dc = (a + c) >> 1; | 745 pred_dc = (a + c) >> 1; |
753 */ | 785 */ |
754 a = dc_val[(x - 1) + (y) * wrap]; | 786 a = dc_val[(x - 1) + (y) * wrap]; |
755 c = dc_val[(x) + (y - 1) * wrap]; | 787 c = dc_val[(x) + (y - 1) * wrap]; |
756 | 788 |
757 /* No prediction outside GOB boundary */ | 789 /* No prediction outside GOB boundary */ |
758 if (s->first_gob_line && ((n < 2) || (n > 3))) | 790 if (s->first_slice_line && ((n < 2) || (n > 3))) |
759 c = 1024; | 791 c = 1024; |
760 pred_dc = 1024; | 792 pred_dc = 1024; |
761 if (s->ac_pred) { | 793 if (s->ac_pred) { |
762 if (s->h263_aic_dir) { | 794 if (s->h263_aic_dir) { |
763 /* left prediction */ | 795 /* left prediction */ |
817 wrap = s->block_wrap[0]; | 849 wrap = s->block_wrap[0]; |
818 xy = s->block_index[block]; | 850 xy = s->block_index[block]; |
819 | 851 |
820 mot_val = s->motion_val[xy]; | 852 mot_val = s->motion_val[xy]; |
821 | 853 |
822 /* special case for first line */ | 854 A = s->motion_val[xy - 1]; |
823 if ((s->mb_y == 0 || s->first_slice_line || s->first_gob_line) && block<2) { | 855 /* special case for first (slice) line */ |
824 A = s->motion_val[xy - 1]; | 856 if ((s->mb_y == 0 || s->first_slice_line) && block<3) { |
825 *px = A[0]; | 857 // we cant just change some MVs to simulate that as we need them for the B frames (and ME) |
826 *py = A[1]; | 858 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( |
859 if(block==0){ //most common case | |
860 if(s->mb_x == s->resync_mb_x){ //rare | |
861 *px= *py = 0; | |
862 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare | |
863 C = s->motion_val[xy + off[block] - wrap]; | |
864 if(s->mb_x==0){ | |
865 *px = C[0]; | |
866 *py = C[1]; | |
867 }else{ | |
868 *px = mid_pred(A[0], 0, C[0]); | |
869 *py = mid_pred(A[1], 0, C[1]); | |
870 } | |
871 }else{ | |
872 *px = A[0]; | |
873 *py = A[1]; | |
874 } | |
875 }else if(block==1){ | |
876 if(s->mb_x + 1 == s->resync_mb_x){ //rare | |
877 C = s->motion_val[xy + off[block] - wrap]; | |
878 *px = mid_pred(A[0], 0, C[0]); | |
879 *py = mid_pred(A[1], 0, C[1]); | |
880 }else{ | |
881 *px = A[0]; | |
882 *py = A[1]; | |
883 } | |
884 }else{ /* block==2*/ | |
885 B = s->motion_val[xy - wrap]; | |
886 C = s->motion_val[xy + off[block] - wrap]; | |
887 if(s->mb_x == s->resync_mb_x) //rare | |
888 A[0]=A[1]=0; | |
889 | |
890 *px = mid_pred(A[0], B[0], C[0]); | |
891 *py = mid_pred(A[1], B[1], C[1]); | |
892 } | |
827 } else { | 893 } else { |
828 A = s->motion_val[xy - 1]; | |
829 B = s->motion_val[xy - wrap]; | 894 B = s->motion_val[xy - wrap]; |
830 C = s->motion_val[xy + off[block] - wrap]; | 895 C = s->motion_val[xy + off[block] - wrap]; |
831 *px = mid_pred(A[0], B[0], C[0]); | 896 *px = mid_pred(A[0], B[0], C[0]); |
832 *py = mid_pred(A[1], B[1], C[1]); | 897 *py = mid_pred(A[1], B[1], C[1]); |
833 } | 898 } |
1103 } | 1168 } |
1104 } | 1169 } |
1105 | 1170 |
1106 /***************************************************/ | 1171 /***************************************************/ |
1107 | 1172 |
1108 static void mpeg4_stuffing(PutBitContext * pbc) | 1173 void ff_mpeg4_stuffing(PutBitContext * pbc) |
1109 { | 1174 { |
1110 int length; | 1175 int length; |
1111 put_bits(pbc, 1, 0); | 1176 put_bits(pbc, 1, 0); |
1112 length= (-get_bit_count(pbc))&7; | 1177 length= (-get_bit_count(pbc))&7; |
1113 put_bits(pbc, length, (1<<length)-1); | 1178 if(length) put_bits(pbc, length, (1<<length)-1); |
1114 } | 1179 } |
1115 | 1180 |
1116 /* must be called before writing the header */ | 1181 /* must be called before writing the header */ |
1117 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ | 1182 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ |
1118 int time_div, time_mod; | 1183 int time_div, time_mod; |
1143 int vo_ver_id=1; //must be 2 if we want GMC or q-pel | 1208 int vo_ver_id=1; //must be 2 if we want GMC or q-pel |
1144 char buf[255]; | 1209 char buf[255]; |
1145 | 1210 |
1146 s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE; | 1211 s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE; |
1147 | 1212 |
1148 if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb); | |
1149 put_bits(&s->pb, 16, 0); | 1213 put_bits(&s->pb, 16, 0); |
1150 put_bits(&s->pb, 16, 0x100); /* video obj */ | 1214 put_bits(&s->pb, 16, 0x100); /* video obj */ |
1151 put_bits(&s->pb, 16, 0); | 1215 put_bits(&s->pb, 16, 0); |
1152 put_bits(&s->pb, 16, 0x120); /* video obj layer */ | 1216 put_bits(&s->pb, 16, 0x120); /* video obj layer */ |
1153 | 1217 |
1193 put_bits(&s->pb, 1, 0); /* not 8 bit */ | 1257 put_bits(&s->pb, 1, 0); /* not 8 bit */ |
1194 put_bits(&s->pb, 1, 0); /* quant type= h263 style*/ | 1258 put_bits(&s->pb, 1, 0); /* quant type= h263 style*/ |
1195 if (vo_ver_id != 1) | 1259 if (vo_ver_id != 1) |
1196 put_bits(&s->pb, 1, s->quarter_sample=0); | 1260 put_bits(&s->pb, 1, s->quarter_sample=0); |
1197 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ | 1261 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
1198 put_bits(&s->pb, 1, 1); /* resync marker disable */ | 1262 s->resync_marker= s->rtp_mode; |
1199 put_bits(&s->pb, 1, 0); /* data partitioned */ | 1263 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ |
1264 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | |
1265 if(s->data_partitioning){ | |
1266 put_bits(&s->pb, 1, 0); /* no rvlc */ | |
1267 } | |
1268 | |
1200 if (vo_ver_id != 1){ | 1269 if (vo_ver_id != 1){ |
1201 put_bits(&s->pb, 1, 0); /* newpred */ | 1270 put_bits(&s->pb, 1, 0); /* newpred */ |
1202 put_bits(&s->pb, 1, 0); /* reduced res vop */ | 1271 put_bits(&s->pb, 1, 0); /* reduced res vop */ |
1203 } | 1272 } |
1204 put_bits(&s->pb, 1, 0); /* scalability */ | 1273 put_bits(&s->pb, 1, 0); /* scalability */ |
1205 | 1274 |
1206 mpeg4_stuffing(&s->pb); | 1275 ff_mpeg4_stuffing(&s->pb); |
1207 put_bits(&s->pb, 16, 0); | 1276 put_bits(&s->pb, 16, 0); |
1208 put_bits(&s->pb, 16, 0x1B2); /* user_data */ | 1277 put_bits(&s->pb, 16, 0x1B2); /* user_data */ |
1209 sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR); | 1278 sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR); |
1210 put_string(&s->pb, buf); | 1279 put_string(&s->pb, buf); |
1211 | 1280 |
1212 s->no_rounding = 0; | 1281 ff_mpeg4_stuffing(&s->pb); |
1213 } | 1282 } |
1214 | 1283 |
1215 /* write mpeg4 VOP header */ | 1284 /* write mpeg4 VOP header */ |
1216 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | 1285 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) |
1217 { | 1286 { |
1218 int time_incr; | 1287 int time_incr; |
1219 int time_div, time_mod; | 1288 int time_div, time_mod; |
1220 | 1289 |
1221 if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s); | 1290 if(s->pict_type==I_TYPE){ |
1291 s->no_rounding=0; | |
1292 if(picture_number==0 || !s->strict_std_compliance) | |
1293 mpeg4_encode_vol_header(s); | |
1294 } | |
1222 | 1295 |
1223 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE); | 1296 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE); |
1224 | 1297 |
1225 if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb); | |
1226 put_bits(&s->pb, 16, 0); /* vop header */ | 1298 put_bits(&s->pb, 16, 0); /* vop header */ |
1227 put_bits(&s->pb, 16, 0x1B6); /* vop header */ | 1299 put_bits(&s->pb, 16, 0x1B6); /* vop header */ |
1228 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ | 1300 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ |
1229 | 1301 |
1230 time_div= s->time/s->time_increment_resolution; | 1302 time_div= s->time/s->time_increment_resolution; |
1392 block[block_permute_op(i)] -= ac_val[i + 8]; | 1464 block[block_permute_op(i)] -= ac_val[i + 8]; |
1393 } | 1465 } |
1394 } | 1466 } |
1395 } | 1467 } |
1396 | 1468 |
1397 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n) | 1469 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n) |
1398 { | 1470 { |
1399 #if 1 | 1471 #if 1 |
1472 // if(level<-255 || level>255) printf("dc overflow\n"); | |
1400 level+=256; | 1473 level+=256; |
1401 if (n < 4) { | 1474 if (n < 4) { |
1402 /* luminance */ | 1475 /* luminance */ |
1403 put_bits(&s->pb, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]); | 1476 put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]); |
1404 } else { | 1477 } else { |
1405 /* chrominance */ | 1478 /* chrominance */ |
1406 put_bits(&s->pb, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]); | 1479 put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]); |
1407 } | 1480 } |
1408 #else | 1481 #else |
1409 int size, v; | 1482 int size, v; |
1410 /* find number of bits */ | 1483 /* find number of bits */ |
1411 size = 0; | 1484 size = 0; |
1432 put_bits(&s->pb, 1, 1); | 1505 put_bits(&s->pb, 1, 1); |
1433 } | 1506 } |
1434 #endif | 1507 #endif |
1435 } | 1508 } |
1436 | 1509 |
1437 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table) | 1510 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1511 UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) | |
1438 { | 1512 { |
1439 int level, run, last, i, j, last_index, last_non_zero, sign, slevel; | 1513 int level, run, last, i, j, last_index, last_non_zero, sign, slevel; |
1440 int code; | 1514 int code; |
1441 const RLTable *rl; | 1515 const RLTable *rl; |
1442 | 1516 |
1443 if (s->mb_intra) { | 1517 if (s->mb_intra) { |
1444 /* mpeg4 based DC predictor */ | 1518 /* mpeg4 based DC predictor */ |
1445 mpeg4_encode_dc(s, intra_dc, n); | 1519 mpeg4_encode_dc(dc_pb, intra_dc, n); |
1446 i = 1; | 1520 i = 1; |
1447 rl = &rl_intra; | 1521 rl = &rl_intra; |
1448 } else { | 1522 } else { |
1449 i = 0; | 1523 i = 0; |
1450 rl = &rl_inter; | 1524 rl = &rl_inter; |
1464 if (level < 0) { | 1538 if (level < 0) { |
1465 sign = 1; | 1539 sign = 1; |
1466 level = -level; | 1540 level = -level; |
1467 } | 1541 } |
1468 code = get_rl_index(rl, last, run, level); | 1542 code = get_rl_index(rl, last, run, level); |
1469 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | 1543 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
1470 if (code == rl->n) { | 1544 if (code == rl->n) { |
1471 int level1, run1; | 1545 int level1, run1; |
1472 level1 = level - rl->max_level[last][run]; | 1546 level1 = level - rl->max_level[last][run]; |
1473 if (level1 < 1) | 1547 if (level1 < 1) |
1474 goto esc2; | 1548 goto esc2; |
1475 code = get_rl_index(rl, last, run, level1); | 1549 code = get_rl_index(rl, last, run, level1); |
1476 if (code == rl->n) { | 1550 if (code == rl->n) { |
1477 esc2: | 1551 esc2: |
1478 put_bits(&s->pb, 1, 1); | 1552 put_bits(ac_pb, 1, 1); |
1479 if (level > MAX_LEVEL) | 1553 if (level > MAX_LEVEL) |
1480 goto esc3; | 1554 goto esc3; |
1481 run1 = run - rl->max_run[last][level] - 1; | 1555 run1 = run - rl->max_run[last][level] - 1; |
1482 if (run1 < 0) | 1556 if (run1 < 0) |
1483 goto esc3; | 1557 goto esc3; |
1484 code = get_rl_index(rl, last, run1, level); | 1558 code = get_rl_index(rl, last, run1, level); |
1485 if (code == rl->n) { | 1559 if (code == rl->n) { |
1486 esc3: | 1560 esc3: |
1487 /* third escape */ | 1561 /* third escape */ |
1488 put_bits(&s->pb, 1, 1); | 1562 put_bits(ac_pb, 1, 1); |
1489 put_bits(&s->pb, 1, last); | 1563 put_bits(ac_pb, 1, last); |
1490 put_bits(&s->pb, 6, run); | 1564 put_bits(ac_pb, 6, run); |
1491 put_bits(&s->pb, 1, 1); | 1565 put_bits(ac_pb, 1, 1); |
1492 put_bits(&s->pb, 12, slevel & 0xfff); | 1566 put_bits(ac_pb, 12, slevel & 0xfff); |
1493 put_bits(&s->pb, 1, 1); | 1567 put_bits(ac_pb, 1, 1); |
1494 } else { | 1568 } else { |
1495 /* second escape */ | 1569 /* second escape */ |
1496 put_bits(&s->pb, 1, 0); | 1570 put_bits(ac_pb, 1, 0); |
1497 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | 1571 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
1498 put_bits(&s->pb, 1, sign); | 1572 put_bits(ac_pb, 1, sign); |
1499 } | 1573 } |
1500 } else { | 1574 } else { |
1501 /* first escape */ | 1575 /* first escape */ |
1502 put_bits(&s->pb, 1, 0); | 1576 put_bits(ac_pb, 1, 0); |
1503 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | 1577 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
1504 put_bits(&s->pb, 1, sign); | 1578 put_bits(ac_pb, 1, sign); |
1505 } | 1579 } |
1506 } else { | 1580 } else { |
1507 put_bits(&s->pb, 1, sign); | 1581 put_bits(ac_pb, 1, sign); |
1508 } | 1582 } |
1509 last_non_zero = i; | 1583 last_non_zero = i; |
1510 } | 1584 } |
1511 } | 1585 } |
1512 } | 1586 } |
1642 int i; | 1716 int i; |
1643 for(i=0;i<n;i++) | 1717 for(i=0;i<n;i++) |
1644 tab[i] = val; | 1718 tab[i] = val; |
1645 } | 1719 } |
1646 | 1720 |
1647 static int mpeg4_resync(MpegEncContext *s) | 1721 void ff_mpeg4_init_partitions(MpegEncContext *s) |
1648 { | 1722 { |
1649 int state, v, bits; | 1723 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL); |
1724 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL); | |
1725 } | |
1726 | |
1727 void ff_mpeg4_merge_partitions(MpegEncContext *s) | |
1728 { | |
1729 const int pb2_len = get_bit_count(&s->pb2 ); | |
1730 const int tex_pb_len= get_bit_count(&s->tex_pb); | |
1731 const int bits= get_bit_count(&s->pb); | |
1732 | |
1733 if(s->pict_type==I_TYPE){ | |
1734 put_bits(&s->pb, 19, DC_MARKER); | |
1735 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | |
1736 s->i_tex_bits+= tex_pb_len; | |
1737 }else{ | |
1738 put_bits(&s->pb, 17, MOTION_MARKER); | |
1739 s->misc_bits+=17 + pb2_len;; | |
1740 s->mv_bits+= bits - s->last_bits; | |
1741 s->p_tex_bits+= tex_pb_len; | |
1742 } | |
1743 | |
1744 flush_put_bits(&s->pb2); | |
1745 flush_put_bits(&s->tex_pb); | |
1746 | |
1747 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len); | |
1748 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len); | |
1749 s->last_bits= get_bit_count(&s->pb); | |
1750 } | |
1751 | |
1752 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) | |
1753 { | |
1754 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
1755 | |
1756 ff_mpeg4_stuffing(&s->pb); | |
1757 if(s->pict_type==I_TYPE) | |
1758 put_bits(&s->pb, 16, 0); | |
1759 else if(s->pict_type==B_TYPE) | |
1760 put_bits(&s->pb, MAX(MAX(s->f_code, s->b_code)+15, 17), 0); | |
1761 else /* S/P_TYPE */ | |
1762 put_bits(&s->pb, s->f_code+15, 0); | |
1763 put_bits(&s->pb, 1, 1); | |
1764 | |
1765 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width); | |
1766 put_bits(&s->pb, 5, s->qscale); | |
1767 put_bits(&s->pb, 1, 0); /* no HEC */ | |
1768 } | |
1769 | |
1770 /** | |
1771 * decodes the next video packet and sets s->next_qscale | |
1772 * returns mb_num of the next packet or <0 if something went wrong | |
1773 */ | |
1774 static int decode_video_packet_header(MpegEncContext *s, GetBitContext *gb) | |
1775 { | |
1776 int bits; | |
1650 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | 1777 int mb_num_bits= av_log2(s->mb_num - 1) + 1; |
1651 int header_extension=0, mb_num; | 1778 int header_extension=0, mb_num; |
1652 int c_wrap, c_xy, l_wrap, l_xy; | 1779 //printf("%X\n", show_bits(&gb, 24)); |
1653 int time_increment; | 1780 //printf("parse_video_packet_header\n"); |
1781 // if(show_aligned_bits(gb, 1, 16) != 0) return -1; | |
1782 | |
1783 /* is there enough space left for a video packet + header */ | |
1784 if( get_bits_count(gb) > gb->size*8-20) return -1; | |
1785 | |
1654 //printf("resync at %d %d\n", s->mb_x, s->mb_y); | 1786 //printf("resync at %d %d\n", s->mb_x, s->mb_y); |
1655 //printf("%X\n", show_bits(&s->gb, 24)); | 1787 // skip_bits(gb, 1); |
1656 | 1788 // align_get_bits(gb); |
1657 if( get_bits_count(&s->gb) > s->gb.size*8-32) | 1789 if(get_bits(gb, 16)!=0){ |
1658 return 0; | 1790 printf("internal error while decoding video packet header\n"); |
1659 | 1791 } |
1660 align_get_bits(&s->gb); | 1792 |
1661 state = 0xff; | 1793 //printf("%X\n", show_bits(gb, 24)); |
1662 for(;;) { | 1794 bits=0; |
1663 v = get_bits(&s->gb, 8); | 1795 while(!get_bits1(gb) && bits<30) bits++; |
1664 //printf("%X ", v); | 1796 if((s->pict_type == P_TYPE || s->pict_type == S_TYPE) && bits != s->f_code-1){ |
1665 state = ((state << 8) | v) & 0xffff; | 1797 printf("marker does not match f_code (is: %d should be: %d pos: %d end %d x: %d y: %d)\n", |
1666 if (state == 0) break; | 1798 bits+1, s->f_code, get_bits_count(gb), gb->size*8, s->mb_x, s->mb_y); |
1667 if( get_bits_count(&s->gb) > s->gb.size*8-32){ | 1799 return -1; |
1668 printf("resync failed\n"); | 1800 }else if(s->pict_type == I_TYPE && bits != 0){ |
1801 printf("marker too long\n"); | |
1802 return -1; | |
1803 }else if(s->pict_type == B_TYPE && bits != MAX(MAX(s->f_code, s->b_code)-1, 1)){ | |
1804 printf("marker does not match f/b_code\n"); | |
1805 return -1; | |
1806 } | |
1807 //printf("%X\n", show_bits(gb, 24)); | |
1808 | |
1809 if(s->shape != RECT_SHAPE){ | |
1810 header_extension= get_bits1(gb); | |
1811 //FIXME more stuff here | |
1812 } | |
1813 | |
1814 mb_num= get_bits(gb, mb_num_bits); | |
1815 if(mb_num < s->mb_x + s->mb_y*s->mb_width || mb_num>=s->mb_num){ | |
1816 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_x + s->mb_y*s->mb_width); | |
1817 return -1; | |
1818 } | |
1819 | |
1820 if(s->shape != BIN_ONLY_SHAPE){ | |
1821 s->next_resync_qscale= get_bits(gb, 5); | |
1822 if(s->next_resync_qscale==0) | |
1823 s->next_resync_qscale= s->qscale; | |
1824 if(s->next_resync_qscale==0){ | |
1825 fprintf(stderr, "qscale==0\n"); | |
1669 return -1; | 1826 return -1; |
1670 } | 1827 } |
1671 } | 1828 } |
1672 //printf("%X\n", show_bits(&s->gb, 24)); | |
1673 bits=0; | |
1674 while(!get_bits1(&s->gb) && bits<30) bits++; | |
1675 if(s->pict_type == P_TYPE && bits != s->f_code-1) | |
1676 printf("marker does not match f_code\n"); | |
1677 //FIXME check bits for B-framess | |
1678 //printf("%X\n", show_bits(&s->gb, 24)); | |
1679 | |
1680 if(s->shape != RECT_SHAPE){ | |
1681 header_extension= get_bits1(&s->gb); | |
1682 //FIXME more stuff here | |
1683 } | |
1684 | |
1685 mb_num= get_bits(&s->gb, mb_num_bits); | |
1686 if(mb_num != s->mb_x + s->mb_y*s->mb_width){ | |
1687 printf("MB-num change not supported %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width); | |
1688 // s->mb_x= mb_num % s->mb_width; | |
1689 // s->mb_y= mb_num / s->mb_width; | |
1690 //FIXME many vars are wrong now | |
1691 } | |
1692 | |
1693 if(s->shape != BIN_ONLY_SHAPE){ | |
1694 s->qscale= get_bits(&s->gb, 5); | |
1695 h263_dc_scale(s); | |
1696 } | |
1697 | 1829 |
1698 if(s->shape == RECT_SHAPE){ | 1830 if(s->shape == RECT_SHAPE){ |
1699 header_extension= get_bits1(&s->gb); | 1831 header_extension= get_bits1(gb); |
1700 } | 1832 } |
1701 if(header_extension){ | 1833 if(header_extension){ |
1834 int time_increment; | |
1702 int time_incr=0; | 1835 int time_incr=0; |
1703 printf("header extension not really supported\n"); | 1836 printf("header extension not supported\n"); |
1704 while (get_bits1(&s->gb) != 0) | 1837 return -1; |
1838 | |
1839 while (get_bits1(gb) != 0) | |
1705 time_incr++; | 1840 time_incr++; |
1706 | 1841 |
1707 check_marker(&s->gb, "before time_increment in video packed header"); | 1842 check_marker(gb, "before time_increment in video packed header"); |
1708 time_increment= get_bits(&s->gb, s->time_increment_bits); | 1843 time_increment= get_bits(gb, s->time_increment_bits); |
1709 if(s->pict_type!=B_TYPE){ | 1844 if(s->pict_type!=B_TYPE){ |
1710 s->last_time_base= s->time_base; | 1845 s->last_time_base= s->time_base; |
1711 s->time_base+= time_incr; | 1846 s->time_base+= time_incr; |
1712 s->time= s->time_base*s->time_increment_resolution + time_increment; | 1847 s->time= s->time_base*s->time_increment_resolution + time_increment; |
1713 s->pp_time= s->time - s->last_non_b_time; | 1848 s->pp_time= s->time - s->last_non_b_time; |
1714 s->last_non_b_time= s->time; | 1849 s->last_non_b_time= s->time; |
1715 }else{ | 1850 }else{ |
1716 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment; | 1851 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment; |
1717 s->bp_time= s->last_non_b_time - s->time; | 1852 s->bp_time= s->last_non_b_time - s->time; |
1718 } | 1853 } |
1719 check_marker(&s->gb, "before vop_coding_type in video packed header"); | 1854 check_marker(gb, "before vop_coding_type in video packed header"); |
1720 | 1855 |
1721 skip_bits(&s->gb, 2); /* vop coding type */ | 1856 skip_bits(gb, 2); /* vop coding type */ |
1722 //FIXME not rect stuff here | 1857 //FIXME not rect stuff here |
1723 | 1858 |
1724 if(s->shape != BIN_ONLY_SHAPE){ | 1859 if(s->shape != BIN_ONLY_SHAPE){ |
1725 skip_bits(&s->gb, 3); /* intra dc vlc threshold */ | 1860 skip_bits(gb, 3); /* intra dc vlc threshold */ |
1726 | 1861 |
1727 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){ | 1862 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){ |
1728 mpeg4_decode_sprite_trajectory(s); | 1863 mpeg4_decode_sprite_trajectory(s); |
1729 } | 1864 } |
1730 | 1865 |
1731 //FIXME reduced res stuff here | 1866 //FIXME reduced res stuff here |
1732 | 1867 |
1733 if (s->pict_type != I_TYPE) { | 1868 if (s->pict_type != I_TYPE) { |
1734 s->f_code = get_bits(&s->gb, 3); /* fcode_for */ | 1869 s->f_code = get_bits(gb, 3); /* fcode_for */ |
1735 if(s->f_code==0){ | 1870 if(s->f_code==0){ |
1736 printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n"); | 1871 printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n"); |
1737 return -1; // makes no sense to continue, as the MV decoding will break very quickly | 1872 return -1; // makes no sense to continue, as the MV decoding will break very quickly |
1738 } | 1873 } |
1739 } | 1874 } |
1740 if (s->pict_type == B_TYPE) { | 1875 if (s->pict_type == B_TYPE) { |
1741 s->b_code = get_bits(&s->gb, 3); | 1876 s->b_code = get_bits(gb, 3); |
1742 } | 1877 } |
1743 } | 1878 } |
1744 | |
1745 } | 1879 } |
1746 //FIXME new-pred stuff | 1880 //FIXME new-pred stuff |
1881 | |
1882 //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)); | |
1883 | |
1884 return mb_num; | |
1885 } | |
1886 | |
1887 void ff_mpeg4_clean_buffers(MpegEncContext *s) | |
1888 { | |
1889 int c_wrap, c_xy, l_wrap, l_xy; | |
1747 | 1890 |
1748 l_wrap= s->block_wrap[0]; | 1891 l_wrap= s->block_wrap[0]; |
1749 l_xy= s->mb_y*l_wrap*2; | 1892 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2; |
1750 c_wrap= s->block_wrap[4]; | 1893 c_wrap= s->block_wrap[4]; |
1751 c_xy= s->mb_y*c_wrap; | 1894 c_xy= s->mb_y*c_wrap + s->mb_x; |
1752 | 1895 |
1753 /* clean DC */ | 1896 /* clean DC */ |
1754 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*3); | 1897 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); |
1755 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap*2); | 1898 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); |
1756 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap*2); | 1899 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1); |
1757 | 1900 |
1758 /* clean AC */ | 1901 /* clean AC */ |
1759 memset(s->ac_val[0] + l_xy, 0, l_wrap*3*16*sizeof(INT16)); | 1902 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16)); |
1760 memset(s->ac_val[1] + c_xy, 0, c_wrap*2*16*sizeof(INT16)); | 1903 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16)); |
1761 memset(s->ac_val[2] + c_xy, 0, c_wrap*2*16*sizeof(INT16)); | 1904 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16)); |
1762 | 1905 |
1763 /* clean MV */ | 1906 /* clean MV */ |
1764 memset(s->motion_val + l_xy, 0, l_wrap*3*2*sizeof(INT16)); | 1907 // we cant clear the MVs as they might be needed by a b frame |
1908 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16)); | |
1765 // memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); | 1909 // memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); |
1766 s->resync_x_pos= s->mb_x; | 1910 s->last_mv[0][0][0]= |
1911 s->last_mv[0][0][1]= | |
1912 s->last_mv[1][0][0]= | |
1913 s->last_mv[1][0][1]= 0; | |
1914 } | |
1915 | |
1916 /* searches for the next resync marker clears ac,dc,mc, and sets s->next_resync_gb, s->mb_num_left */ | |
1917 int ff_mpeg4_resync(MpegEncContext *s) | |
1918 { | |
1919 GetBitContext gb; | |
1920 | |
1921 /* search & parse next resync marker */ | |
1922 | |
1923 gb= s->next_resync_gb; | |
1924 align_get_bits(&gb); | |
1925 //printf("mpeg4_resync %d next:%d \n", get_bits_count(&gb), get_bits_count(&s->next_resync_gb)); | |
1926 for(;;) { | |
1927 int v= show_bits(&gb, 24); | |
1928 if( get_bits_count(&gb) >= gb.size*8-24 || v == 1 /* start-code */){ | |
1929 s->mb_num_left= s->mb_num - s->mb_x - s->mb_y*s->mb_width; | |
1930 //printf("mpeg4_resync end\n"); | |
1931 s->gb= s->next_resync_gb; //continue at the next resync marker | |
1932 return -1; | |
1933 }else if(v>>8 == 0){ | |
1934 int next; | |
1935 s->next_resync_pos= get_bits_count(&gb); | |
1936 | |
1937 next= decode_video_packet_header(s, &gb); | |
1938 if(next >= 0){ | |
1939 s->mb_num_left= next - s->mb_x - s->mb_y*s->mb_width; | |
1940 break; | |
1941 } | |
1942 | |
1943 align_get_bits(&gb); | |
1944 } | |
1945 skip_bits(&gb, 8); | |
1946 } | |
1947 s->next_resync_gb=gb; | |
1948 | |
1949 return 0; | |
1950 } | |
1951 | |
1952 static inline void init_block_index(MpegEncContext *s) | |
1953 { | |
1954 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2; | |
1955 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1) + s->mb_x*2; | |
1956 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2; | |
1957 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2) + s->mb_x*2; | |
1958 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x; | |
1959 s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x; | |
1960 } | |
1961 | |
1962 static inline void update_block_index(MpegEncContext *s) | |
1963 { | |
1964 s->block_index[0]+=2; | |
1965 s->block_index[1]+=2; | |
1966 s->block_index[2]+=2; | |
1967 s->block_index[3]+=2; | |
1968 s->block_index[4]++; | |
1969 s->block_index[5]++; | |
1970 } | |
1971 | |
1972 /** | |
1973 * decodes the first & second partition | |
1974 * returns error type or 0 if no error | |
1975 */ | |
1976 int ff_mpeg4_decode_partitions(MpegEncContext *s) | |
1977 { | |
1978 static const INT8 quant_tab[4] = { -1, -2, 1, 2 }; | |
1979 int mb_num; | |
1980 | |
1981 /* decode first partition */ | |
1982 mb_num=0; | |
1767 s->first_slice_line=1; | 1983 s->first_slice_line=1; |
1984 s->mb_x= s->resync_mb_x; | |
1985 for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){ | |
1986 init_block_index(s); | |
1987 for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){ | |
1988 const int xy= s->mb_x + s->mb_y*s->mb_width; | |
1989 int cbpc; | |
1990 int dir=0; | |
1991 | |
1992 mb_num++; | |
1993 update_block_index(s); | |
1994 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) | |
1995 s->first_slice_line=0; | |
1996 | |
1997 if(s->mb_x==0) PRINT_MB_TYPE("\n"); | |
1998 | |
1999 if(s->pict_type==I_TYPE){ | |
2000 int i; | |
2001 | |
2002 PRINT_MB_TYPE("I"); | |
2003 cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc); | |
2004 if (cbpc < 0){ | |
2005 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); | |
2006 return DECODING_DESYNC; | |
2007 } | |
2008 s->cbp_table[xy]= cbpc & 3; | |
2009 s->mb_type[xy]= MB_TYPE_INTRA; | |
2010 s->mb_intra = 1; | |
2011 | |
2012 if(cbpc & 4) { | |
2013 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
2014 if (s->qscale < 1) | |
2015 s->qscale = 1; | |
2016 else if (s->qscale > 31) | |
2017 s->qscale = 31; | |
2018 h263_dc_scale(s); | |
2019 } | |
2020 s->qscale_table[xy]= s->qscale; | |
2021 | |
2022 s->mbintra_table[xy]= 1; | |
2023 for(i=0; i<6; i++){ | |
2024 int dc_pred_dir; | |
2025 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
2026 if(dc < 0){ | |
2027 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); | |
2028 return DECODING_DESYNC; | |
2029 } | |
2030 dir<<=1; | |
2031 if(dc_pred_dir) dir|=1; | |
2032 } | |
2033 s->pred_dir_table[xy]= dir; | |
2034 }else{ /* P/S_TYPE */ | |
2035 int mx, my, pred_x, pred_y; | |
2036 INT16 * const mot_val= s->motion_val[s->block_index[0]]; | |
2037 const int stride= s->block_wrap[0]*2; | |
2038 | |
2039 if(get_bits1(&s->gb)){ | |
2040 /* skip mb */ | |
2041 s->mb_type[xy]= MB_TYPE_SKIPED; | |
2042 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
2043 const int a= s->sprite_warping_accuracy; | |
2044 PRINT_MB_TYPE("G"); | |
2045 if(s->divx_version==500 && s->divx_build==413){ | |
2046 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample)); | |
2047 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample)); | |
2048 }else{ | |
2049 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample); | |
2050 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample); | |
2051 s->mb_type[xy]= MB_TYPE_GMC | MB_TYPE_SKIPED; | |
2052 } | |
2053 }else{ | |
2054 PRINT_MB_TYPE("S"); | |
2055 mx = 0; | |
2056 my = 0; | |
2057 } | |
2058 mot_val[0 ]= mot_val[2 ]= | |
2059 mot_val[0+stride]= mot_val[2+stride]= mx; | |
2060 mot_val[1 ]= mot_val[3 ]= | |
2061 mot_val[1+stride]= mot_val[3+stride]= my; | |
2062 | |
2063 if(s->mbintra_table[xy]) | |
2064 ff_clean_intra_table_entries(s); | |
2065 | |
2066 continue; | |
2067 } | |
2068 cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc); | |
2069 if (cbpc < 0){ | |
2070 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); | |
2071 return DECODING_DESYNC; | |
2072 } | |
2073 if (cbpc > 20) | |
2074 cbpc+=3; | |
2075 else if (cbpc == 20) | |
2076 fprintf(stderr, "Stuffing !"); | |
2077 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant | |
2078 | |
2079 s->mb_intra = ((cbpc & 4) != 0); | |
2080 | |
2081 if(s->mb_intra){ | |
2082 PRINT_MB_TYPE("I"); | |
2083 s->mbintra_table[xy]= 1; | |
2084 s->mb_type[xy]= MB_TYPE_INTRA; | |
2085 mot_val[0 ]= mot_val[2 ]= | |
2086 mot_val[0+stride]= mot_val[2+stride]= 0; | |
2087 mot_val[1 ]= mot_val[3 ]= | |
2088 mot_val[1+stride]= mot_val[3+stride]= 0; | |
2089 }else{ | |
2090 if(s->mbintra_table[xy]) | |
2091 ff_clean_intra_table_entries(s); | |
2092 | |
2093 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) | |
2094 s->mcsel= get_bits1(&s->gb); | |
2095 else s->mcsel= 0; | |
2096 | |
2097 if ((cbpc & 16) == 0) { | |
2098 PRINT_MB_TYPE("P"); | |
2099 /* 16x16 motion prediction */ | |
2100 s->mb_type[xy]= MB_TYPE_INTER; | |
2101 | |
2102 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
2103 if(!s->mcsel) | |
2104 mx = h263_decode_motion(s, pred_x, s->f_code); | |
2105 else { | |
2106 const int a= s->sprite_warping_accuracy; | |
2107 if(s->divx_version==500 && s->divx_build==413){ | |
2108 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample)); | |
2109 }else{ | |
2110 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample); | |
2111 } | |
2112 } | |
2113 if (mx >= 0xffff) | |
2114 return DECODING_DESYNC; | |
2115 | |
2116 if(!s->mcsel) | |
2117 my = h263_decode_motion(s, pred_y, s->f_code); | |
2118 else{ | |
2119 const int a= s->sprite_warping_accuracy; | |
2120 if(s->divx_version==500 && s->divx_build==413){ | |
2121 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample)); | |
2122 }else{ | |
2123 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample); | |
2124 } | |
2125 } | |
2126 if (my >= 0xffff) | |
2127 return DECODING_DESYNC; | |
2128 mot_val[0 ]= mot_val[2 ] = | |
2129 mot_val[0+stride]= mot_val[2+stride]= mx; | |
2130 mot_val[1 ]= mot_val[3 ]= | |
2131 mot_val[1+stride]= mot_val[3+stride]= my; | |
2132 } else { | |
2133 int i; | |
2134 PRINT_MB_TYPE("4"); | |
2135 s->mb_type[xy]= MB_TYPE_INTER4V; | |
2136 for(i=0;i<4;i++) { | |
2137 INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y); | |
2138 mx = h263_decode_motion(s, pred_x, s->f_code); | |
2139 if (mx >= 0xffff) | |
2140 return DECODING_DESYNC; | |
2141 | |
2142 my = h263_decode_motion(s, pred_y, s->f_code); | |
2143 if (my >= 0xffff) | |
2144 return DECODING_DESYNC; | |
2145 mot_val[0] = mx; | |
2146 mot_val[1] = my; | |
2147 } | |
2148 } | |
2149 } | |
2150 } | |
2151 } | |
2152 s->mb_x= 0; | |
2153 } | |
2154 | |
2155 if (s->pict_type==I_TYPE && get_bits(&s->gb, 19)!=DC_MARKER ) s->decoding_error= DECODING_DESYNC; | |
2156 else if(s->pict_type!=I_TYPE && get_bits(&s->gb, 17)!=MOTION_MARKER) s->decoding_error= DECODING_DESYNC; | |
2157 if(s->decoding_error== DECODING_DESYNC){ | |
2158 fprintf(stderr, "marker missing after first partition at %d %d\n", s->mb_x, s->mb_y); | |
2159 return DECODING_DESYNC; | |
2160 } | |
2161 | |
2162 /* decode second partition */ | |
2163 mb_num=0; | |
2164 s->mb_x= s->resync_mb_x; | |
2165 for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){ | |
2166 init_block_index(s); | |
2167 for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){ | |
2168 const int xy= s->mb_x + s->mb_y*s->mb_width; | |
2169 | |
2170 mb_num++; | |
2171 update_block_index(s); | |
2172 | |
2173 if(s->pict_type==I_TYPE){ | |
2174 int ac_pred= get_bits1(&s->gb); | |
2175 int cbpy = get_vlc(&s->gb, &cbpy_vlc); | |
2176 if(cbpy<0){ | |
2177 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | |
2178 return DECODING_AC_LOST; | |
2179 } | |
2180 | |
2181 s->cbp_table[xy]|= cbpy<<2; | |
2182 s->pred_dir_table[xy]|= ac_pred<<7; | |
2183 }else{ /* P || S_TYPE */ | |
2184 if(s->mb_type[xy]&MB_TYPE_INTRA){ | |
2185 int dir=0,i; | |
2186 int ac_pred = get_bits1(&s->gb); | |
2187 int cbpy = get_vlc(&s->gb, &cbpy_vlc); | |
2188 | |
2189 if(cbpy<0){ | |
2190 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | |
2191 return DECODING_ACDC_LOST; | |
2192 } | |
2193 | |
2194 if(s->cbp_table[xy] & 8) { | |
2195 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
2196 if (s->qscale < 1) | |
2197 s->qscale = 1; | |
2198 else if (s->qscale > 31) | |
2199 s->qscale = 31; | |
2200 h263_dc_scale(s); | |
2201 } | |
2202 s->qscale_table[xy]= s->qscale; | |
2203 | |
2204 for(i=0; i<6; i++){ | |
2205 int dc_pred_dir; | |
2206 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
2207 if(dc < 0){ | |
2208 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); | |
2209 return DECODING_ACDC_LOST; | |
2210 } | |
2211 dir<<=1; | |
2212 if(dc_pred_dir) dir|=1; | |
2213 } | |
2214 s->cbp_table[xy]&= 3; //remove dquant | |
2215 s->cbp_table[xy]|= cbpy<<2; | |
2216 s->pred_dir_table[xy]= dir | (ac_pred<<7); | |
2217 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){ | |
2218 s->qscale_table[xy]= s->qscale; | |
2219 s->cbp_table[xy]= 0; | |
2220 }else{ | |
2221 int cbpy = get_vlc(&s->gb, &cbpy_vlc); | |
2222 | |
2223 if(cbpy<0){ | |
2224 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | |
2225 return DECODING_ACDC_LOST; | |
2226 } | |
2227 | |
2228 if(s->cbp_table[xy] & 8) { | |
2229 //fprintf(stderr, "dquant\n"); | |
2230 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
2231 if (s->qscale < 1) | |
2232 s->qscale = 1; | |
2233 else if (s->qscale > 31) | |
2234 s->qscale = 31; | |
2235 h263_dc_scale(s); | |
2236 } | |
2237 s->qscale_table[xy]= s->qscale; | |
2238 | |
2239 s->cbp_table[xy]&= 3; //remove dquant | |
2240 s->cbp_table[xy]|= (cbpy^0xf)<<2; | |
2241 } | |
2242 } | |
2243 } | |
2244 s->mb_x= 0; | |
2245 } | |
2246 | |
2247 | |
2248 return 0; | |
2249 } | |
2250 | |
2251 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, | |
2252 DCTELEM block[6][64]) | |
2253 { | |
2254 int cbp, mb_type; | |
2255 const int xy= s->mb_x + s->mb_y*s->mb_width; | |
2256 | |
2257 if(s->mb_x==s->resync_mb_x && s->mb_y==s->resync_mb_y){ //Note resync_mb_{x,y}==0 at the start | |
2258 int i; | |
2259 int block_index_backup[6]; | |
2260 int qscale= s->qscale; | |
2261 | |
2262 for(i=0; i<6; i++) block_index_backup[i]= s->block_index[i]; | |
2263 | |
2264 s->decoding_error= ff_mpeg4_decode_partitions(s); | |
2265 | |
2266 for(i=0; i<6; i++) s->block_index[i]= block_index_backup[i]; | |
2267 s->first_slice_line=1; | |
2268 s->mb_x= s->resync_mb_x; | |
2269 s->mb_y= s->resync_mb_y; | |
2270 s->qscale= qscale; | |
2271 h263_dc_scale(s); | |
2272 | |
2273 if(s->decoding_error==DECODING_DESYNC) return -1; | |
2274 } | |
2275 | |
2276 mb_type= s->mb_type[xy]; | |
2277 if(s->decoding_error) | |
2278 cbp=0; | |
2279 else | |
2280 cbp = s->cbp_table[xy]; | |
2281 | |
2282 if(s->decoding_error!=DECODING_ACDC_LOST && s->qscale_table[xy] != s->qscale){ | |
2283 s->qscale= s->qscale_table[xy]; | |
2284 h263_dc_scale(s); | |
2285 } | |
2286 | |
2287 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { | |
2288 int i; | |
2289 for(i=0; i<4; i++){ | |
2290 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0]; | |
2291 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1]; | |
2292 } | |
2293 s->mb_intra = mb_type&MB_TYPE_INTRA; | |
2294 | |
2295 if (mb_type&MB_TYPE_SKIPED) { | |
2296 /* skip mb */ | |
2297 for(i=0;i<6;i++) | |
2298 s->block_last_index[i] = -1; | |
2299 s->mv_dir = MV_DIR_FORWARD; | |
2300 s->mv_type = MV_TYPE_16X16; | |
2301 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
2302 s->mcsel=1; | |
2303 s->mb_skiped = 0; | |
2304 }else{ | |
2305 s->mcsel=0; | |
2306 s->mb_skiped = 1; | |
2307 } | |
2308 return 0; | |
2309 }else if(s->mb_intra && s->decoding_error!=DECODING_ACDC_LOST){ | |
2310 s->ac_pred = s->pred_dir_table[xy]>>7; | |
2311 | |
2312 /* decode each block */ | |
2313 for (i = 0; i < 6; i++) { | |
2314 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1); | |
2315 if(ret==DECODING_AC_LOST){ | |
2316 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y); | |
2317 s->decoding_error=DECODING_AC_LOST; | |
2318 cbp=0; | |
2319 }else if(ret==DECODING_ACDC_LOST){ | |
2320 fprintf(stderr, "dc corrupted at %d %d (trying to continue with mc only)\n", s->mb_x, s->mb_y); | |
2321 s->decoding_error=DECODING_ACDC_LOST; | |
2322 break; | |
2323 } | |
2324 } | |
2325 }else if(!s->mb_intra){ | |
2326 // s->mcsel= 0; //FIXME do we need to init that | |
2327 | |
2328 s->mv_dir = MV_DIR_FORWARD; | |
2329 if (mb_type&MB_TYPE_INTER4V) { | |
2330 s->mv_type = MV_TYPE_8X8; | |
2331 } else { | |
2332 s->mv_type = MV_TYPE_16X16; | |
2333 } | |
2334 if(s->decoding_error==0 && cbp){ | |
2335 /* decode each block */ | |
2336 for (i = 0; i < 6; i++) { | |
2337 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1); | |
2338 if(ret==DECODING_AC_LOST){ | |
2339 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y); | |
2340 s->decoding_error=DECODING_AC_LOST; | |
2341 break; | |
2342 } | |
2343 } | |
2344 } | |
2345 } | |
2346 } else { /* I-Frame */ | |
2347 int i; | |
2348 s->mb_intra = 1; | |
2349 s->ac_pred = s->pred_dir_table[xy]>>7; | |
2350 | |
2351 /* decode each block */ | |
2352 for (i = 0; i < 6; i++) { | |
2353 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1); | |
2354 if(ret==DECODING_AC_LOST){ | |
2355 fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y); | |
2356 s->decoding_error=DECODING_AC_LOST; | |
2357 cbp=0; | |
2358 }else if(ret==DECODING_ACDC_LOST){ | |
2359 fprintf(stderr, "dc corrupted at %d %d\n", s->mb_x, s->mb_y); | |
2360 return -1; | |
2361 } | |
2362 } | |
2363 } | |
1768 | 2364 |
1769 return 0; | 2365 return 0; |
1770 } | 2366 } |
2367 | |
1771 | 2368 |
1772 int h263_decode_mb(MpegEncContext *s, | 2369 int h263_decode_mb(MpegEncContext *s, |
1773 DCTELEM block[6][64]) | 2370 DCTELEM block[6][64]) |
1774 { | 2371 { |
1775 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | 2372 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; |
1777 static INT8 quant_tab[4] = { -1, -2, 1, 2 }; | 2374 static INT8 quant_tab[4] = { -1, -2, 1, 2 }; |
1778 | 2375 |
1779 if(s->mb_x==0) PRINT_MB_TYPE("\n") | 2376 if(s->mb_x==0) PRINT_MB_TYPE("\n") |
1780 | 2377 |
1781 if(s->resync_marker){ | 2378 if(s->resync_marker){ |
1782 if( s->resync_x_pos == s->mb_x+1 | 2379 if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){ |
1783 || s->resync_x_pos == s->mb_x){ | |
1784 /* f*ck mpeg4 | |
1785 this is here so we dont need to slowdown h263_pred_motion with it */ | |
1786 if(s->resync_x_pos == s->mb_x+1 && s->mb_x==0){ | |
1787 int xy= s->block_index[0] - s->block_wrap[0]; | |
1788 s->motion_val[xy][0]= s->motion_val[xy+2][0]; | |
1789 s->motion_val[xy][1]= s->motion_val[xy+2][1]; | |
1790 } | |
1791 | |
1792 s->first_slice_line=0; | 2380 s->first_slice_line=0; |
1793 s->resync_x_pos=0; // isnt needed but for cleanness sake ;) | 2381 } |
1794 } | 2382 } |
1795 | 2383 |
1796 if(show_aligned_bits(&s->gb, 1, 16) == 0){ | 2384 if(s->data_partitioning && s->pict_type!=B_TYPE) |
1797 if( mpeg4_resync(s) < 0 ) return -1; | 2385 return mpeg4_decode_partitioned_mb(s, block); |
1798 | |
1799 } | |
1800 } | |
1801 | 2386 |
1802 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { | 2387 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
1803 if (get_bits1(&s->gb)) { | 2388 if (get_bits1(&s->gb)) { |
1804 /* skip mb */ | 2389 /* skip mb */ |
1805 s->mb_intra = 0; | 2390 s->mb_intra = 0; |
2071 if (s->h263_aic) { | 2656 if (s->h263_aic) { |
2072 s->y_dc_scale = 2 * s->qscale; | 2657 s->y_dc_scale = 2 * s->qscale; |
2073 s->c_dc_scale = 2 * s->qscale; | 2658 s->c_dc_scale = 2 * s->qscale; |
2074 } | 2659 } |
2075 cbpy = get_vlc(&s->gb, &cbpy_vlc); | 2660 cbpy = get_vlc(&s->gb, &cbpy_vlc); |
2661 if(cbpy<0) return -1; | |
2076 cbp = (cbpc & 3) | (cbpy << 2); | 2662 cbp = (cbpc & 3) | (cbpy << 2); |
2077 if (dquant) { | 2663 if (dquant) { |
2078 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | 2664 s->qscale += quant_tab[get_bits(&s->gb, 2)]; |
2079 if (s->qscale < 1) | 2665 if (s->qscale < 1) |
2080 s->qscale = 1; | 2666 s->qscale = 1; |
2252 } | 2838 } |
2253 s->block_last_index[n] = i; | 2839 s->block_last_index[n] = i; |
2254 return 0; | 2840 return 0; |
2255 } | 2841 } |
2256 | 2842 |
2257 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) | 2843 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
2258 { | 2844 { |
2259 int level, pred, code; | 2845 int level, pred, code; |
2260 UINT16 *dc_val; | 2846 UINT16 *dc_val; |
2261 | 2847 |
2262 if (n < 4) | 2848 if (n < 4) |
2263 code = get_vlc(&s->gb, &dc_lum); | 2849 code = get_vlc(&s->gb, &dc_lum); |
2264 else | 2850 else |
2265 code = get_vlc(&s->gb, &dc_chrom); | 2851 code = get_vlc(&s->gb, &dc_chrom); |
2266 if (code < 0) | 2852 if (code < 0 || code > 9 /* && s->nbit<9 */){ |
2853 fprintf(stderr, "illegal dc vlc\n"); | |
2267 return -1; | 2854 return -1; |
2855 } | |
2268 if (code == 0) { | 2856 if (code == 0) { |
2269 level = 0; | 2857 level = 0; |
2270 } else { | 2858 } else { |
2271 level = get_bits(&s->gb, code); | 2859 level = get_bits(&s->gb, code); |
2272 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/ | 2860 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/ |
2273 level = - (level ^ ((1 << code) - 1)); | 2861 level = - (level ^ ((1 << code) - 1)); |
2274 if (code > 8) | 2862 if (code > 8){ |
2275 skip_bits1(&s->gb); /* marker */ | 2863 if(get_bits1(&s->gb)==0){ /* marker */ |
2864 fprintf(stderr, "dc marker bit missing\n"); | |
2865 return -1; | |
2866 } | |
2867 } | |
2276 } | 2868 } |
2277 | 2869 |
2278 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr); | 2870 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr); |
2279 level += pred; | 2871 level += pred; |
2280 if (level < 0) | 2872 if (level < 0) |
2285 *dc_val = level * s->c_dc_scale; | 2877 *dc_val = level * s->c_dc_scale; |
2286 } | 2878 } |
2287 return level; | 2879 return level; |
2288 } | 2880 } |
2289 | 2881 |
2290 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | 2882 /** |
2883 * decode a block | |
2884 * returns 0 if everything went ok | |
2885 * returns DECODING_AC_LOST if an error was detected during AC decoding | |
2886 * returns DECODING_ACDC_LOST if an error was detected during DC decoding | |
2887 */ | |
2888 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
2291 int n, int coded) | 2889 int n, int coded) |
2292 { | 2890 { |
2293 int code, level, i, j, last, run; | 2891 int code, level, i, j, last, run; |
2294 int dc_pred_dir; | 2892 int dc_pred_dir; |
2295 RLTable *rl; | 2893 RLTable *rl; |
2296 const UINT8 *scan_table; | 2894 const UINT8 *scan_table; |
2297 | 2895 |
2298 if (s->mb_intra) { | 2896 if (s->mb_intra) { |
2299 /* DC coef */ | 2897 /* DC coef */ |
2300 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | 2898 if(s->data_partitioning && s->pict_type!=B_TYPE){ |
2301 if (level < 0) | 2899 level = s->dc_val[0][ s->block_index[n] ]; |
2302 return -1; | 2900 if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs |
2901 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale; | |
2902 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32; | |
2903 }else{ | |
2904 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
2905 if (level < 0) | |
2906 return DECODING_ACDC_LOST; | |
2907 } | |
2303 block[0] = level; | 2908 block[0] = level; |
2304 i = 1; | 2909 i = 1; |
2305 if (!coded) | 2910 if (!coded) |
2306 goto not_coded; | 2911 goto not_coded; |
2307 rl = &rl_intra; | 2912 rl = &rl_intra; |
2308 if (s->ac_pred) { | 2913 if (s->ac_pred) { |
2309 if (dc_pred_dir == 0) | 2914 if (dc_pred_dir == 0) |
2324 } | 2929 } |
2325 | 2930 |
2326 for(;;) { | 2931 for(;;) { |
2327 code = get_vlc(&s->gb, &rl->vlc); | 2932 code = get_vlc(&s->gb, &rl->vlc); |
2328 if (code < 0) | 2933 if (code < 0) |
2329 return -1; | 2934 return DECODING_AC_LOST; |
2330 if (code == rl->n) { | 2935 if (code == rl->n) { |
2331 /* escape */ | 2936 /* escape */ |
2332 if (get_bits1(&s->gb) != 0) { | 2937 if (get_bits1(&s->gb) != 0) { |
2333 if (get_bits1(&s->gb) != 0) { | 2938 if (get_bits1(&s->gb) != 0) { |
2334 /* third escape */ | 2939 /* third escape */ |
2335 last = get_bits1(&s->gb); | 2940 last = get_bits1(&s->gb); |
2336 run = get_bits(&s->gb, 6); | 2941 run = get_bits(&s->gb, 6); |
2337 get_bits1(&s->gb); /* marker */ | 2942 if(get_bits1(&s->gb)==0){ |
2943 fprintf(stderr, "1. marker bit missing in 3. esc\n"); | |
2944 return DECODING_AC_LOST; | |
2945 } | |
2338 level = get_bits(&s->gb, 12); | 2946 level = get_bits(&s->gb, 12); |
2339 level = (level << 20) >> 20; /* sign extend */ | 2947 level = (level << 20) >> 20; /* sign extend */ |
2340 skip_bits1(&s->gb); /* marker */ | 2948 if(get_bits1(&s->gb)==0){ |
2949 fprintf(stderr, "2. marker bit missing in 3. esc\n"); | |
2950 return DECODING_AC_LOST; | |
2951 } | |
2952 if(level>512 || level<-512){ //FIXME check that QP=1 is ok with this too | |
2953 fprintf(stderr, "|level| overflow in 3. esc\n"); | |
2954 return DECODING_AC_LOST; | |
2955 } | |
2956 #if 1 | |
2957 { | |
2958 const int abs_level= ABS(level); | |
2959 const int run1= run - rl->max_run[last][abs_level] - 1; | |
2960 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && s->error_resilience>=0){ | |
2961 if(abs_level <= rl->max_level[last][run]){ | |
2962 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n"); | |
2963 return DECODING_AC_LOST; | |
2964 } | |
2965 if(abs_level <= rl->max_level[last][run]*2){ | |
2966 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n"); | |
2967 return DECODING_AC_LOST; | |
2968 } | |
2969 if(abs_level <= rl->max_level[last][run1]){ | |
2970 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n"); | |
2971 return DECODING_AC_LOST; | |
2972 } | |
2973 } | |
2974 } | |
2975 #endif | |
2341 } else { | 2976 } else { |
2342 /* second escape */ | 2977 /* second escape */ |
2343 code = get_vlc(&s->gb, &rl->vlc); | 2978 code = get_vlc(&s->gb, &rl->vlc); |
2344 if (code < 0 || code >= rl->n) | 2979 if (code < 0 || code >= rl->n) |
2345 return -1; | 2980 return DECODING_AC_LOST; |
2346 run = rl->table_run[code]; | 2981 run = rl->table_run[code]; |
2347 level = rl->table_level[code]; | 2982 level = rl->table_level[code]; |
2348 last = code >= rl->last; | 2983 last = code >= rl->last; |
2349 run += rl->max_run[last][level] + 1; | 2984 run += rl->max_run[last][level] + 1; |
2350 if (get_bits1(&s->gb)) | 2985 if (get_bits1(&s->gb)) |
2352 } | 2987 } |
2353 } else { | 2988 } else { |
2354 /* first escape */ | 2989 /* first escape */ |
2355 code = get_vlc(&s->gb, &rl->vlc); | 2990 code = get_vlc(&s->gb, &rl->vlc); |
2356 if (code < 0 || code >= rl->n) | 2991 if (code < 0 || code >= rl->n) |
2357 return -1; | 2992 return DECODING_AC_LOST; |
2358 run = rl->table_run[code]; | 2993 run = rl->table_run[code]; |
2359 level = rl->table_level[code]; | 2994 level = rl->table_level[code]; |
2360 last = code >= rl->last; | 2995 last = code >= rl->last; |
2361 level += rl->max_level[last][run]; | 2996 level += rl->max_level[last][run]; |
2362 if (get_bits1(&s->gb)) | 2997 if (get_bits1(&s->gb)) |
2369 if (get_bits1(&s->gb)) | 3004 if (get_bits1(&s->gb)) |
2370 level = -level; | 3005 level = -level; |
2371 } | 3006 } |
2372 i += run; | 3007 i += run; |
2373 if (i >= 64) | 3008 if (i >= 64) |
2374 return -1; | 3009 return DECODING_AC_LOST; |
2375 j = scan_table[i]; | 3010 j = scan_table[i]; |
2376 block[j] = level; | 3011 block[j] = level; |
2377 i++; | 3012 i++; |
2378 if (last) | 3013 if (last) |
2379 break; | 3014 break; |
2836 // printf("width/height: %d %d\n", width, height); | 3471 // printf("width/height: %d %d\n", width, height); |
2837 } | 3472 } |
2838 } | 3473 } |
2839 | 3474 |
2840 if(get_bits1(&s->gb)) printf("interlaced not supported\n"); /* interlaced */ | 3475 if(get_bits1(&s->gb)) printf("interlaced not supported\n"); /* interlaced */ |
2841 if(!get_bits1(&s->gb)) printf("OBMC not supported\n"); /* OBMC Disable */ | 3476 if(!get_bits1(&s->gb)) printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */ |
2842 if (vo_ver_id == 1) { | 3477 if (vo_ver_id == 1) { |
2843 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */ | 3478 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */ |
2844 } else { | 3479 } else { |
2845 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */ | 3480 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */ |
2846 } | 3481 } |
2930 | 3565 |
2931 if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n"); | 3566 if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n"); |
2932 | 3567 |
2933 s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */ | 3568 s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */ |
2934 | 3569 |
2935 s->data_partioning= get_bits1(&s->gb); | 3570 s->data_partitioning= get_bits1(&s->gb); |
2936 if(s->data_partioning){ | 3571 if(s->data_partitioning){ |
2937 printf("data partitioning not supported\n"); | 3572 s->rvlc= get_bits1(&s->gb); |
2938 skip_bits1(&s->gb); // reversible vlc | 3573 if(s->rvlc){ |
3574 printf("reversible vlc not supported\n"); | |
3575 } | |
2939 } | 3576 } |
2940 | 3577 |
2941 if(vo_ver_id != 1) { | 3578 if(vo_ver_id != 1) { |
2942 s->new_pred= get_bits1(&s->gb); | 3579 s->new_pred= get_bits1(&s->gb); |
2943 if(s->new_pred){ | 3580 if(s->new_pred){ |
2997 } else if (startcode != 0x1b6) { //VOP | 3634 } else if (startcode != 0x1b6) { //VOP |
2998 goto redo; | 3635 goto redo; |
2999 } | 3636 } |
3000 | 3637 |
3001 s->pict_type = get_bits(&s->gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ | 3638 s->pict_type = get_bits(&s->gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ |
3639 //if(s->pict_type!=I_TYPE) return FRAME_SKIPED; | |
3002 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){ | 3640 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){ |
3003 printf("low_delay flag set, but shouldnt, clearing it\n"); | 3641 printf("low_delay flag set, but shouldnt, clearing it\n"); |
3004 s->low_delay=0; | 3642 s->low_delay=0; |
3005 } | 3643 } |
3006 // printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample); | 3644 // printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample); |
3645 //printf("%d", s->pict_type); | |
3007 time_incr=0; | 3646 time_incr=0; |
3008 while (get_bits1(&s->gb) != 0) | 3647 while (get_bits1(&s->gb) != 0) |
3009 time_incr++; | 3648 time_incr++; |
3010 | 3649 |
3011 check_marker(&s->gb, "before time_increment"); | 3650 check_marker(&s->gb, "before time_increment"); |