Mercurial > libavcodec.hg

comparison msmpeg4.c @ 519:55b4e2248a45 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
wmv1 slice_height != mb_height support encoding of slice_height != mb_height 1bit shorter wmv1 headers if bit_rate<50 !? ROTFL M$ is even more stupid than i thought using dc of non intra blocks for dc prediction of wmv1 if bitrate < 129 && res < 320x240
author michaelni
date Sun, 07 Jul 2002 08:34:46 +0000
parents 2241bce35bb9
children f5d7fcc81787
comparison
equal deleted inserted replaced
518:70113647b50d 519:55b4e2248a45
41 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); 41 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
42 static int msmpeg4_decode_motion(MpegEncContext * s, 42 static int msmpeg4_decode_motion(MpegEncContext * s,
43 int *mx_ptr, int *my_ptr); 43 int *mx_ptr, int *my_ptr);
44 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val); 44 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
45 static void init_h263_dc_for_msmpeg4(void); 45 static void init_h263_dc_for_msmpeg4(void);
46 static inline void msmpeg4_memsetw(short *tab, int val, int n);
47
46 48
47 49
48 extern UINT32 inverse[256]; 50 extern UINT32 inverse[256];
49 51
50 #ifdef DEBUG 52 #ifdef DEBUG
343 345
344 s->dc_table_index = 1; 346 s->dc_table_index = 1;
345 s->mv_table_index = 1; /* only if P frame */ 347 s->mv_table_index = 1; /* only if P frame */
346 s->use_skip_mb_code = 1; /* only if P frame */ 348 s->use_skip_mb_code = 1; /* only if P frame */
347 s->per_mb_rl_table = 0; 349 s->per_mb_rl_table = 0;
350 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=128 && s->pict_type==P_TYPE);
348 351
349 if (s->pict_type == I_TYPE) { 352 if (s->pict_type == I_TYPE) {
350 s->no_rounding = 1; 353 s->no_rounding = 1;
351 put_bits(&s->pb, 5, 0x17); /* indicate only one "slice" */ 354 s->slice_height= s->mb_height/1;
355 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
352 356
353 if(s->msmpeg4_version==4){ 357 if(s->msmpeg4_version==4){
354 msmpeg4_encode_ext_header(s); 358 msmpeg4_encode_ext_header(s);
355 put_bits(&s->pb, 1, s->per_mb_rl_table); 359 if(s->bit_rate>50)
360 put_bits(&s->pb, 1, s->per_mb_rl_table);
356 } 361 }
357 362
358 if(s->msmpeg4_version>2){ 363 if(s->msmpeg4_version>2){
359 if(!s->per_mb_rl_table){ 364 if(!s->per_mb_rl_table){
360 code012(&s->pb, s->rl_chroma_table_index); 365 code012(&s->pb, s->rl_chroma_table_index);
364 put_bits(&s->pb, 1, s->dc_table_index); 369 put_bits(&s->pb, 1, s->dc_table_index);
365 } 370 }
366 } else { 371 } else {
367 put_bits(&s->pb, 1, s->use_skip_mb_code); 372 put_bits(&s->pb, 1, s->use_skip_mb_code);
368 373
369 if(s->msmpeg4_version==4) 374 if(s->msmpeg4_version==4 && s->bit_rate>50)
370 put_bits(&s->pb, 1, s->per_mb_rl_table); 375 put_bits(&s->pb, 1, s->per_mb_rl_table);
371 376
372 if(s->msmpeg4_version>2){ 377 if(s->msmpeg4_version>2){
373 if(!s->per_mb_rl_table) 378 if(!s->per_mb_rl_table)
374 code012(&s->pb, s->rl_table_index); 379 code012(&s->pb, s->rl_table_index);
396 401
397 void msmpeg4_encode_ext_header(MpegEncContext * s) 402 void msmpeg4_encode_ext_header(MpegEncContext * s)
398 { 403 {
399 put_bits(&s->pb, 5, s->frame_rate / FRAME_RATE_BASE); //yes 29.97 -> 29 404 put_bits(&s->pb, 5, s->frame_rate / FRAME_RATE_BASE); //yes 29.97 -> 29
400 405
401 put_bits(&s->pb, 11, MIN(s->bit_rate, 2047)); 406 put_bits(&s->pb, 11, MIN(s->bit_rate, 2047));
402 407
403 if(s->msmpeg4_version<3) 408 if(s->msmpeg4_version<3)
404 s->flipflop_rounding=0; 409 s->flipflop_rounding=0;
405 else{ 410 else{
406 s->flipflop_rounding=1; 411 s->flipflop_rounding=1;
472 put_bits(&s->pb, 6, mx); 477 put_bits(&s->pb, 6, mx);
473 put_bits(&s->pb, 6, my); 478 put_bits(&s->pb, 6, my);
474 } 479 }
475 } 480 }
476 481
482 static inline void handle_slices(MpegEncContext *s){
483 if (s->mb_x == 0) {
484 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
485 if(s->msmpeg4_version != 4){
486 int wrap;
487 /* reset DC pred (set previous line to 1024) */
488 wrap = 2 * s->mb_width + 2;
489 msmpeg4_memsetw(&s->dc_val[0][(1) + (2 * s->mb_y) * wrap],
490 1024, 2 * s->mb_width);
491 wrap = s->mb_width + 2;
492 msmpeg4_memsetw(&s->dc_val[1][(1) + (s->mb_y) * wrap],
493 1024, s->mb_width);
494 msmpeg4_memsetw(&s->dc_val[2][(1) + (s->mb_y) * wrap],
495 1024, s->mb_width);
496
497 /* reset AC pred (set previous line to 0) */
498 wrap = s->mb_width * 2 + 2;
499 msmpeg4_memsetw(s->ac_val[0][0] + (1 + (2 * s->mb_y) * wrap)*16,
500 0, 2 * s->mb_width*16);
501 wrap = s->mb_width + 2;
502 msmpeg4_memsetw(s->ac_val[1][0] + (1 + (s->mb_y) * wrap)*16,
503 0, s->mb_width*16);
504 msmpeg4_memsetw(s->ac_val[2][0] + (1 + (s->mb_y) * wrap)*16,
505 0, s->mb_width*16);
506 }
507 s->first_slice_line = 1;
508 } else {
509 s->first_slice_line = 0;
510 }
511 }
512 }
513
477 void msmpeg4_encode_mb(MpegEncContext * s, 514 void msmpeg4_encode_mb(MpegEncContext * s,
478 DCTELEM block[6][64], 515 DCTELEM block[6][64],
479 int motion_x, int motion_y) 516 int motion_x, int motion_y)
480 { 517 {
481 int cbp, coded_cbp, i; 518 int cbp, coded_cbp, i;
482 int pred_x, pred_y; 519 int pred_x, pred_y;
483 UINT8 *coded_block; 520 UINT8 *coded_block;
484 521
522 handle_slices(s);
523
485 if (!s->mb_intra) { 524 if (!s->mb_intra) {
486 /* compute cbp */ 525 /* compute cbp */
487 set_stat(ST_INTER_MB); 526 set_stat(ST_INTER_MB);
488 cbp = 0; 527 cbp = 0;
489 for (i = 0; i < 6; i++) { 528 for (i = 0; i < 6; i++) {
606 i= n-3; 645 i= n-3;
607 } 646 }
608 647
609 *dc_val_ptr= &s->last_dc[i]; 648 *dc_val_ptr= &s->last_dc[i];
610 return s->last_dc[i]; 649 return s->last_dc[i];
650 }
651
652 static int get_dc(uint8_t *src, int stride, int scale)
653 {
654 int y;
655 int sum=0;
656 for(y=0; y<8; y++){
657 int x;
658 for(x=0; x<8; x++){
659 sum+=src[x + y*stride];
660 }
661 }
662 return (sum + (scale>>1))/scale;
611 } 663 }
612 664
613 /* dir = 0: left, dir = 1: top prediction */ 665 /* dir = 0: left, dir = 1: top prediction */
614 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, 666 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
615 UINT16 **dc_val_ptr, int *dir_ptr) 667 UINT16 **dc_val_ptr, int *dir_ptr)
673 } 725 }
674 #endif 726 #endif
675 /* XXX: WARNING: they did not choose the same test as MPEG4. This 727 /* XXX: WARNING: they did not choose the same test as MPEG4. This
676 is very important ! */ 728 is very important ! */
677 if(s->msmpeg4_version>3){ 729 if(s->msmpeg4_version>3){
678 if (abs(a - b) < abs(b - c)) { 730 if(s->inter_intra_pred){
679 pred = c; 731 uint8_t *dest;
680 *dir_ptr = 1; 732 int wrap;
681 } else { 733
682 pred = a; 734 if(n==1){
683 *dir_ptr = 0; 735 pred=a;
736 *dir_ptr = 0;
737 }else if(n==2){
738 pred=c;
739 *dir_ptr = 1;
740 }else if(n==3){
741 if (abs(a - b) < abs(b - c)) {
742 pred = c;
743 *dir_ptr = 1;
744 } else {
745 pred = a;
746 *dir_ptr = 0;
747 }
748 }else{
749 if(n<4){
750 wrap= s->linesize;
751 dest= s->current_picture[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
752 }else{
753 wrap= s->linesize>>1;
754 dest= s->current_picture[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
755 }
756 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
757 else a= get_dc(dest-8, wrap, scale*8);
758 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
759 else c= get_dc(dest-8*wrap, wrap, scale*8);
760
761 if (s->h263_aic_dir==0) {
762 pred= a;
763 *dir_ptr = 0;
764 }else if (s->h263_aic_dir==1) {
765 if(n==0){
766 pred= c;
767 *dir_ptr = 1;
768 }else{
769 pred= a;
770 *dir_ptr = 0;
771 }
772 }else if (s->h263_aic_dir==2) {
773 if(n==0){
774 pred= a;
775 *dir_ptr = 0;
776 }else{
777 pred= c;
778 *dir_ptr = 1;
779 }
780 } else {
781 pred= c;
782 *dir_ptr = 1;
783 }
784 }
785 }else{
786 if (abs(a - b) < abs(b - c)) {
787 pred = c;
788 *dir_ptr = 1;
789 } else {
790 pred = a;
791 *dir_ptr = 0;
792 }
684 } 793 }
685 }else{ 794 }else{
686 if (abs(a - b) <= abs(b - c)) { 795 if (abs(a - b) <= abs(b - c)) {
687 pred = c; 796 pred = c;
688 *dir_ptr = 1; 797 *dir_ptr = 1;
902 static VLC v2_intra_cbpc_vlc; 1011 static VLC v2_intra_cbpc_vlc;
903 static VLC v2_mb_type_vlc; 1012 static VLC v2_mb_type_vlc;
904 static VLC v2_mv_vlc; 1013 static VLC v2_mv_vlc;
905 static VLC v1_intra_cbpc_vlc; 1014 static VLC v1_intra_cbpc_vlc;
906 static VLC v1_inter_cbpc_vlc; 1015 static VLC v1_inter_cbpc_vlc;
1016 static VLC inter_intra_vlc;
907 1017
908 /* this table is practically identical to the one from h263 except that its inverted */ 1018 /* this table is practically identical to the one from h263 except that its inverted */
909 static void init_h263_dc_for_msmpeg4(void) 1019 static void init_h263_dc_for_msmpeg4(void)
910 { 1020 {
911 int level, uni_code, uni_len; 1021 int level, uni_code, uni_len;
1027 intra_MCBPC_bits, 1, 1, 1137 intra_MCBPC_bits, 1, 1,
1028 intra_MCBPC_code, 1, 1); 1138 intra_MCBPC_code, 1, 1);
1029 init_vlc(&v1_inter_cbpc_vlc, 6, 25, 1139 init_vlc(&v1_inter_cbpc_vlc, 6, 25,
1030 inter_MCBPC_bits, 1, 1, 1140 inter_MCBPC_bits, 1, 1,
1031 inter_MCBPC_code, 1, 1); 1141 inter_MCBPC_code, 1, 1);
1142
1143 init_vlc(&inter_intra_vlc, 3, 4,
1144 &table_inter_intra[0][1], 2, 1,
1145 &table_inter_intra[0][0], 2, 1);
1032 } 1146 }
1033 return 0; 1147 return 0;
1034 } 1148 }
1035 1149
1036 static int decode012(GetBitContext *gb) 1150 static int decode012(GetBitContext *gb)
1073 if (s->pict_type != I_TYPE && 1187 if (s->pict_type != I_TYPE &&
1074 s->pict_type != P_TYPE){ 1188 s->pict_type != P_TYPE){
1075 fprintf(stderr, "invalid picture type\n"); 1189 fprintf(stderr, "invalid picture type\n");
1076 return -1; 1190 return -1;
1077 } 1191 }
1078 1192 #if 0
1193 {
1194 static int had_i=0;
1195 if(s->pict_type == I_TYPE) had_i=1;
1196 if(!had_i) return -1;
1197 }
1198 #endif
1079 s->qscale = get_bits(&s->gb, 5); 1199 s->qscale = get_bits(&s->gb, 5);
1080 1200
1081 if (s->pict_type == I_TYPE) { 1201 if (s->pict_type == I_TYPE) {
1082 code = get_bits(&s->gb, 5); 1202 code = get_bits(&s->gb, 5);
1083 if(s->msmpeg4_version==1){ 1203 if(s->msmpeg4_version==1){
1087 } 1207 }
1088 1208
1089 s->slice_height = code; 1209 s->slice_height = code;
1090 }else{ 1210 }else{
1091 /* 0x17: one slice, 0x18: two slices, ... */ 1211 /* 0x17: one slice, 0x18: two slices, ... */
1092 if (code < 0x17) 1212 if (code < 0x17){
1213 fprintf(stderr, "error, slice code was %X\n", code);
1093 return -1; 1214 return -1;
1215 }
1094 1216
1095 s->slice_height = s->mb_height / (code - 0x16); 1217 s->slice_height = s->mb_height / (code - 0x16);
1096 } 1218 }
1097 1219
1098 switch(s->msmpeg4_version){ 1220 switch(s->msmpeg4_version){
1110 s->dc_table_index = get_bits1(&s->gb); 1232 s->dc_table_index = get_bits1(&s->gb);
1111 break; 1233 break;
1112 case 4: 1234 case 4:
1113 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8); 1235 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1114 1236
1115 s->per_mb_rl_table= get_bits1(&s->gb); 1237 if(s->bit_rate > 50) s->per_mb_rl_table= get_bits1(&s->gb);
1238 else s->per_mb_rl_table= 0;
1239
1116 if(!s->per_mb_rl_table){ 1240 if(!s->per_mb_rl_table){
1117 s->rl_chroma_table_index = decode012(&s->gb); 1241 s->rl_chroma_table_index = decode012(&s->gb);
1118 s->rl_table_index = decode012(&s->gb); 1242 s->rl_table_index = decode012(&s->gb);
1119 } 1243 }
1120 1244
1121 s->dc_table_index = get_bits1(&s->gb); 1245 s->dc_table_index = get_bits1(&s->gb);
1246 s->inter_intra_pred= 0;
1122 break; 1247 break;
1123 } 1248 }
1124 s->no_rounding = 1; 1249 s->no_rounding = 1;
1125 /* printf(" %d %d %d %d %d \n", 1250 /* printf("qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1126 s->qscale, 1251 s->qscale,
1127 s->rl_chroma_table_index, 1252 s->rl_chroma_table_index,
1128 s->rl_table_index, 1253 s->rl_table_index,
1129 s->dc_table_index, 1254 s->dc_table_index,
1130 s->per_mb_rl_table);*/ 1255 s->per_mb_rl_table,
1256 s->slice_height);*/
1131 } else { 1257 } else {
1132
1133 switch(s->msmpeg4_version){ 1258 switch(s->msmpeg4_version){
1134 case 1: 1259 case 1:
1135 case 2: 1260 case 2:
1136 if(s->msmpeg4_version==1) 1261 if(s->msmpeg4_version==1)
1137 s->use_skip_mb_code = 1; 1262 s->use_skip_mb_code = 1;
1151 1276
1152 s->mv_table_index = get_bits1(&s->gb); 1277 s->mv_table_index = get_bits1(&s->gb);
1153 break; 1278 break;
1154 case 4: 1279 case 4:
1155 s->use_skip_mb_code = get_bits1(&s->gb); 1280 s->use_skip_mb_code = get_bits1(&s->gb);
1156 s->per_mb_rl_table= get_bits1(&s->gb); 1281
1282 if(s->bit_rate > 50) s->per_mb_rl_table= get_bits1(&s->gb);
1283 else s->per_mb_rl_table= 0;
1284
1157 if(!s->per_mb_rl_table){ 1285 if(!s->per_mb_rl_table){
1158 s->rl_table_index = decode012(&s->gb); 1286 s->rl_table_index = decode012(&s->gb);
1159 s->rl_chroma_table_index = s->rl_table_index; 1287 s->rl_chroma_table_index = s->rl_table_index;
1160 } 1288 }
1161 1289
1162 s->dc_table_index = get_bits1(&s->gb); 1290 s->dc_table_index = get_bits1(&s->gb);
1163 1291
1164 s->mv_table_index = get_bits1(&s->gb); 1292 s->mv_table_index = get_bits1(&s->gb);
1293 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=128);
1165 break; 1294 break;
1166 } 1295 }
1167 /* printf(" %d %d %d %d %d %d \n", 1296 /* printf("skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1168 s->use_skip_mb_code, 1297 s->use_skip_mb_code,
1169 s->rl_table_index, 1298 s->rl_table_index,
1170 s->rl_chroma_table_index, 1299 s->rl_chroma_table_index,
1171 s->dc_table_index, 1300 s->dc_table_index,
1172 s->mv_table_index, 1301 s->mv_table_index,
1173 s->per_mb_rl_table);*/ 1302 s->per_mb_rl_table,
1303 s->qscale);*/
1174 if(s->flipflop_rounding){ 1304 if(s->flipflop_rounding){
1175 s->no_rounding ^= 1; 1305 s->no_rounding ^= 1;
1176 }else{ 1306 }else{
1177 s->no_rounding = 0; 1307 s->no_rounding = 0;
1178 } 1308 }
1385 printf("\n"); 1515 printf("\n");
1386 if(s->mb_y==0) printf("\n"); 1516 if(s->mb_y==0) printf("\n");
1387 } 1517 }
1388 #endif 1518 #endif
1389 /* special slice handling */ 1519 /* special slice handling */
1390 if (s->mb_x == 0) { 1520 handle_slices(s);
1391 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
1392 int wrap;
1393 /* reset DC pred (set previous line to 1024) */
1394 wrap = 2 * s->mb_width + 2;
1395 msmpeg4_memsetw(&s->dc_val[0][(1) + (2 * s->mb_y) * wrap],
1396 1024, 2 * s->mb_width);
1397 wrap = s->mb_width + 2;
1398 msmpeg4_memsetw(&s->dc_val[1][(1) + (s->mb_y) * wrap],
1399 1024, s->mb_width);
1400 msmpeg4_memsetw(&s->dc_val[2][(1) + (s->mb_y) * wrap],
1401 1024, s->mb_width);
1402
1403 /* reset AC pred (set previous line to 0) */
1404 wrap = s->mb_width * 2 + 2;
1405 msmpeg4_memsetw(s->ac_val[0][0] + (1 + (2 * s->mb_y) * wrap)*16,
1406 0, 2 * s->mb_width*16);
1407 wrap = s->mb_width + 2;
1408 msmpeg4_memsetw(s->ac_val[1][0] + (1 + (s->mb_y) * wrap)*16,
1409 0, s->mb_width*16);
1410 msmpeg4_memsetw(s->ac_val[2][0] + (1 + (s->mb_y) * wrap)*16,
1411 0, s->mb_width*16);
1412
1413 s->first_slice_line = 1;
1414 } else {
1415 s->first_slice_line = 0;
1416 }
1417 }
1418 1521
1419 if(s->msmpeg4_version<=2) return msmpeg4v12_decode_mb(s, block); //FIXME export function & call from outside perhaps 1522 if(s->msmpeg4_version<=2) return msmpeg4v12_decode_mb(s, block); //FIXME export function & call from outside perhaps
1420 1523
1421 if (s->pict_type == P_TYPE) { 1524 if (s->pict_type == P_TYPE) {
1422 set_stat(ST_INTER_MB); 1525 set_stat(ST_INTER_MB);
1487 set_stat(ST_INTRA_MB); 1590 set_stat(ST_INTRA_MB);
1488 s->ac_pred = get_bits1(&s->gb); 1591 s->ac_pred = get_bits1(&s->gb);
1489 #ifdef PRINT_MB 1592 #ifdef PRINT_MB
1490 printf("%c", s->ac_pred ? 'A' : 'I'); 1593 printf("%c", s->ac_pred ? 'A' : 'I');
1491 #endif 1594 #endif
1595 if(s->inter_intra_pred){
1596 s->h263_aic_dir= get_vlc(&s->gb, &inter_intra_vlc);
1597 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1598 }
1492 if(s->per_mb_rl_table && cbp){ 1599 if(s->per_mb_rl_table && cbp){
1493 s->rl_table_index = decode012(&s->gb); 1600 s->rl_table_index = decode012(&s->gb);
1494 s->rl_chroma_table_index = s->rl_table_index; 1601 s->rl_chroma_table_index = s->rl_table_index;
1495 } 1602 }
1496 } 1603 }
1530 c+= c +dc_pred_dir; 1637 c+= c +dc_pred_dir;
1531 } 1638 }
1532 #endif 1639 #endif
1533 if (level < 0){ 1640 if (level < 0){
1534 fprintf(stderr, "dc overflow- block: %d qscale: %d//\n", n, s->qscale); 1641 fprintf(stderr, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1535 return -1; 1642 if(s->inter_intra_pred) level=0;
1643 else return -1;
1536 } 1644 }
1537 if (n < 4) { 1645 if (n < 4) {
1538 rl = &rl_table[s->rl_table_index]; 1646 rl = &rl_table[s->rl_table_index];
1539 if(level > 256*s->y_dc_scale){ 1647 if(level > 256*s->y_dc_scale){
1540 fprintf(stderr, "dc overflow+ L qscale: %d//\n", s->qscale); 1648 fprintf(stderr, "dc overflow+ L qscale: %d//\n", s->qscale);
1541 return -1; 1649 if(!s->inter_intra_pred) return -1;
1542 } 1650 }
1543 } else { 1651 } else {
1544 rl = &rl_table[3 + s->rl_chroma_table_index]; 1652 rl = &rl_table[3 + s->rl_chroma_table_index];
1545 if(level > 256*s->c_dc_scale){ 1653 if(level > 256*s->c_dc_scale){
1546 fprintf(stderr, "dc overflow+ C qscale: %d//\n", s->qscale); 1654 fprintf(stderr, "dc overflow+ C qscale: %d//\n", s->qscale);
1547 return -1; 1655 if(!s->inter_intra_pred) return -1;
1548 } 1656 }
1549 } 1657 }
1550 block[0] = level; 1658 block[0] = level;
1551 1659
1552 run_diff = 0; 1660 run_diff = 0;