Mercurial > libavcodec.hg

comparison mpegvideo.c @ 1389:da0b3a50d209 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rate distortion mb decision support fix decoding of old %16!=0 divx fix assertion failure in motion_est.c
author michaelni
date Tue, 29 Jul 2003 02:09:12 +0000
parents 18cdce49339e
children ba99a78bcb37
comparison
equal deleted inserted replaced
1388:b5c65adac96a 1389:da0b3a50d209
48 DCTELEM *block, int n, int qscale); 48 DCTELEM *block, int n, int qscale);
49 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w); 49 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
50 #ifdef CONFIG_ENCODERS 50 #ifdef CONFIG_ENCODERS
51 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); 51 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
52 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); 52 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
53 static int sse_mb(MpegEncContext *s);
53 #endif //CONFIG_ENCODERS 54 #endif //CONFIG_ENCODERS
54 55
55 #ifdef HAVE_XVMC 56 #ifdef HAVE_XVMC
56 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx); 57 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
57 extern void XVMC_field_end(MpegEncContext *s); 58 extern void XVMC_field_end(MpegEncContext *s);
2423 } 2424 }
2424 } 2425 }
2425 else if (s->h263_pred || s->h263_aic) 2426 else if (s->h263_pred || s->h263_aic)
2426 s->mbintra_table[mb_xy]=1; 2427 s->mbintra_table[mb_xy]=1;
2427 2428
2428 /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
2429 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
2430 //FIXME a lot of thet is only needed for !low_delay
2431 const int wrap = s->block_wrap[0];
2432 const int xy = s->block_index[0];
2433 if(s->mv_type != MV_TYPE_8X8){
2434 int motion_x, motion_y;
2435 if (s->mb_intra) {
2436 motion_x = 0;
2437 motion_y = 0;
2438 } else if (s->mv_type == MV_TYPE_16X16) {
2439 motion_x = s->mv[0][0][0];
2440 motion_y = s->mv[0][0][1];
2441 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2442 int i;
2443 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2444 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2445 motion_x = (motion_x>>1) | (motion_x&1);
2446 for(i=0; i<2; i++){
2447 s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
2448 s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
2449 s->field_select_table[mb_xy][i]= s->field_select[0][i];
2450 }
2451 }
2452
2453 /* no update if 8X8 because it has been done during parsing */
2454 s->motion_val[xy][0] = motion_x;
2455 s->motion_val[xy][1] = motion_y;
2456 s->motion_val[xy + 1][0] = motion_x;
2457 s->motion_val[xy + 1][1] = motion_y;
2458 s->motion_val[xy + wrap][0] = motion_x;
2459 s->motion_val[xy + wrap][1] = motion_y;
2460 s->motion_val[xy + 1 + wrap][0] = motion_x;
2461 s->motion_val[xy + 1 + wrap][1] = motion_y;
2462 }
2463
2464 if(s->encoding){ //FIXME encoding MUST be cleaned up
2465 if (s->mv_type == MV_TYPE_8X8)
2466 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
2467 else
2468 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
2469 }
2470 }
2471
2472 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc 2429 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2473 uint8_t *dest_y, *dest_cb, *dest_cr; 2430 uint8_t *dest_y, *dest_cb, *dest_cr;
2474 int dct_linesize, dct_offset; 2431 int dct_linesize, dct_offset;
2475 op_pixels_func (*op_pix)[4]; 2432 op_pixels_func (*op_pix)[4];
2476 qpel_mc_func (*op_qpix)[16]; 2433 qpel_mc_func (*op_qpix)[16];
2477 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics 2434 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2478 const int uvlinesize= s->current_picture.linesize[1]; 2435 const int uvlinesize= s->current_picture.linesize[1];
2479 2436
2480 /* avoid copy if macroblock skipped in last frame too */ 2437 /* avoid copy if macroblock skipped in last frame too */
2481 if (s->pict_type != B_TYPE) {
2482 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2483 }
2484
2485 /* skip only during decoding as we might trash the buffers during encoding a bit */ 2438 /* skip only during decoding as we might trash the buffers during encoding a bit */
2486 if(!s->encoding){ 2439 if(!s->encoding){
2487 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy]; 2440 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2488 const int age= s->current_picture.age; 2441 const int age= s->current_picture.age;
2489 2442
2504 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */ 2457 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2505 if(*mbskip_ptr >99) *mbskip_ptr= 99; 2458 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2506 } else{ 2459 } else{
2507 *mbskip_ptr = 0; /* not skipped */ 2460 *mbskip_ptr = 0; /* not skipped */
2508 } 2461 }
2509 }else
2510 s->mb_skiped= 0;
2511
2512 if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){ //FIXME precalc
2513 dest_y = s->current_picture.data[0] + mb_x * 16;
2514 dest_cb = s->current_picture.data[1] + mb_x * 8;
2515 dest_cr = s->current_picture.data[2] + mb_x * 8;
2516 }else{
2517 dest_y = s->current_picture.data[0] + (mb_y * 16* linesize ) + mb_x * 16;
2518 dest_cb = s->current_picture.data[1] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2519 dest_cr = s->current_picture.data[2] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2520 } 2462 }
2521 2463
2522 if (s->interlaced_dct) { 2464 if (s->interlaced_dct) {
2523 dct_linesize = linesize * 2; 2465 dct_linesize = linesize * 2;
2524 dct_offset = linesize; 2466 dct_offset = linesize;
2525 } else { 2467 } else {
2526 dct_linesize = linesize; 2468 dct_linesize = linesize;
2527 dct_offset = linesize * 8; 2469 dct_offset = linesize * 8;
2528 } 2470 }
2471
2472 dest_y= s->dest[0];
2473 dest_cb= s->dest[1];
2474 dest_cr= s->dest[2];
2529 2475
2530 if (!s->mb_intra) { 2476 if (!s->mb_intra) {
2531 /* motion handling */ 2477 /* motion handling */
2532 /* decoding or more than one mb_type (MC was allready done otherwise) */ 2478 /* decoding or more than one mb_type (MC was allready done otherwise) */
2533 if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){ 2479 if(!s->encoding){
2534 if ((!s->no_rounding) || s->pict_type==B_TYPE){ 2480 if ((!s->no_rounding) || s->pict_type==B_TYPE){
2535 op_pix = s->dsp.put_pixels_tab; 2481 op_pix = s->dsp.put_pixels_tab;
2536 op_qpix= s->dsp.put_qpel_pixels_tab; 2482 op_qpix= s->dsp.put_qpel_pixels_tab;
2537 }else{ 2483 }else{
2538 op_pix = s->dsp.put_no_rnd_pixels_tab; 2484 op_pix = s->dsp.put_no_rnd_pixels_tab;
2789 s->avctx->draw_horiz_band(s->avctx, src, offset, 2735 s->avctx->draw_horiz_band(s->avctx, src, offset,
2790 y, s->picture_structure, h); 2736 y, s->picture_structure, h);
2791 } 2737 }
2792 } 2738 }
2793 2739
2740 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2741 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2742 const int uvlinesize= s->current_picture.linesize[1];
2743
2744 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2745 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1) + s->mb_x*2;
2746 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
2747 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2) + s->mb_x*2;
2748 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
2749 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;
2750
2751 if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
2752 s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
2753 s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
2754 s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
2755 }else{
2756 s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize ) + s->mb_x * 16 - 16;
2757 s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
2758 s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
2759 }
2760 }
2761
2794 #ifdef CONFIG_ENCODERS 2762 #ifdef CONFIG_ENCODERS
2795 2763
2796 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y) 2764 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2797 { 2765 {
2798 const int mb_x= s->mb_x; 2766 const int mb_x= s->mb_x;
2883 uint8_t *dest_y, *dest_cb, *dest_cr; 2851 uint8_t *dest_y, *dest_cb, *dest_cr;
2884 uint8_t *ptr_y, *ptr_cb, *ptr_cr; 2852 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2885 int wrap_y, wrap_c; 2853 int wrap_y, wrap_c;
2886 int emu=0; 2854 int emu=0;
2887 2855
2888 dest_y = s->current_picture.data[0] + (mb_y * 16 * s->linesize ) + mb_x * 16; 2856 dest_y = s->dest[0];
2889 dest_cb = s->current_picture.data[1] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8; 2857 dest_cb = s->dest[1];
2890 dest_cr = s->current_picture.data[2] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8; 2858 dest_cr = s->dest[2];
2891 wrap_y = s->linesize; 2859 wrap_y = s->linesize;
2892 wrap_c = s->uvlinesize; 2860 wrap_c = s->uvlinesize;
2893 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16; 2861 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2894 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8; 2862 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2895 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8; 2863 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3159 d->b_count= s->b_count; 3127 d->b_count= s->b_count;
3160 d->skip_count= s->skip_count; 3128 d->skip_count= s->skip_count;
3161 d->misc_bits= s->misc_bits; 3129 d->misc_bits= s->misc_bits;
3162 d->last_bits= 0; 3130 d->last_bits= 0;
3163 3131
3164 d->mb_skiped= s->mb_skiped; 3132 d->mb_skiped= 0;
3165 d->qscale= s->qscale; 3133 d->qscale= s->qscale;
3166 } 3134 }
3167 3135
3168 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){ 3136 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3169 int i; 3137 int i;
3204 3172
3205 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 3173 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
3206 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], 3174 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3207 int *dmin, int *next_block, int motion_x, int motion_y) 3175 int *dmin, int *next_block, int motion_x, int motion_y)
3208 { 3176 {
3209 int bits_count; 3177 int score;
3178 uint8_t *dest_backup[3];
3210 3179
3211 copy_context_before_encode(s, backup, type); 3180 copy_context_before_encode(s, backup, type);
3212 3181
3213 s->block= s->blocks[*next_block]; 3182 s->block= s->blocks[*next_block];
3214 s->pb= pb[*next_block]; 3183 s->pb= pb[*next_block];
3215 if(s->data_partitioning){ 3184 if(s->data_partitioning){
3216 s->pb2 = pb2 [*next_block]; 3185 s->pb2 = pb2 [*next_block];
3217 s->tex_pb= tex_pb[*next_block]; 3186 s->tex_pb= tex_pb[*next_block];
3218 } 3187 }
3188
3189 if(*next_block){
3190 memcpy(dest_backup, s->dest, sizeof(s->dest));
3191 s->dest[0] = s->me.scratchpad;
3192 s->dest[1] = s->me.scratchpad + 16;
3193 s->dest[2] = s->me.scratchpad + 16 + 8;
3194 assert(2*s->uvlinesize == s->linesize); //should be no prob for encoding
3195 assert(s->linesize >= 64); //FIXME
3196 }
3219 3197
3220 encode_mb(s, motion_x, motion_y); 3198 encode_mb(s, motion_x, motion_y);
3221 3199
3222 bits_count= get_bit_count(&s->pb); 3200 score= get_bit_count(&s->pb);
3223 if(s->data_partitioning){ 3201 if(s->data_partitioning){
3224 bits_count+= get_bit_count(&s->pb2); 3202 score+= get_bit_count(&s->pb2);
3225 bits_count+= get_bit_count(&s->tex_pb); 3203 score+= get_bit_count(&s->tex_pb);
3226 } 3204 }
3227 3205
3228 if(bits_count<*dmin){ 3206 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3229 *dmin= bits_count; 3207 MPV_decode_mb(s, s->block);
3208
3209 score *= s->qscale * s->qscale * 109;
3210 score += sse_mb(s) << 7;
3211 }
3212
3213 if(*next_block){
3214 memcpy(s->dest, dest_backup, sizeof(s->dest));
3215 }
3216
3217 if(score<*dmin){
3218 *dmin= score;
3230 *next_block^=1; 3219 *next_block^=1;
3231 3220
3232 copy_context_after_encode(best, s, type); 3221 copy_context_after_encode(best, s, type);
3233 } 3222 }
3234 } 3223 }
3235 3224
3236 static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){ 3225 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3237 uint32_t *sq = squareTbl + 256; 3226 uint32_t *sq = squareTbl + 256;
3238 int acc=0; 3227 int acc=0;
3239 int x,y; 3228 int x,y;
3240 3229
3241 if(w==16 && h==16) 3230 if(w==16 && h==16)
3250 } 3239 }
3251 3240
3252 assert(acc>=0); 3241 assert(acc>=0);
3253 3242
3254 return acc; 3243 return acc;
3244 }
3245
3246 static int sse_mb(MpegEncContext *s){
3247 int w= 16;
3248 int h= 16;
3249
3250 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3251 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3252
3253 if(w==16 && h==16)
3254 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)
3255 +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)
3256 +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);
3257 else
3258 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)
3259 +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)
3260 +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);
3255 } 3261 }
3256 3262
3257 static void encode_picture(MpegEncContext *s, int picture_number) 3263 static void encode_picture(MpegEncContext *s, int picture_number)
3258 { 3264 {
3259 int mb_x, mb_y, pdif = 0; 3265 int mb_x, mb_y, pdif = 0;
3506 s->resync_mb_x=0; 3512 s->resync_mb_x=0;
3507 s->resync_mb_y=0; 3513 s->resync_mb_y=0;
3508 s->first_slice_line = 1; 3514 s->first_slice_line = 1;
3509 s->ptr_lastgob = s->pb.buf; 3515 s->ptr_lastgob = s->pb.buf;
3510 for(mb_y=0; mb_y < s->mb_height; mb_y++) { 3516 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3517 s->mb_x=0;
3518 s->mb_y= mb_y;
3519
3511 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; 3520 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3512 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; 3521 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3522 ff_init_block_index(s);
3513 3523
3514 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3515 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3516 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3517 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3518 s->block_index[4]= s->block_wrap[4]*(mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2);
3519 s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
3520 for(mb_x=0; mb_x < s->mb_width; mb_x++) { 3524 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3521 const int xy= mb_y*s->mb_stride + mb_x; 3525 const int xy= mb_y*s->mb_stride + mb_x;
3522 int mb_type= s->mb_type[xy]; 3526 int mb_type= s->mb_type[xy];
3523 // int d; 3527 // int d;
3524 int dmin=10000000; 3528 int dmin= INT_MAX;
3525 3529
3526 s->mb_x = mb_x; 3530 s->mb_x = mb_x;
3527 s->mb_y = mb_y; 3531 ff_update_block_index(s);
3528 s->block_index[0]+=2;
3529 s->block_index[1]+=2;
3530 s->block_index[2]+=2;
3531 s->block_index[3]+=2;
3532 s->block_index[4]++;
3533 s->block_index[5]++;
3534 3532
3535 /* write gob / video packet header */ 3533 /* write gob / video packet header */
3536 #ifdef CONFIG_RISKY 3534 #ifdef CONFIG_RISKY
3537 if(s->rtp_mode){ 3535 if(s->rtp_mode){
3538 int current_packet_size, is_gob_start; 3536 int current_packet_size, is_gob_start;
3586 if( (s->resync_mb_x == s->mb_x) 3584 if( (s->resync_mb_x == s->mb_x)
3587 && s->resync_mb_y+1 == s->mb_y){ 3585 && s->resync_mb_y+1 == s->mb_y){
3588 s->first_slice_line=0; 3586 s->first_slice_line=0;
3589 } 3587 }
3590 3588
3589 s->mb_skiped=0;
3590
3591 if(mb_type & (mb_type-1)){ // more than 1 MB type possible 3591 if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3592 int next_block=0; 3592 int next_block=0;
3593 int pb_bits_count, pb2_bits_count, tex_pb_bits_count; 3593 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3594 3594
3595 copy_context_before_encode(&backup_s, s, -1); 3595 copy_context_before_encode(&backup_s, s, -1);
3668 s->mb_intra= 1; 3668 s->mb_intra= 1;
3669 s->mv[0][0][0] = 0; 3669 s->mv[0][0][0] = 0;
3670 s->mv[0][0][1] = 0; 3670 s->mv[0][0][1] = 0;
3671 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 3671 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
3672 &dmin, &next_block, 0, 0); 3672 &dmin, &next_block, 0, 0);
3673 /* force cleaning of ac/dc pred stuff if needed ... */ 3673 if(s->h263_pred || s->h263_aic){
3674 if(s->h263_pred || s->h263_aic) 3674 if(best_s.mb_intra)
3675 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1; 3675 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3676 else
3677 ff_clean_intra_table_entries(s); //old mode?
3678 }
3676 } 3679 }
3677 copy_context_after_encode(s, &best_s, -1); 3680 copy_context_after_encode(s, &best_s, -1);
3678 3681
3679 pb_bits_count= get_bit_count(&s->pb); 3682 pb_bits_count= get_bit_count(&s->pb);
3680 flush_put_bits(&s->pb); 3683 flush_put_bits(&s->pb);
3691 flush_put_bits(&s->tex_pb); 3694 flush_put_bits(&s->tex_pb);
3692 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count); 3695 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3693 s->tex_pb= backup_s.tex_pb; 3696 s->tex_pb= backup_s.tex_pb;
3694 } 3697 }
3695 s->last_bits= get_bit_count(&s->pb); 3698 s->last_bits= get_bit_count(&s->pb);
3699
3700 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3701 ff_h263_update_motion_val(s);
3702
3703 if(next_block==0){
3704 s->dsp.put_pixels_tab[0][0](s->dest[0], s->me.scratchpad , s->linesize ,16);
3705 s->dsp.put_pixels_tab[1][0](s->dest[1], s->me.scratchpad + 16, s->uvlinesize, 8);
3706 s->dsp.put_pixels_tab[1][0](s->dest[2], s->me.scratchpad + 24, s->uvlinesize, 8);
3707 }
3708
3709 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3710 MPV_decode_mb(s, s->block);
3696 } else { 3711 } else {
3697 int motion_x, motion_y; 3712 int motion_x, motion_y;
3698 int intra_score; 3713 int intra_score;
3699 int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride]; 3714 int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3700 3715
3701 if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){ 3716 if(s->avctx->mb_decision==FF_MB_DECISION_SIMPLE && s->pict_type==P_TYPE){ //FIXME check if the mess is usefull at all
3702 /* get luma score */ 3717 /* get luma score */
3703 if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){ 3718 if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3704 intra_score= (s->current_picture.mb_var[mb_x + mb_y*s->mb_stride]<<8) - 500; //FIXME dont scale it down so we dont have to fix it 3719 intra_score= (s->current_picture.mb_var[mb_x + mb_y*s->mb_stride]<<8) - 500; //FIXME dont scale it down so we dont have to fix it
3705 }else{ 3720 }else{
3706 uint8_t *dest_y; 3721 uint8_t *dest_y;
3844 3859
3845 encode_mb(s, motion_x, motion_y); 3860 encode_mb(s, motion_x, motion_y);
3846 3861
3847 // RAL: Update last macrobloc type 3862 // RAL: Update last macrobloc type
3848 s->last_mv_dir = s->mv_dir; 3863 s->last_mv_dir = s->mv_dir;
3864
3865 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3866 ff_h263_update_motion_val(s);
3867
3868 MPV_decode_mb(s, s->block);
3849 } 3869 }
3850 3870
3851 /* clean the MV table in IPS frames for direct mode in B frames */ 3871 /* clean the MV table in IPS frames for direct mode in B frames */
3852 if(s->mb_intra /* && I,P,S_TYPE */){ 3872 if(s->mb_intra /* && I,P,S_TYPE */){
3853 s->p_mv_table[xy][0]=0; 3873 s->p_mv_table[xy][0]=0;
3854 s->p_mv_table[xy][1]=0; 3874 s->p_mv_table[xy][1]=0;
3855 } 3875 }
3856
3857 MPV_decode_mb(s, s->block);
3858 3876
3859 if(s->flags&CODEC_FLAG_PSNR){ 3877 if(s->flags&CODEC_FLAG_PSNR){
3860 int w= 16; 3878 int w= 16;
3861 int h= 16; 3879 int h= 16;
3862 3880
3863 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; 3881 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3864 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; 3882 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3865 3883
3866 s->current_picture_ptr->error[0] += sse( 3884 s->current_picture_ptr->error[0] += sse(
3867 s, 3885 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3868 s->new_picture .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, 3886 s->dest[0], w, h, s->linesize);
3869 s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3870 w, h, s->linesize);
3871 s->current_picture_ptr->error[1] += sse( 3887 s->current_picture_ptr->error[1] += sse(
3872 s, 3888 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3873 s->new_picture .data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, 3889 s->dest[1], w>>1, h>>1, s->uvlinesize);
3874 s->current_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3875 w>>1, h>>1, s->uvlinesize);
3876 s->current_picture_ptr->error[2] += sse( 3890 s->current_picture_ptr->error[2] += sse(
3877 s, 3891 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3878 s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, 3892 s->dest[2], w>>1, h>>1, s->uvlinesize);
3879 s->current_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3880 w>>1, h>>1, s->uvlinesize);
3881 } 3893 }
3882 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb)); 3894 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3883 } 3895 }
3884 } 3896 }
3885 emms_c(); 3897 emms_c();
4400 4412
4401 4413
4402 static const AVOption mpeg4_options[] = 4414 static const AVOption mpeg4_options[] =
4403 { 4415 {
4404 AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000), 4416 AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4405 AVOPTION_CODEC_FLAG("vhq", "very high quality", flags, CODEC_FLAG_HQ, 0),
4406 AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference" 4417 AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4407 "the reference can be CBR (for CBR pass1) or VBR (for pass2)", 4418 "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4408 bit_rate_tolerance, 4, 240000000, 8000), 4419 bit_rate_tolerance, 4, 240000000, 8000),
4409 AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2), 4420 AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4410 AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31), 4421 AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),