Mercurial > libavcodec.hg

comparison mpegvideo.c @ 1708:dea5b2946999 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
interlaced motion estimation interlaced mpeg2 encoding P & B frames rate distored interlaced mb decission alternate scantable support 4mv encoding fixes (thats also why the regression tests change) passing height to most dsp functions interlaced mpeg4 encoding (no direct mode MBs yet) various related cleanups disabled old motion estimaton algorithms (log, full, ...) they will either be fixed or removed
author michael
date Tue, 30 Dec 2003 16:07:57 +0000
parents 027545a2fdbe
children f2f8eddf1b13
comparison
equal deleted inserted replaced
1707:027545a2fdbe 1708:dea5b2946999
250 #endif //CONFIG_ENCODERS 250 #endif //CONFIG_ENCODERS
251 251
252 /* load & permutate scantables 252 /* load & permutate scantables
253 note: only wmv uses differnt ones 253 note: only wmv uses differnt ones
254 */ 254 */
255 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); 255 if(s->alternate_scan){
256 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); 256 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
257 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
258 }else{
259 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
260 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
261 }
257 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); 262 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
258 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); 263 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
259 264
260 s->picture_structure= PICT_FRAME; 265 s->picture_structure= PICT_FRAME;
261 266
392 } 397 }
393 398
394 /* init common structure for both encoder and decoder */ 399 /* init common structure for both encoder and decoder */
395 int MPV_common_init(MpegEncContext *s) 400 int MPV_common_init(MpegEncContext *s)
396 { 401 {
397 int y_size, c_size, yc_size, i, mb_array_size, x, y; 402 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
398 403
399 dsputil_init(&s->dsp, s->avctx); 404 dsputil_init(&s->dsp, s->avctx);
400 DCT_common_init(s); 405 DCT_common_init(s);
401 406
402 s->flags= s->avctx->flags; 407 s->flags= s->avctx->flags;
405 s->mb_height = (s->height + 15) / 16; 410 s->mb_height = (s->height + 15) / 16;
406 s->mb_stride = s->mb_width + 1; 411 s->mb_stride = s->mb_width + 1;
407 s->b8_stride = s->mb_width*2 + 1; 412 s->b8_stride = s->mb_width*2 + 1;
408 s->b4_stride = s->mb_width*4 + 1; 413 s->b4_stride = s->mb_width*4 + 1;
409 mb_array_size= s->mb_height * s->mb_stride; 414 mb_array_size= s->mb_height * s->mb_stride;
415 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
410 416
411 /* set default edge pos, will be overriden in decode_header if needed */ 417 /* set default edge pos, will be overriden in decode_header if needed */
412 s->h_edge_pos= s->mb_width*16; 418 s->h_edge_pos= s->mb_width*16;
413 s->v_edge_pos= s->mb_height*16; 419 s->v_edge_pos= s->mb_height*16;
414 420
456 } 462 }
457 } 463 }
458 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed? 464 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
459 465
460 if (s->encoding) { 466 if (s->encoding) {
461 int mv_table_size= s->mb_stride * (s->mb_height+2) + 1;
462
463 /* Allocate MV tables */ 467 /* Allocate MV tables */
464 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) 468 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
465 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) 469 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
466 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) 470 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
467 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) 471 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
489 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int)); 493 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
490 } 494 }
491 CHECKED_ALLOCZ(s->avctx->stats_out, 256); 495 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
492 496
493 /* Allocate MB type table */ 497 /* Allocate MB type table */
494 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint8_t)) //needed for encoding 498 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
495 499
496 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int)) 500 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
497 501
498 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int)) 502 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
499 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int)) 503 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
511 515
512 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture)) 516 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
513 517
514 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t)) 518 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
515 519
516 if(s->codec_id==CODEC_ID_MPEG4){ 520 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
517 /* interlaced direct mode decoding tables */ 521 /* interlaced direct mode decoding tables */
518 CHECKED_ALLOCZ(s->field_mv_table, mb_array_size*2*2 * sizeof(int16_t)) 522 for(i=0; i<2; i++){
519 CHECKED_ALLOCZ(s->field_select_table, mb_array_size*2* sizeof(int8_t)) 523 int j, k;
524 for(j=0; j<2; j++){
525 for(k=0; k<2; k++){
526 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
527 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
528 }
529 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
530 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
531 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
532 }
533 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
534 }
520 } 535 }
521 if (s->out_format == FMT_H263) { 536 if (s->out_format == FMT_H263) {
522 /* ac values */ 537 /* ac values */
523 CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16); 538 CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
524 s->ac_val[1] = s->ac_val[0] + y_size; 539 s->ac_val[1] = s->ac_val[0] + y_size;
581 //extern int sads; 596 //extern int sads;
582 597
583 /* init common structure for both encoder and decoder */ 598 /* init common structure for both encoder and decoder */
584 void MPV_common_end(MpegEncContext *s) 599 void MPV_common_end(MpegEncContext *s)
585 { 600 {
586 int i; 601 int i, j, k;
587 602
588 av_freep(&s->parse_context.buffer); 603 av_freep(&s->parse_context.buffer);
589 s->parse_context.buffer_size=0; 604 s->parse_context.buffer_size=0;
590 605
591 av_freep(&s->mb_type); 606 av_freep(&s->mb_type);
599 s->b_forw_mv_table= NULL; 614 s->b_forw_mv_table= NULL;
600 s->b_back_mv_table= NULL; 615 s->b_back_mv_table= NULL;
601 s->b_bidir_forw_mv_table= NULL; 616 s->b_bidir_forw_mv_table= NULL;
602 s->b_bidir_back_mv_table= NULL; 617 s->b_bidir_back_mv_table= NULL;
603 s->b_direct_mv_table= NULL; 618 s->b_direct_mv_table= NULL;
619 for(i=0; i<2; i++){
620 for(j=0; j<2; j++){
621 for(k=0; k<2; k++){
622 av_freep(&s->b_field_mv_table_base[i][j][k]);
623 s->b_field_mv_table[i][j][k]=NULL;
624 }
625 av_freep(&s->b_field_select_table[i][j]);
626 av_freep(&s->p_field_mv_table_base[i][j]);
627 s->p_field_mv_table[i][j]=NULL;
628 }
629 av_freep(&s->p_field_select_table[i]);
630 }
604 631
605 av_freep(&s->dc_val[0]); 632 av_freep(&s->dc_val[0]);
606 av_freep(&s->ac_val[0]); 633 av_freep(&s->ac_val[0]);
607 av_freep(&s->coded_block); 634 av_freep(&s->coded_block);
608 av_freep(&s->mbintra_table); 635 av_freep(&s->mbintra_table);
616 av_freep(&s->prev_pict_types); 643 av_freep(&s->prev_pict_types);
617 av_freep(&s->bitstream_buffer); 644 av_freep(&s->bitstream_buffer);
618 av_freep(&s->tex_pb_buffer); 645 av_freep(&s->tex_pb_buffer);
619 av_freep(&s->pb2_buffer); 646 av_freep(&s->pb2_buffer);
620 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL; 647 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
621 av_freep(&s->field_mv_table);
622 av_freep(&s->field_select_table);
623 av_freep(&s->avctx->stats_out); 648 av_freep(&s->avctx->stats_out);
624 av_freep(&s->ac_stats); 649 av_freep(&s->ac_stats);
625 av_freep(&s->error_status_table); 650 av_freep(&s->error_status_table);
626 av_freep(&s->mb_index2xy); 651 av_freep(&s->mb_index2xy);
627 av_freep(&s->lambda_table); 652 av_freep(&s->lambda_table);
690 } 715 }
691 716
692 s->me_method = avctx->me_method; 717 s->me_method = avctx->me_method;
693 718
694 /* Fixed QSCALE */ 719 /* Fixed QSCALE */
695 s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE); 720 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
696 721
697 s->adaptive_quant= ( s->avctx->lumi_masking 722 s->adaptive_quant= ( s->avctx->lumi_masking
698 || s->avctx->dark_masking 723 || s->avctx->dark_masking
699 || s->avctx->temporal_cplx_masking 724 || s->avctx->temporal_cplx_masking
700 || s->avctx->spatial_cplx_masking 725 || s->avctx->spatial_cplx_masking
701 || s->avctx->p_masking 726 || s->avctx->p_masking
702 || (s->flags&CODEC_FLAG_QP_RD)) 727 || (s->flags&CODEC_FLAG_QP_RD))
703 && !s->fixed_qscale; 728 && !s->fixed_qscale;
704 729
705 s->obmc= (s->flags & CODEC_FLAG_OBMC); 730 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
706 s->loop_filter= (s->flags & CODEC_FLAG_LOOP_FILTER); 731 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
732 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
707 733
708 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 734 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
709 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){ 735 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
710 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n"); 736 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
711 return -1; 737 return -1;
932 return -1; 958 return -1;
933 959
934 if(s->modified_quant) 960 if(s->modified_quant)
935 s->chroma_qscale_table= ff_h263_chroma_qscale_table; 961 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
936 s->progressive_frame= 962 s->progressive_frame=
937 s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT); 963 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
938 964
939 ff_init_me(s); 965 ff_init_me(s);
940 966
941 #ifdef CONFIG_ENCODERS 967 #ifdef CONFIG_ENCODERS
942 #ifdef CONFIG_RISKY 968 #ifdef CONFIG_RISKY
1608 h= s->height&~15; 1634 h= s->height&~15;
1609 1635
1610 for(y=0; y<h; y+=16){ 1636 for(y=0; y<h; y+=16){
1611 for(x=0; x<w; x+=16){ 1637 for(x=0; x<w; x+=16){
1612 int offset= x + y*stride; 1638 int offset= x + y*stride;
1613 int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride); 1639 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1614 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8; 1640 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1615 int sae = get_sae(src + offset, mean, stride); 1641 int sae = get_sae(src + offset, mean, stride);
1616 1642
1617 acc+= sae + 500 < sad; 1643 acc+= sae + 500 < sad;
1618 } 1644 }
1904 1930
1905 /* update mpeg1/2 vbv_delay for CBR */ 1931 /* update mpeg1/2 vbv_delay for CBR */
1906 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate){ 1932 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate){
1907 int vbv_delay; 1933 int vbv_delay;
1908 1934
1909 assert(s->repeat_first_field==0 && s->avctx->repeat_pic==0); 1935 assert(s->repeat_first_field==0);
1910 1936
1911 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate); 1937 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
1912 assert(vbv_delay < 0xFFFF); 1938 assert(vbv_delay < 0xFFFF);
1913 1939
1914 s->vbv_delay_ptr[0] &= 0xF8; 1940 s->vbv_delay_ptr[0] &= 0xF8;
3298 emu=1; 3324 emu=1;
3299 } 3325 }
3300 3326
3301 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ 3327 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3302 int progressive_score, interlaced_score; 3328 int progressive_score, interlaced_score;
3303 3329
3304 progressive_score= pix_vcmp16x8(ptr, wrap_y ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y ); 3330 progressive_score= pix_vcmp16x8(ptr, wrap_y ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
3305 interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y , wrap_y*2); 3331 interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y , wrap_y*2);
3306 3332
3307 if(progressive_score > interlaced_score + 100){ 3333 if(progressive_score > interlaced_score + 100){
3308 s->interlaced_dct=1; 3334 s->interlaced_dct=1;
3415 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c); 3441 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3416 } 3442 }
3417 /* pre quantization */ 3443 /* pre quantization */
3418 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){ 3444 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3419 //FIXME optimize 3445 //FIXME optimize
3420 if(s->dsp.pix_abs8x8(ptr_y , dest_y , wrap_y) < 20*s->qscale) skip_dct[0]= 1; 3446 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3421 if(s->dsp.pix_abs8x8(ptr_y + 8, dest_y + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1; 3447 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3422 if(s->dsp.pix_abs8x8(ptr_y +dct_offset , dest_y +dct_offset , wrap_y) < 20*s->qscale) skip_dct[2]= 1; 3448 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3423 if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1; 3449 if(s->dsp.sad[1](NULL, ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y, 8) < 20*s->qscale) skip_dct[3]= 1;
3424 if(s->dsp.pix_abs8x8(ptr_cb , dest_cb , wrap_c) < 20*s->qscale) skip_dct[4]= 1; 3450 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3425 if(s->dsp.pix_abs8x8(ptr_cr , dest_cr , wrap_c) < 20*s->qscale) skip_dct[5]= 1; 3451 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3426 #if 0 3452 #if 0
3427 { 3453 {
3428 static int stat[7]; 3454 static int stat[7];
3429 int num=0; 3455 int num=0;
3430 for(i=0; i<6; i++) 3456 for(i=0; i<6; i++)
3480 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){ 3506 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3481 s->block_last_index[4]= 3507 s->block_last_index[4]=
3482 s->block_last_index[5]= 0; 3508 s->block_last_index[5]= 0;
3483 s->block[4][0]= 3509 s->block[4][0]=
3484 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale; 3510 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3511 }
3512
3513 //non c quantize code returns incorrect block_last_index FIXME
3514 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3515 for(i=0; i<6; i++){
3516 int j;
3517 if(s->block_last_index[i]>0){
3518 for(j=63; j>0; j--){
3519 if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3520 }
3521 s->block_last_index[i]= j;
3522 }
3523 }
3485 } 3524 }
3486 3525
3487 /* huffman encode */ 3526 /* huffman encode */
3488 switch(s->codec_id){ //FIXME funct ptr could be slightly faster 3527 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3489 case CODEC_ID_MPEG1VIDEO: 3528 case CODEC_ID_MPEG1VIDEO:
3722 uint32_t *sq = squareTbl + 256; 3761 uint32_t *sq = squareTbl + 256;
3723 int acc=0; 3762 int acc=0;
3724 int x,y; 3763 int x,y;
3725 3764
3726 if(w==16 && h==16) 3765 if(w==16 && h==16)
3727 return s->dsp.sse[0](NULL, src1, src2, stride); 3766 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3728 else if(w==8 && h==8) 3767 else if(w==8 && h==8)
3729 return s->dsp.sse[1](NULL, src1, src2, stride); 3768 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3730 3769
3731 for(y=0; y<h; y++){ 3770 for(y=0; y<h; y++){
3732 for(x=0; x<w; x++){ 3771 for(x=0; x<w; x++){
3733 acc+= sq[src1[x + y*stride] - src2[x + y*stride]]; 3772 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3734 } 3773 }
3745 3784
3746 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; 3785 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3747 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; 3786 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3748 3787
3749 if(w==16 && h==16) 3788 if(w==16 && h==16)
3750 return s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize) 3789 return s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
3751 +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize) 3790 +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
3752 +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize); 3791 +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
3753 else 3792 else
3754 return sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize) 3793 return sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
3755 +sse(s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize) 3794 +sse(s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
3756 +sse(s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize); 3795 +sse(s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
3757 } 3796 }
3758 3797
3759 static void encode_picture(MpegEncContext *s, int picture_number) 3798 static void encode_picture(MpegEncContext *s, int picture_number)
3760 { 3799 {
3761 int mb_x, mb_y, pdif = 0; 3800 int mb_x, mb_y, pdif = 0;
3762 int i; 3801 int i, j;
3763 int bits; 3802 int bits;
3764 MpegEncContext best_s, backup_s; 3803 MpegEncContext best_s, backup_s;
3765 uint8_t bit_buf[2][3000]; 3804 uint8_t bit_buf[2][3000];
3766 uint8_t bit_buf2[2][3000]; 3805 uint8_t bit_buf2[2][3000];
3767 uint8_t bit_buf_tex[2][3000]; 3806 uint8_t bit_buf_tex[2][3000];
3841 }else /* if(s->pict_type == I_TYPE) */{ 3880 }else /* if(s->pict_type == I_TYPE) */{
3842 /* I-Frame */ 3881 /* I-Frame */
3843 //FIXME do we need to zero them? 3882 //FIXME do we need to zero them?
3844 memset(s->current_picture.motion_val[0][0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2); 3883 memset(s->current_picture.motion_val[0][0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3845 memset(s->p_mv_table , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2); 3884 memset(s->p_mv_table , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3846 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height); 3885 for(i=0; i<s->mb_stride*s->mb_height; i++)
3886 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3847 3887
3848 if(!s->fixed_qscale){ 3888 if(!s->fixed_qscale){
3849 /* finding spatial complexity for I-frame rate control */ 3889 /* finding spatial complexity for I-frame rate control */
3850 for(mb_y=0; mb_y < s->mb_height; mb_y++) { 3890 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3851 for(mb_x=0; mb_x < s->mb_width; mb_x++) { 3891 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3866 } 3906 }
3867 emms_c(); 3907 emms_c();
3868 3908
3869 if(s->scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){ 3909 if(s->scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
3870 s->pict_type= I_TYPE; 3910 s->pict_type= I_TYPE;
3871 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height); 3911 for(i=0; i<s->mb_stride*s->mb_height; i++)
3912 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3872 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum); 3913 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3873 } 3914 }
3874 3915
3875 if(!s->umvplus){ 3916 if(!s->umvplus){
3876 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) { 3917 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3877 s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER); 3918 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3878 3919
3920 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3921 int a,b;
3922 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3923 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3924 s->f_code= FFMAX(s->f_code, FFMAX(a,b));
3925 }
3926
3879 ff_fix_long_p_mvs(s); 3927 ff_fix_long_p_mvs(s);
3928 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3929 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3930 for(i=0; i<2; i++){
3931 for(j=0; j<2; j++)
3932 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3933 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3934 }
3935 }
3880 } 3936 }
3881 3937
3882 if(s->pict_type==B_TYPE){ 3938 if(s->pict_type==B_TYPE){
3883 int a, b; 3939 int a, b;
3884 3940
3885 a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD); 3941 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3886 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR); 3942 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3887 s->f_code = FFMAX(a, b); 3943 s->f_code = FFMAX(a, b);
3888 3944
3889 a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD); 3945 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3890 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR); 3946 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3891 s->b_code = FFMAX(a, b); 3947 s->b_code = FFMAX(a, b);
3892 3948
3893 ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD); 3949 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3894 ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD); 3950 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3895 ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR); 3951 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3896 ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR); 3952 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3953 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3954 int dir;
3955 for(dir=0; dir<2; dir++){
3956 for(i=0; i<2; i++){
3957 for(j=0; j<2; j++){
3958 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3959 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3960 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3961 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3962 }
3963 }
3964 }
3965 }
3897 } 3966 }
3898 } 3967 }
3899 3968
3900 if (!s->fixed_qscale) 3969 if (!s->fixed_qscale)
3901 s->current_picture.quality = ff_rate_estimate_qscale(s); 3970 s->current_picture.quality = ff_rate_estimate_qscale(s);
3988 s->last_dc[i] = 128; 4057 s->last_dc[i] = 128;
3989 4058
3990 s->current_picture_ptr->error[i] = 0; 4059 s->current_picture_ptr->error[i] = 0;
3991 } 4060 }
3992 s->mb_skip_run = 0; 4061 s->mb_skip_run = 0;
3993 s->last_mv[0][0][0] = 0; 4062 memset(s->last_mv, 0, sizeof(s->last_mv));
3994 s->last_mv[0][0][1] = 0;
3995 s->last_mv[1][0][0] = 0;
3996 s->last_mv[1][0][1] = 0;
3997 4063
3998 s->last_mv_dir = 0; 4064 s->last_mv_dir = 0;
3999 4065
4000 #ifdef CONFIG_RISKY 4066 #ifdef CONFIG_RISKY
4001 switch(s->codec_id){ 4067 switch(s->codec_id){
4025 for(mb_x=0; mb_x < s->mb_width; mb_x++) { 4091 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4026 const int xy= mb_y*s->mb_stride + mb_x; 4092 const int xy= mb_y*s->mb_stride + mb_x;
4027 int mb_type= s->mb_type[xy]; 4093 int mb_type= s->mb_type[xy];
4028 // int d; 4094 // int d;
4029 int dmin= INT_MAX; 4095 int dmin= INT_MAX;
4096 int dir;
4030 4097
4031 s->mb_x = mb_x; 4098 s->mb_x = mb_x;
4032 ff_update_block_index(s); 4099 ff_update_block_index(s);
4033 4100
4034 /* write gob / video packet header */ 4101 /* write gob / video packet header */
4132 if(s->data_partitioning){ 4199 if(s->data_partitioning){
4133 backup_s.pb2= s->pb2; 4200 backup_s.pb2= s->pb2;
4134 backup_s.tex_pb= s->tex_pb; 4201 backup_s.tex_pb= s->tex_pb;
4135 } 4202 }
4136 4203
4137 if(mb_type&MB_TYPE_INTER){ 4204 if(mb_type&CANDIDATE_MB_TYPE_INTER){
4138 s->mv_dir = MV_DIR_FORWARD; 4205 s->mv_dir = MV_DIR_FORWARD;
4139 s->mv_type = MV_TYPE_16X16; 4206 s->mv_type = MV_TYPE_16X16;
4140 s->mb_intra= 0; 4207 s->mb_intra= 0;
4141 s->mv[0][0][0] = s->p_mv_table[xy][0]; 4208 s->mv[0][0][0] = s->p_mv_table[xy][0];
4142 s->mv[0][0][1] = s->p_mv_table[xy][1]; 4209 s->mv[0][0][1] = s->p_mv_table[xy][1];
4143 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 4210 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
4144 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); 4211 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4145 } 4212 }
4146 if(mb_type&MB_TYPE_SKIPED){ 4213 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
4214 s->mv_dir = MV_DIR_FORWARD;
4215 s->mv_type = MV_TYPE_FIELD;
4216 s->mb_intra= 0;
4217 for(i=0; i<2; i++){
4218 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4219 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4220 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4221 }
4222 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
4223 &dmin, &next_block, 0, 0);
4224 }
4225 if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4147 s->mv_dir = MV_DIR_FORWARD; 4226 s->mv_dir = MV_DIR_FORWARD;
4148 s->mv_type = MV_TYPE_16X16; 4227 s->mv_type = MV_TYPE_16X16;
4149 s->mb_intra= 0; 4228 s->mb_intra= 0;
4150 s->mv[0][0][0] = 0; 4229 s->mv[0][0][0] = 0;
4151 s->mv[0][0][1] = 0; 4230 s->mv[0][0][1] = 0;
4152 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_SKIPED, pb, pb2, tex_pb, 4231 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb,
4153 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); 4232 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4154 } 4233 }
4155 if(mb_type&MB_TYPE_INTER4V){ 4234 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
4156 s->mv_dir = MV_DIR_FORWARD; 4235 s->mv_dir = MV_DIR_FORWARD;
4157 s->mv_type = MV_TYPE_8X8; 4236 s->mv_type = MV_TYPE_8X8;
4158 s->mb_intra= 0; 4237 s->mb_intra= 0;
4159 for(i=0; i<4; i++){ 4238 for(i=0; i<4; i++){
4160 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0]; 4239 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4161 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; 4240 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4162 } 4241 }
4163 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 4242 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
4164 &dmin, &next_block, 0, 0); 4243 &dmin, &next_block, 0, 0);
4165 } 4244 }
4166 if(mb_type&MB_TYPE_FORWARD){ 4245 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
4167 s->mv_dir = MV_DIR_FORWARD; 4246 s->mv_dir = MV_DIR_FORWARD;
4168 s->mv_type = MV_TYPE_16X16; 4247 s->mv_type = MV_TYPE_16X16;
4169 s->mb_intra= 0; 4248 s->mb_intra= 0;
4170 s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; 4249 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4171 s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; 4250 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4172 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 4251 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
4173 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); 4252 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4174 } 4253 }
4175 if(mb_type&MB_TYPE_BACKWARD){ 4254 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
4176 s->mv_dir = MV_DIR_BACKWARD; 4255 s->mv_dir = MV_DIR_BACKWARD;
4177 s->mv_type = MV_TYPE_16X16; 4256 s->mv_type = MV_TYPE_16X16;
4178 s->mb_intra= 0; 4257 s->mb_intra= 0;
4179 s->mv[1][0][0] = s->b_back_mv_table[xy][0]; 4258 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4180 s->mv[1][0][1] = s->b_back_mv_table[xy][1]; 4259 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4181 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 4260 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
4182 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]); 4261 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4183 } 4262 }
4184 if(mb_type&MB_TYPE_BIDIR){ 4263 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
4185 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; 4264 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4186 s->mv_type = MV_TYPE_16X16; 4265 s->mv_type = MV_TYPE_16X16;
4187 s->mb_intra= 0; 4266 s->mb_intra= 0;
4188 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; 4267 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4189 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; 4268 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4190 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; 4269 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4191 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; 4270 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4192 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 4271 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
4193 &dmin, &next_block, 0, 0); 4272 &dmin, &next_block, 0, 0);
4194 } 4273 }
4195 if(mb_type&MB_TYPE_DIRECT){ 4274 if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
4196 int mx= s->b_direct_mv_table[xy][0]; 4275 int mx= s->b_direct_mv_table[xy][0];
4197 int my= s->b_direct_mv_table[xy][1]; 4276 int my= s->b_direct_mv_table[xy][1];
4198 4277
4199 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; 4278 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4200 s->mb_intra= 0; 4279 s->mb_intra= 0;
4201 #ifdef CONFIG_RISKY 4280 #ifdef CONFIG_RISKY
4202 ff_mpeg4_set_direct_mv(s, mx, my); 4281 ff_mpeg4_set_direct_mv(s, mx, my);
4203 #endif 4282 #endif
4204 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 4283 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
4205 &dmin, &next_block, mx, my); 4284 &dmin, &next_block, mx, my);
4206 } 4285 }
4207 if(mb_type&MB_TYPE_INTRA){ 4286 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
4287 s->mv_dir = MV_DIR_FORWARD;
4288 s->mv_type = MV_TYPE_FIELD;
4289 s->mb_intra= 0;
4290 for(i=0; i<2; i++){
4291 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4292 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4293 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4294 }
4295 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
4296 &dmin, &next_block, 0, 0);
4297 }
4298 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
4299 s->mv_dir = MV_DIR_BACKWARD;
4300 s->mv_type = MV_TYPE_FIELD;
4301 s->mb_intra= 0;
4302 for(i=0; i<2; i++){
4303 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4304 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4305 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4306 }
4307 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
4308 &dmin, &next_block, 0, 0);
4309 }
4310 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
4311 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4312 s->mv_type = MV_TYPE_FIELD;
4313 s->mb_intra= 0;
4314 for(dir=0; dir<2; dir++){
4315 for(i=0; i<2; i++){
4316 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4317 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4318 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4319 }
4320 }
4321 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
4322 &dmin, &next_block, 0, 0);
4323 }
4324 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
4208 s->mv_dir = 0; 4325 s->mv_dir = 0;
4209 s->mv_type = MV_TYPE_16X16; 4326 s->mv_type = MV_TYPE_16X16;
4210 s->mb_intra= 1; 4327 s->mb_intra= 1;
4211 s->mv[0][0][0] = 0; 4328 s->mv[0][0][0] = 0;
4212 s->mv[0][0][1] = 0; 4329 s->mv[0][0][1] = 0;
4213 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 4330 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
4214 &dmin, &next_block, 0, 0); 4331 &dmin, &next_block, 0, 0);
4215 if(s->h263_pred || s->h263_aic){ 4332 if(s->h263_pred || s->h263_aic){
4216 if(best_s.mb_intra) 4333 if(best_s.mb_intra)
4217 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1; 4334 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4218 else 4335 else
4250 dc[i]= s->dc_val[0][ s->block_index[i] ]; 4367 dc[i]= s->dc_val[0][ s->block_index[i] ];
4251 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16); 4368 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4252 } 4369 }
4253 } 4370 }
4254 4371
4255 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 4372 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
4256 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]); 4373 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4257 if(best_s.qscale != qp){ 4374 if(best_s.qscale != qp){
4258 if(s->mb_intra){ 4375 if(s->mb_intra){
4259 for(i=0; i<6; i++){ 4376 for(i=0; i<6; i++){
4260 s->dc_val[0][ s->block_index[i] ]= dc[i]; 4377 s->dc_val[0][ s->block_index[i] ]= dc[i];
4310 int motion_x, motion_y; 4427 int motion_x, motion_y;
4311 s->mv_type=MV_TYPE_16X16; 4428 s->mv_type=MV_TYPE_16X16;
4312 // only one MB-Type possible 4429 // only one MB-Type possible
4313 4430
4314 switch(mb_type){ 4431 switch(mb_type){
4315 case MB_TYPE_INTRA: 4432 case CANDIDATE_MB_TYPE_INTRA:
4316 s->mv_dir = 0; 4433 s->mv_dir = 0;
4317 s->mb_intra= 1; 4434 s->mb_intra= 1;
4318 motion_x= s->mv[0][0][0] = 0; 4435 motion_x= s->mv[0][0][0] = 0;
4319 motion_y= s->mv[0][0][1] = 0; 4436 motion_y= s->mv[0][0][1] = 0;
4320 break; 4437 break;
4321 case MB_TYPE_INTER: 4438 case CANDIDATE_MB_TYPE_INTER:
4322 s->mv_dir = MV_DIR_FORWARD; 4439 s->mv_dir = MV_DIR_FORWARD;
4323 s->mb_intra= 0; 4440 s->mb_intra= 0;
4324 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0]; 4441 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
4325 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1]; 4442 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
4326 break; 4443 break;
4327 case MB_TYPE_INTER4V: 4444 case CANDIDATE_MB_TYPE_INTER_I:
4445 s->mv_dir = MV_DIR_FORWARD;
4446 s->mv_type = MV_TYPE_FIELD;
4447 s->mb_intra= 0;
4448 for(i=0; i<2; i++){
4449 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4450 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4451 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4452 }
4453 motion_x = motion_y = 0;
4454 break;
4455 case CANDIDATE_MB_TYPE_INTER4V:
4328 s->mv_dir = MV_DIR_FORWARD; 4456 s->mv_dir = MV_DIR_FORWARD;
4329 s->mv_type = MV_TYPE_8X8; 4457 s->mv_type = MV_TYPE_8X8;
4330 s->mb_intra= 0; 4458 s->mb_intra= 0;
4331 for(i=0; i<4; i++){ 4459 for(i=0; i<4; i++){
4332 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0]; 4460 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4333 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; 4461 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4334 } 4462 }
4335 motion_x= motion_y= 0; 4463 motion_x= motion_y= 0;
4336 break; 4464 break;
4337 case MB_TYPE_DIRECT: 4465 case CANDIDATE_MB_TYPE_DIRECT:
4338 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; 4466 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4339 s->mb_intra= 0; 4467 s->mb_intra= 0;
4340 motion_x=s->b_direct_mv_table[xy][0]; 4468 motion_x=s->b_direct_mv_table[xy][0];
4341 motion_y=s->b_direct_mv_table[xy][1]; 4469 motion_y=s->b_direct_mv_table[xy][1];
4342 #ifdef CONFIG_RISKY 4470 #ifdef CONFIG_RISKY
4343 ff_mpeg4_set_direct_mv(s, motion_x, motion_y); 4471 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
4344 #endif 4472 #endif
4345 break; 4473 break;
4346 case MB_TYPE_BIDIR: 4474 case CANDIDATE_MB_TYPE_BIDIR:
4347 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; 4475 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4348 s->mb_intra= 0; 4476 s->mb_intra= 0;
4349 motion_x=0; 4477 motion_x=0;
4350 motion_y=0; 4478 motion_y=0;
4351 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; 4479 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4352 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; 4480 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4353 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; 4481 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4354 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; 4482 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4355 break; 4483 break;
4356 case MB_TYPE_BACKWARD: 4484 case CANDIDATE_MB_TYPE_BACKWARD:
4357 s->mv_dir = MV_DIR_BACKWARD; 4485 s->mv_dir = MV_DIR_BACKWARD;
4358 s->mb_intra= 0; 4486 s->mb_intra= 0;
4359 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0]; 4487 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4360 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1]; 4488 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4361 break; 4489 break;
4362 case MB_TYPE_FORWARD: 4490 case CANDIDATE_MB_TYPE_FORWARD:
4363 s->mv_dir = MV_DIR_FORWARD; 4491 s->mv_dir = MV_DIR_FORWARD;
4364 s->mb_intra= 0; 4492 s->mb_intra= 0;
4365 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; 4493 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4366 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; 4494 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4367 // printf(" %d %d ", motion_x, motion_y); 4495 // printf(" %d %d ", motion_x, motion_y);
4496 break;
4497 case CANDIDATE_MB_TYPE_FORWARD_I:
4498 s->mv_dir = MV_DIR_FORWARD;
4499 s->mv_type = MV_TYPE_FIELD;
4500 s->mb_intra= 0;
4501 for(i=0; i<2; i++){
4502 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4503 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4504 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4505 }
4506 motion_x=motion_y=0;
4507 break;
4508 case CANDIDATE_MB_TYPE_BACKWARD_I:
4509 s->mv_dir = MV_DIR_BACKWARD;
4510 s->mv_type = MV_TYPE_FIELD;
4511 s->mb_intra= 0;
4512 for(i=0; i<2; i++){
4513 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4514 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4515 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4516 }
4517 motion_x=motion_y=0;
4518 break;
4519 case CANDIDATE_MB_TYPE_BIDIR_I:
4520 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4521 s->mv_type = MV_TYPE_FIELD;
4522 s->mb_intra= 0;
4523 for(dir=0; dir<2; dir++){
4524 for(i=0; i<2; i++){
4525 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4526 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4527 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4528 }
4529 }
4530 motion_x=motion_y=0;
4368 break; 4531 break;
4369 default: 4532 default:
4370 motion_x=motion_y=0; //gcc warning fix 4533 motion_x=motion_y=0; //gcc warning fix
4371 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n"); 4534 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
4372 } 4535 }