Mercurial > libavcodec.hg
comparison motion_est.c @ 2967:ef2149182f1c libavcodec
COSMETICS: Remove all trailing whitespace.
author | diego |
---|---|
date | Sat, 17 Dec 2005 18:14:38 +0000 |
parents | 40765c51a7a9 |
children | bfabfdf9ce55 |
comparison
equal
deleted
inserted
replaced
2966:564788471dd4 | 2967:ef2149182f1c |
---|---|
1 /* | 1 /* |
2 * Motion estimation | 2 * Motion estimation |
3 * Copyright (c) 2000,2001 Fabrice Bellard. | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
4 * Copyright (c) 2002-2004 Michael Niedermayer | 4 * Copyright (c) 2002-2004 Michael Niedermayer |
5 * | 5 * |
6 * | 6 * |
7 * This library is free software; you can redistribute it and/or | 7 * This library is free software; you can redistribute it and/or |
8 * modify it under the terms of the GNU Lesser General Public | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | 9 * License as published by the Free Software Foundation; either |
10 * version 2 of the License, or (at your option) any later version. | 10 * version 2 of the License, or (at your option) any later version. |
18 * License along with this library; if not, write to the Free Software | 18 * License along with this library; if not, write to the Free Software |
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
20 * | 20 * |
21 * new Motion Estimation (X1/EPZS) by Michael Niedermayer <michaelni@gmx.at> | 21 * new Motion Estimation (X1/EPZS) by Michael Niedermayer <michaelni@gmx.at> |
22 */ | 22 */ |
23 | 23 |
24 /** | 24 /** |
25 * @file motion_est.c | 25 * @file motion_est.c |
26 * Motion estimation. | 26 * Motion estimation. |
27 */ | 27 */ |
28 | 28 |
29 #include <stdlib.h> | 29 #include <stdlib.h> |
30 #include <stdio.h> | 30 #include <stdio.h> |
31 #include <limits.h> | 31 #include <limits.h> |
32 #include "avcodec.h" | 32 #include "avcodec.h" |
33 #include "dsputil.h" | 33 #include "dsputil.h" |
67 }Minima; | 67 }Minima; |
68 | 68 |
69 static int minima_cmp(const void *a, const void *b){ | 69 static int minima_cmp(const void *a, const void *b){ |
70 const Minima *da = (const Minima *) a; | 70 const Minima *da = (const Minima *) a; |
71 const Minima *db = (const Minima *) b; | 71 const Minima *db = (const Minima *) b; |
72 | 72 |
73 return da->height - db->height; | 73 return da->height - db->height; |
74 } | 74 } |
75 | 75 |
76 #define FLAG_QPEL 1 //must be 1 | 76 #define FLAG_QPEL 1 //must be 1 |
77 #define FLAG_CHROMA 2 | 77 #define FLAG_CHROMA 2 |
95 } | 95 } |
96 } | 96 } |
97 | 97 |
98 static int get_flags(MotionEstContext *c, int direct, int chroma){ | 98 static int get_flags(MotionEstContext *c, int direct, int chroma){ |
99 return ((c->avctx->flags&CODEC_FLAG_QPEL) ? FLAG_QPEL : 0) | 99 return ((c->avctx->flags&CODEC_FLAG_QPEL) ? FLAG_QPEL : 0) |
100 + (direct ? FLAG_DIRECT : 0) | 100 + (direct ? FLAG_DIRECT : 0) |
101 + (chroma ? FLAG_CHROMA : 0); | 101 + (chroma ? FLAG_CHROMA : 0); |
102 } | 102 } |
103 | 103 |
104 static always_inline int cmp(MpegEncContext *s, const int x, const int y, const int subx, const int suby, | 104 static always_inline int cmp(MpegEncContext *s, const int x, const int y, const int subx, const int suby, |
105 const int size, const int h, int ref_index, int src_index, | 105 const int size, const int h, int ref_index, int src_index, |
128 int fy = c->direct_basis_mv[i][1] + hy; | 128 int fy = c->direct_basis_mv[i][1] + hy; |
129 int bx = hx ? fx - c->co_located_mv[i][0] : c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(qpel+4)); | 129 int bx = hx ? fx - c->co_located_mv[i][0] : c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(qpel+4)); |
130 int by = hy ? fy - c->co_located_mv[i][1] : c->co_located_mv[i][1]*(time_pb - time_pp)/time_pp + ((i>>1)<<(qpel+4)); | 130 int by = hy ? fy - c->co_located_mv[i][1] : c->co_located_mv[i][1]*(time_pb - time_pp)/time_pp + ((i>>1)<<(qpel+4)); |
131 int fxy= (fx&mask) + ((fy&mask)<<(qpel+1)); | 131 int fxy= (fx&mask) + ((fy&mask)<<(qpel+1)); |
132 int bxy= (bx&mask) + ((by&mask)<<(qpel+1)); | 132 int bxy= (bx&mask) + ((by&mask)<<(qpel+1)); |
133 | 133 |
134 uint8_t *dst= c->temp + 8*(i&1) + 8*stride*(i>>1); | 134 uint8_t *dst= c->temp + 8*(i&1) + 8*stride*(i>>1); |
135 if(qpel){ | 135 if(qpel){ |
136 c->qpel_put[1][fxy](dst, ref[0] + (fx>>2) + (fy>>2)*stride, stride); | 136 c->qpel_put[1][fxy](dst, ref[0] + (fx>>2) + (fy>>2)*stride, stride); |
137 c->qpel_avg[1][bxy](dst, ref[8] + (bx>>2) + (by>>2)*stride, stride); | 137 c->qpel_avg[1][bxy](dst, ref[8] + (bx>>2) + (by>>2)*stride, stride); |
138 }else{ | 138 }else{ |
145 int fy = c->direct_basis_mv[0][1] + hy; | 145 int fy = c->direct_basis_mv[0][1] + hy; |
146 int bx = hx ? fx - c->co_located_mv[0][0] : (c->co_located_mv[0][0]*(time_pb - time_pp)/time_pp); | 146 int bx = hx ? fx - c->co_located_mv[0][0] : (c->co_located_mv[0][0]*(time_pb - time_pp)/time_pp); |
147 int by = hy ? fy - c->co_located_mv[0][1] : (c->co_located_mv[0][1]*(time_pb - time_pp)/time_pp); | 147 int by = hy ? fy - c->co_located_mv[0][1] : (c->co_located_mv[0][1]*(time_pb - time_pp)/time_pp); |
148 int fxy= (fx&mask) + ((fy&mask)<<(qpel+1)); | 148 int fxy= (fx&mask) + ((fy&mask)<<(qpel+1)); |
149 int bxy= (bx&mask) + ((by&mask)<<(qpel+1)); | 149 int bxy= (bx&mask) + ((by&mask)<<(qpel+1)); |
150 | 150 |
151 if(qpel){ | 151 if(qpel){ |
152 c->qpel_put[1][fxy](c->temp , ref[0] + (fx>>2) + (fy>>2)*stride , stride); | 152 c->qpel_put[1][fxy](c->temp , ref[0] + (fx>>2) + (fy>>2)*stride , stride); |
153 c->qpel_put[1][fxy](c->temp + 8 , ref[0] + (fx>>2) + (fy>>2)*stride + 8 , stride); | 153 c->qpel_put[1][fxy](c->temp + 8 , ref[0] + (fx>>2) + (fy>>2)*stride + 8 , stride); |
154 c->qpel_put[1][fxy](c->temp + 8*stride, ref[0] + (fx>>2) + (fy>>2)*stride + 8*stride, stride); | 154 c->qpel_put[1][fxy](c->temp + 8*stride, ref[0] + (fx>>2) + (fy>>2)*stride + 8*stride, stride); |
155 c->qpel_put[1][fxy](c->temp + 8 + 8*stride, ref[0] + (fx>>2) + (fy>>2)*stride + 8 + 8*stride, stride); | 155 c->qpel_put[1][fxy](c->temp + 8 + 8*stride, ref[0] + (fx>>2) + (fy>>2)*stride + 8 + 8*stride, stride); |
156 c->qpel_avg[1][bxy](c->temp , ref[8] + (bx>>2) + (by>>2)*stride , stride); | 156 c->qpel_avg[1][bxy](c->temp , ref[8] + (bx>>2) + (by>>2)*stride , stride); |
157 c->qpel_avg[1][bxy](c->temp + 8 , ref[8] + (bx>>2) + (by>>2)*stride + 8 , stride); | 157 c->qpel_avg[1][bxy](c->temp + 8 , ref[8] + (bx>>2) + (by>>2)*stride + 8 , stride); |
158 c->qpel_avg[1][bxy](c->temp + 8*stride, ref[8] + (bx>>2) + (by>>2)*stride + 8*stride, stride); | 158 c->qpel_avg[1][bxy](c->temp + 8*stride, ref[8] + (bx>>2) + (by>>2)*stride + 8*stride, stride); |
159 c->qpel_avg[1][bxy](c->temp + 8 + 8*stride, ref[8] + (bx>>2) + (by>>2)*stride + 8 + 8*stride, stride); | 159 c->qpel_avg[1][bxy](c->temp + 8 + 8*stride, ref[8] + (bx>>2) + (by>>2)*stride + 8 + 8*stride, stride); |
160 }else{ | 160 }else{ |
161 assert((fx>>1) + 16*s->mb_x >= -16); | 161 assert((fx>>1) + 16*s->mb_x >= -16); |
162 assert((fy>>1) + 16*s->mb_y >= -16); | 162 assert((fy>>1) + 16*s->mb_y >= -16); |
163 assert((fx>>1) + 16*s->mb_x <= s->width); | 163 assert((fx>>1) + 16*s->mb_x <= s->width); |
164 assert((fy>>1) + 16*s->mb_y <= s->height); | 164 assert((fy>>1) + 16*s->mb_y <= s->height); |
165 assert((bx>>1) + 16*s->mb_x >= -16); | 165 assert((bx>>1) + 16*s->mb_x >= -16); |
190 }else{ | 190 }else{ |
191 c->hpel_put[size][dxy](c->temp, ref[0] + x + y*stride, stride, h); | 191 c->hpel_put[size][dxy](c->temp, ref[0] + x + y*stride, stride, h); |
192 if(chroma) | 192 if(chroma) |
193 uvdxy= dxy | (x&1) | (2*(y&1)); | 193 uvdxy= dxy | (x&1) | (2*(y&1)); |
194 } | 194 } |
195 d = cmp_func(s, c->temp, src[0], stride, h); | 195 d = cmp_func(s, c->temp, src[0], stride, h); |
196 }else{ | 196 }else{ |
197 d = cmp_func(s, src[0], ref[0] + x + y*stride, stride, h); | 197 d = cmp_func(s, src[0], ref[0] + x + y*stride, stride, h); |
198 if(chroma) | 198 if(chroma) |
199 uvdxy= (x&1) + 2*(y&1); | 199 uvdxy= (x&1) + 2*(y&1); |
200 } | 200 } |
201 if(chroma){ | 201 if(chroma){ |
202 uint8_t * const uvtemp= c->temp + 16*stride; | 202 uint8_t * const uvtemp= c->temp + 16*stride; |
203 c->hpel_put[size+1][uvdxy](uvtemp , ref[1] + (x>>1) + (y>>1)*uvstride, uvstride, h>>1); | 203 c->hpel_put[size+1][uvdxy](uvtemp , ref[1] + (x>>1) + (y>>1)*uvstride, uvstride, h>>1); |
204 c->hpel_put[size+1][uvdxy](uvtemp+8, ref[2] + (x>>1) + (y>>1)*uvstride, uvstride, h>>1); | 204 c->hpel_put[size+1][uvdxy](uvtemp+8, ref[2] + (x>>1) + (y>>1)*uvstride, uvstride, h>>1); |
205 d += chroma_cmp_func(s, uvtemp , src[1], uvstride, h>>1); | 205 d += chroma_cmp_func(s, uvtemp , src[1], uvstride, h>>1); |
206 d += chroma_cmp_func(s, uvtemp+8, src[2], uvstride, h>>1); | 206 d += chroma_cmp_func(s, uvtemp+8, src[2], uvstride, h>>1); |
207 } | 207 } |
208 } | 208 } |
209 #if 0 | 209 #if 0 |
210 if(full_pel){ | 210 if(full_pel){ |
211 const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1); | 211 const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1); |
232 | 232 |
233 ff_set_cmp(&s->dsp, s->dsp.me_pre_cmp, c->avctx->me_pre_cmp); | 233 ff_set_cmp(&s->dsp, s->dsp.me_pre_cmp, c->avctx->me_pre_cmp); |
234 ff_set_cmp(&s->dsp, s->dsp.me_cmp, c->avctx->me_cmp); | 234 ff_set_cmp(&s->dsp, s->dsp.me_cmp, c->avctx->me_cmp); |
235 ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, c->avctx->me_sub_cmp); | 235 ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, c->avctx->me_sub_cmp); |
236 ff_set_cmp(&s->dsp, s->dsp.mb_cmp, c->avctx->mb_cmp); | 236 ff_set_cmp(&s->dsp, s->dsp.mb_cmp, c->avctx->mb_cmp); |
237 | 237 |
238 c->flags = get_flags(c, 0, c->avctx->me_cmp &FF_CMP_CHROMA); | 238 c->flags = get_flags(c, 0, c->avctx->me_cmp &FF_CMP_CHROMA); |
239 c->sub_flags= get_flags(c, 0, c->avctx->me_sub_cmp&FF_CMP_CHROMA); | 239 c->sub_flags= get_flags(c, 0, c->avctx->me_sub_cmp&FF_CMP_CHROMA); |
240 c->mb_flags = get_flags(c, 0, c->avctx->mb_cmp &FF_CMP_CHROMA); | 240 c->mb_flags = get_flags(c, 0, c->avctx->mb_cmp &FF_CMP_CHROMA); |
241 | 241 |
242 /*FIXME s->no_rounding b_type*/ | 242 /*FIXME s->no_rounding b_type*/ |
246 if(s->no_rounding) c->qpel_put= s->dsp.put_no_rnd_qpel_pixels_tab; | 246 if(s->no_rounding) c->qpel_put= s->dsp.put_no_rnd_qpel_pixels_tab; |
247 else c->qpel_put= s->dsp.put_qpel_pixels_tab; | 247 else c->qpel_put= s->dsp.put_qpel_pixels_tab; |
248 }else{ | 248 }else{ |
249 if(c->avctx->me_sub_cmp&FF_CMP_CHROMA) | 249 if(c->avctx->me_sub_cmp&FF_CMP_CHROMA) |
250 c->sub_motion_search= hpel_motion_search; | 250 c->sub_motion_search= hpel_motion_search; |
251 else if( c->avctx->me_sub_cmp == FF_CMP_SAD | 251 else if( c->avctx->me_sub_cmp == FF_CMP_SAD |
252 && c->avctx-> me_cmp == FF_CMP_SAD | 252 && c->avctx-> me_cmp == FF_CMP_SAD |
253 && c->avctx-> mb_cmp == FF_CMP_SAD) | 253 && c->avctx-> mb_cmp == FF_CMP_SAD) |
254 c->sub_motion_search= sad_hpel_motion_search; // 2050 vs. 2450 cycles | 254 c->sub_motion_search= sad_hpel_motion_search; // 2050 vs. 2450 cycles |
255 else | 255 else |
256 c->sub_motion_search= hpel_motion_search; | 256 c->sub_motion_search= hpel_motion_search; |
257 } | 257 } |
258 c->hpel_avg= s->dsp.avg_pixels_tab; | 258 c->hpel_avg= s->dsp.avg_pixels_tab; |
259 if(s->no_rounding) c->hpel_put= s->dsp.put_no_rnd_pixels_tab; | 259 if(s->no_rounding) c->hpel_put= s->dsp.put_no_rnd_pixels_tab; |
260 else c->hpel_put= s->dsp.put_pixels_tab; | 260 else c->hpel_put= s->dsp.put_pixels_tab; |
261 | 261 |
262 if(s->linesize){ | 262 if(s->linesize){ |
263 c->stride = s->linesize; | 263 c->stride = s->linesize; |
264 c->uvstride= s->uvlinesize; | 264 c->uvstride= s->uvlinesize; |
265 }else{ | 265 }else{ |
266 c->stride = 16*s->mb_width + 32; | 266 c->stride = 16*s->mb_width + 32; |
267 c->uvstride= 8*s->mb_width + 16; | 267 c->uvstride= 8*s->mb_width + 16; |
268 } | 268 } |
283 c->sub_motion_search= no_sub_motion_search; | 283 c->sub_motion_search= no_sub_motion_search; |
284 } | 284 } |
285 | 285 |
286 c->temp= c->scratchpad; | 286 c->temp= c->scratchpad; |
287 } | 287 } |
288 | 288 |
289 #if 0 | 289 #if 0 |
290 static int pix_dev(uint8_t * pix, int line_size, int mean) | 290 static int pix_dev(uint8_t * pix, int line_size, int mean) |
291 { | 291 { |
292 int s, i, j; | 292 int s, i, j; |
293 | 293 |
559 int mx, my, dminh; | 559 int mx, my, dminh; |
560 uint8_t *pix, *ptr; | 560 uint8_t *pix, *ptr; |
561 int stride= c->stride; | 561 int stride= c->stride; |
562 const int flags= c->sub_flags; | 562 const int flags= c->sub_flags; |
563 LOAD_COMMON | 563 LOAD_COMMON |
564 | 564 |
565 assert(flags == 0); | 565 assert(flags == 0); |
566 | 566 |
567 if(c->skip){ | 567 if(c->skip){ |
568 // printf("S"); | 568 // printf("S"); |
569 *mx_ptr = 0; | 569 *mx_ptr = 0; |
570 *my_ptr = 0; | 570 *my_ptr = 0; |
571 return dmin; | 571 return dmin; |
572 } | 572 } |
573 // printf("N"); | 573 // printf("N"); |
574 | 574 |
575 pix = c->src[src_index][0]; | 575 pix = c->src[src_index][0]; |
576 | 576 |
577 mx = *mx_ptr; | 577 mx = *mx_ptr; |
578 my = *my_ptr; | 578 my = *my_ptr; |
579 ptr = c->ref[ref_index][0] + (my * stride) + mx; | 579 ptr = c->ref[ref_index][0] + (my * stride) + mx; |
580 | 580 |
581 dminh = dmin; | 581 dminh = dmin; |
582 | 582 |
583 if (mx > xmin && mx < xmax && | 583 if (mx > xmin && mx < xmax && |
584 my > ymin && my < ymax) { | 584 my > ymin && my < ymax) { |
585 int dx=0, dy=0; | 585 int dx=0, dy=0; |
586 int d, pen_x, pen_y; | 586 int d, pen_x, pen_y; |
587 const int index= (my<<ME_MAP_SHIFT) + mx; | 587 const int index= (my<<ME_MAP_SHIFT) + mx; |
588 const int t= score_map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]; | 588 const int t= score_map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]; |
589 const int l= score_map[(index- 1 )&(ME_MAP_SIZE-1)]; | 589 const int l= score_map[(index- 1 )&(ME_MAP_SIZE-1)]; |
590 const int r= score_map[(index+ 1 )&(ME_MAP_SIZE-1)]; | 590 const int r= score_map[(index+ 1 )&(ME_MAP_SIZE-1)]; |
591 const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]; | 591 const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]; |
592 mx<<=1; | 592 mx<<=1; |
593 my<<=1; | 593 my<<=1; |
594 | 594 |
595 | 595 |
596 pen_x= pred_x + mx; | 596 pen_x= pred_x + mx; |
597 pen_y= pred_y + my; | 597 pen_y= pred_y + my; |
598 | 598 |
599 ptr-= stride; | 599 ptr-= stride; |
600 if(t<=b){ | 600 if(t<=b){ |
658 } | 658 } |
659 | 659 |
660 static inline void set_p_mv_tables(MpegEncContext * s, int mx, int my, int mv4) | 660 static inline void set_p_mv_tables(MpegEncContext * s, int mx, int my, int mv4) |
661 { | 661 { |
662 const int xy= s->mb_x + s->mb_y*s->mb_stride; | 662 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
663 | 663 |
664 s->p_mv_table[xy][0] = mx; | 664 s->p_mv_table[xy][0] = mx; |
665 s->p_mv_table[xy][1] = my; | 665 s->p_mv_table[xy][1] = my; |
666 | 666 |
667 /* has already been set to the 4 MV if 4MV is done */ | 667 /* has already been set to the 4 MV if 4MV is done */ |
668 if(mv4){ | 668 if(mv4){ |
698 c->ymax = - y + s->mb_height*16; | 698 c->ymax = - y + s->mb_height*16; |
699 } else if (s->out_format == FMT_H261){ | 699 } else if (s->out_format == FMT_H261){ |
700 // Search range of H261 is different from other codec standards | 700 // Search range of H261 is different from other codec standards |
701 c->xmin = (x > 15) ? - 15 : 0; | 701 c->xmin = (x > 15) ? - 15 : 0; |
702 c->ymin = (y > 15) ? - 15 : 0; | 702 c->ymin = (y > 15) ? - 15 : 0; |
703 c->xmax = (x < s->mb_width * 16 - 16) ? 15 : 0; | 703 c->xmax = (x < s->mb_width * 16 - 16) ? 15 : 0; |
704 c->ymax = (y < s->mb_height * 16 - 16) ? 15 : 0; | 704 c->ymax = (y < s->mb_height * 16 - 16) ? 15 : 0; |
705 } else { | 705 } else { |
706 c->xmin = - x; | 706 c->xmin = - x; |
707 c->ymin = - y; | 707 c->ymin = - y; |
708 c->xmax = - x + s->mb_width *16 - 16; | 708 c->xmax = - x + s->mb_width *16 - 16; |
732 int same=1; | 732 int same=1; |
733 const int stride= c->stride; | 733 const int stride= c->stride; |
734 uint8_t *mv_penalty= c->current_mv_penalty; | 734 uint8_t *mv_penalty= c->current_mv_penalty; |
735 | 735 |
736 init_mv4_ref(c); | 736 init_mv4_ref(c); |
737 | 737 |
738 for(block=0; block<4; block++){ | 738 for(block=0; block<4; block++){ |
739 int mx4, my4; | 739 int mx4, my4; |
740 int pred_x4, pred_y4; | 740 int pred_x4, pred_y4; |
741 int dmin4; | 741 int dmin4; |
742 static const int off[4]= {2, 1, 1, -1}; | 742 static const int off[4]= {2, 1, 1, -1}; |
759 P_TOPRIGHT[1] = s->current_picture.motion_val[0][mot_xy - mot_stride + off[block]][1]; | 759 P_TOPRIGHT[1] = s->current_picture.motion_val[0][mot_xy - mot_stride + off[block]][1]; |
760 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift); | 760 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift); |
761 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift); | 761 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift); |
762 if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); | 762 if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); |
763 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift); | 763 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift); |
764 | 764 |
765 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); | 765 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); |
766 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | 766 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); |
767 | 767 |
768 c->pred_x= pred_x4 = P_MEDIAN[0]; | 768 c->pred_x= pred_x4 = P_MEDIAN[0]; |
769 c->pred_y= pred_y4 = P_MEDIAN[1]; | 769 c->pred_y= pred_y4 = P_MEDIAN[1]; |
772 P_MV1[1]= my; | 772 P_MV1[1]= my; |
773 | 773 |
774 dmin4 = epzs_motion_search4(s, &mx4, &my4, P, block, block, s->p_mv_table, (1<<16)>>shift); | 774 dmin4 = epzs_motion_search4(s, &mx4, &my4, P, block, block, s->p_mv_table, (1<<16)>>shift); |
775 | 775 |
776 dmin4= c->sub_motion_search(s, &mx4, &my4, dmin4, block, block, size, h); | 776 dmin4= c->sub_motion_search(s, &mx4, &my4, dmin4, block, block, size, h); |
777 | 777 |
778 if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){ | 778 if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){ |
779 int dxy; | 779 int dxy; |
780 const int offset= ((block&1) + (block>>1)*stride)*8; | 780 const int offset= ((block&1) + (block>>1)*stride)*8; |
781 uint8_t *dest_y = c->scratchpad + offset; | 781 uint8_t *dest_y = c->scratchpad + offset; |
782 if(s->quarter_sample){ | 782 if(s->quarter_sample){ |
805 my4_sum+= my4/2; | 805 my4_sum+= my4/2; |
806 }else{ | 806 }else{ |
807 mx4_sum+= mx4; | 807 mx4_sum+= mx4; |
808 my4_sum+= my4; | 808 my4_sum+= my4; |
809 } | 809 } |
810 | 810 |
811 s->current_picture.motion_val[0][ s->block_index[block] ][0]= mx4; | 811 s->current_picture.motion_val[0][ s->block_index[block] ][0]= mx4; |
812 s->current_picture.motion_val[0][ s->block_index[block] ][1]= my4; | 812 s->current_picture.motion_val[0][ s->block_index[block] ][1]= my4; |
813 | 813 |
814 if(mx4 != mx || my4 != my) same=0; | 814 if(mx4 != mx || my4 != my) same=0; |
815 } | 815 } |
816 | 816 |
817 if(same) | 817 if(same) |
818 return INT_MAX; | 818 return INT_MAX; |
819 | 819 |
820 if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){ | 820 if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){ |
821 dmin_sum += s->dsp.mb_cmp[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*16*stride, c->scratchpad, stride, 16); | 821 dmin_sum += s->dsp.mb_cmp[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*16*stride, c->scratchpad, stride, 16); |
822 } | 822 } |
823 | 823 |
824 if(c->avctx->mb_cmp&FF_CMP_CHROMA){ | 824 if(c->avctx->mb_cmp&FF_CMP_CHROMA){ |
825 int dxy; | 825 int dxy; |
826 int mx, my; | 826 int mx, my; |
827 int offset; | 827 int offset; |
828 | 828 |
829 mx= ff_h263_round_chroma(mx4_sum); | 829 mx= ff_h263_round_chroma(mx4_sum); |
830 my= ff_h263_round_chroma(my4_sum); | 830 my= ff_h263_round_chroma(my4_sum); |
831 dxy = ((my & 1) << 1) | (mx & 1); | 831 dxy = ((my & 1) << 1) | (mx & 1); |
832 | 832 |
833 offset= (s->mb_x*8 + (mx>>1)) + (s->mb_y*8 + (my>>1))*s->uvlinesize; | 833 offset= (s->mb_x*8 + (mx>>1)) + (s->mb_y*8 + (my>>1))*s->uvlinesize; |
834 | 834 |
835 if(s->no_rounding){ | 835 if(s->no_rounding){ |
836 s->dsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad , s->last_picture.data[1] + offset, s->uvlinesize, 8); | 836 s->dsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad , s->last_picture.data[1] + offset, s->uvlinesize, 8); |
837 s->dsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad+8 , s->last_picture.data[2] + offset, s->uvlinesize, 8); | 837 s->dsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad+8 , s->last_picture.data[2] + offset, s->uvlinesize, 8); |
838 }else{ | 838 }else{ |
839 s->dsp.put_pixels_tab [1][dxy](c->scratchpad , s->last_picture.data[1] + offset, s->uvlinesize, 8); | 839 s->dsp.put_pixels_tab [1][dxy](c->scratchpad , s->last_picture.data[1] + offset, s->uvlinesize, 8); |
841 } | 841 } |
842 | 842 |
843 dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad , s->uvlinesize, 8); | 843 dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad , s->uvlinesize, 8); |
844 dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad+8, s->uvlinesize, 8); | 844 dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad+8, s->uvlinesize, 8); |
845 } | 845 } |
846 | 846 |
847 c->pred_x= mx; | 847 c->pred_x= mx; |
848 c->pred_y= my; | 848 c->pred_y= my; |
849 | 849 |
850 switch(c->avctx->mb_cmp&0xFF){ | 850 switch(c->avctx->mb_cmp&0xFF){ |
851 /*case FF_CMP_SSE: | 851 /*case FF_CMP_SSE: |
868 c->src[1][1] = c->src[0][1] + s->uvlinesize; | 868 c->src[1][1] = c->src[0][1] + s->uvlinesize; |
869 c->src[1][2] = c->src[0][2] + s->uvlinesize; | 869 c->src[1][2] = c->src[0][2] + s->uvlinesize; |
870 } | 870 } |
871 } | 871 } |
872 | 872 |
873 static int interlaced_search(MpegEncContext *s, int ref_index, | 873 static int interlaced_search(MpegEncContext *s, int ref_index, |
874 int16_t (*mv_tables[2][2])[2], uint8_t *field_select_tables[2], int mx, int my, int user_field_select) | 874 int16_t (*mv_tables[2][2])[2], uint8_t *field_select_tables[2], int mx, int my, int user_field_select) |
875 { | 875 { |
876 MotionEstContext * const c= &s->me; | 876 MotionEstContext * const c= &s->me; |
877 const int size=0; | 877 const int size=0; |
878 const int h=8; | 878 const int h=8; |
882 int same=1; | 882 int same=1; |
883 const int stride= 2*s->linesize; | 883 const int stride= 2*s->linesize; |
884 int dmin_sum= 0; | 884 int dmin_sum= 0; |
885 const int mot_stride= s->mb_stride; | 885 const int mot_stride= s->mb_stride; |
886 const int xy= s->mb_x + s->mb_y*mot_stride; | 886 const int xy= s->mb_x + s->mb_y*mot_stride; |
887 | 887 |
888 c->ymin>>=1; | 888 c->ymin>>=1; |
889 c->ymax>>=1; | 889 c->ymax>>=1; |
890 c->stride<<=1; | 890 c->stride<<=1; |
891 c->uvstride<<=1; | 891 c->uvstride<<=1; |
892 init_interlaced_ref(s, ref_index); | 892 init_interlaced_ref(s, ref_index); |
893 | 893 |
894 for(block=0; block<2; block++){ | 894 for(block=0; block<2; block++){ |
895 int field_select; | 895 int field_select; |
896 int best_dmin= INT_MAX; | 896 int best_dmin= INT_MAX; |
897 int best_field= -1; | 897 int best_field= -1; |
898 | 898 |
899 for(field_select=0; field_select<2; field_select++){ | 899 for(field_select=0; field_select<2; field_select++){ |
900 int dmin, mx_i, my_i; | 900 int dmin, mx_i, my_i; |
901 int16_t (*mv_table)[2]= mv_tables[block][field_select]; | 901 int16_t (*mv_table)[2]= mv_tables[block][field_select]; |
902 | 902 |
903 if(user_field_select){ | 903 if(user_field_select){ |
904 if(field_select_tables[block][xy] != field_select) | 904 if(field_select_tables[block][xy] != field_select) |
905 continue; | 905 continue; |
906 } | 906 } |
907 | 907 |
908 P_LEFT[0] = mv_table[xy - 1][0]; | 908 P_LEFT[0] = mv_table[xy - 1][0]; |
909 P_LEFT[1] = mv_table[xy - 1][1]; | 909 P_LEFT[1] = mv_table[xy - 1][1]; |
910 if(P_LEFT[0] > (c->xmax<<1)) P_LEFT[0] = (c->xmax<<1); | 910 if(P_LEFT[0] > (c->xmax<<1)) P_LEFT[0] = (c->xmax<<1); |
911 | 911 |
912 c->pred_x= P_LEFT[0]; | 912 c->pred_x= P_LEFT[0]; |
913 c->pred_y= P_LEFT[1]; | 913 c->pred_y= P_LEFT[1]; |
914 | 914 |
915 if(!s->first_slice_line){ | 915 if(!s->first_slice_line){ |
916 P_TOP[0] = mv_table[xy - mot_stride][0]; | 916 P_TOP[0] = mv_table[xy - mot_stride][0]; |
917 P_TOP[1] = mv_table[xy - mot_stride][1]; | 917 P_TOP[1] = mv_table[xy - mot_stride][1]; |
918 P_TOPRIGHT[0] = mv_table[xy - mot_stride + 1][0]; | 918 P_TOPRIGHT[0] = mv_table[xy - mot_stride + 1][0]; |
919 P_TOPRIGHT[1] = mv_table[xy - mot_stride + 1][1]; | 919 P_TOPRIGHT[1] = mv_table[xy - mot_stride + 1][1]; |
920 if(P_TOP[1] > (c->ymax<<1)) P_TOP[1] = (c->ymax<<1); | 920 if(P_TOP[1] > (c->ymax<<1)) P_TOP[1] = (c->ymax<<1); |
921 if(P_TOPRIGHT[0] < (c->xmin<<1)) P_TOPRIGHT[0]= (c->xmin<<1); | 921 if(P_TOPRIGHT[0] < (c->xmin<<1)) P_TOPRIGHT[0]= (c->xmin<<1); |
922 if(P_TOPRIGHT[0] > (c->xmax<<1)) P_TOPRIGHT[0]= (c->xmax<<1); | 922 if(P_TOPRIGHT[0] > (c->xmax<<1)) P_TOPRIGHT[0]= (c->xmax<<1); |
923 if(P_TOPRIGHT[1] > (c->ymax<<1)) P_TOPRIGHT[1]= (c->ymax<<1); | 923 if(P_TOPRIGHT[1] > (c->ymax<<1)) P_TOPRIGHT[1]= (c->ymax<<1); |
924 | 924 |
925 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); | 925 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); |
926 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | 926 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); |
927 } | 927 } |
928 P_MV1[0]= mx; //FIXME not correct if block != field_select | 928 P_MV1[0]= mx; //FIXME not correct if block != field_select |
929 P_MV1[1]= my / 2; | 929 P_MV1[1]= my / 2; |
930 | 930 |
931 dmin = epzs_motion_search2(s, &mx_i, &my_i, P, block, field_select+ref_index, mv_table, (1<<16)>>1); | 931 dmin = epzs_motion_search2(s, &mx_i, &my_i, P, block, field_select+ref_index, mv_table, (1<<16)>>1); |
932 | 932 |
933 dmin= c->sub_motion_search(s, &mx_i, &my_i, dmin, block, field_select+ref_index, size, h); | 933 dmin= c->sub_motion_search(s, &mx_i, &my_i, dmin, block, field_select+ref_index, size, h); |
934 | 934 |
935 mv_table[xy][0]= mx_i; | 935 mv_table[xy][0]= mx_i; |
936 mv_table[xy][1]= my_i; | 936 mv_table[xy][1]= my_i; |
937 | 937 |
938 if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){ | 938 if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){ |
939 int dxy; | 939 int dxy; |
940 | 940 |
941 //FIXME chroma ME | 941 //FIXME chroma ME |
942 uint8_t *ref= c->ref[field_select+ref_index][0] + (mx_i>>1) + (my_i>>1)*stride; | 942 uint8_t *ref= c->ref[field_select+ref_index][0] + (mx_i>>1) + (my_i>>1)*stride; |
949 } | 949 } |
950 dmin= s->dsp.mb_cmp[size](s, c->src[block][0], c->scratchpad, stride, h); | 950 dmin= s->dsp.mb_cmp[size](s, c->src[block][0], c->scratchpad, stride, h); |
951 dmin+= (mv_penalty[mx_i-c->pred_x] + mv_penalty[my_i-c->pred_y] + 1)*c->mb_penalty_factor; | 951 dmin+= (mv_penalty[mx_i-c->pred_x] + mv_penalty[my_i-c->pred_y] + 1)*c->mb_penalty_factor; |
952 }else | 952 }else |
953 dmin+= c->mb_penalty_factor; //field_select bits | 953 dmin+= c->mb_penalty_factor; //field_select bits |
954 | 954 |
955 dmin += field_select != block; //slightly prefer same field | 955 dmin += field_select != block; //slightly prefer same field |
956 | 956 |
957 if(dmin < best_dmin){ | 957 if(dmin < best_dmin){ |
958 best_dmin= dmin; | 958 best_dmin= dmin; |
959 best_field= field_select; | 959 best_field= field_select; |
960 } | 960 } |
961 } | 961 } |
962 { | 962 { |
963 int16_t (*mv_table)[2]= mv_tables[block][best_field]; | 963 int16_t (*mv_table)[2]= mv_tables[block][best_field]; |
964 | 964 |
965 if(mv_table[xy][0] != mx) same=0; //FIXME check if these checks work and are any good at all | 965 if(mv_table[xy][0] != mx) same=0; //FIXME check if these checks work and are any good at all |
966 if(mv_table[xy][1]&1) same=0; | 966 if(mv_table[xy][1]&1) same=0; |
967 if(mv_table[xy][1]*2 != my) same=0; | 967 if(mv_table[xy][1]*2 != my) same=0; |
968 if(best_field != block) same=0; | 968 if(best_field != block) same=0; |
969 } | 969 } |
970 | 970 |
971 field_select_tables[block][xy]= best_field; | 971 field_select_tables[block][xy]= best_field; |
972 dmin_sum += best_dmin; | 972 dmin_sum += best_dmin; |
973 } | 973 } |
974 | 974 |
975 c->ymin<<=1; | 975 c->ymin<<=1; |
976 c->ymax<<=1; | 976 c->ymax<<=1; |
977 c->stride>>=1; | 977 c->stride>>=1; |
978 c->uvstride>>=1; | 978 c->uvstride>>=1; |
979 | 979 |
980 if(same) | 980 if(same) |
981 return INT_MAX; | 981 return INT_MAX; |
982 | 982 |
983 switch(c->avctx->mb_cmp&0xFF){ | 983 switch(c->avctx->mb_cmp&0xFF){ |
984 /*case FF_CMP_SSE: | 984 /*case FF_CMP_SSE: |
985 return dmin_sum+ 32*s->qscale*s->qscale;*/ | 985 return dmin_sum+ 32*s->qscale*s->qscale;*/ |
986 case FF_CMP_RD: | 986 case FF_CMP_RD: |
987 return dmin_sum; | 987 return dmin_sum; |
991 } | 991 } |
992 | 992 |
993 static void clip_input_mv(MpegEncContext * s, int16_t *mv, int interlaced){ | 993 static void clip_input_mv(MpegEncContext * s, int16_t *mv, int interlaced){ |
994 int ymax= s->me.ymax>>interlaced; | 994 int ymax= s->me.ymax>>interlaced; |
995 int ymin= s->me.ymin>>interlaced; | 995 int ymin= s->me.ymin>>interlaced; |
996 | 996 |
997 if(mv[0] < s->me.xmin) mv[0] = s->me.xmin; | 997 if(mv[0] < s->me.xmin) mv[0] = s->me.xmin; |
998 if(mv[0] > s->me.xmax) mv[0] = s->me.xmax; | 998 if(mv[0] > s->me.xmax) mv[0] = s->me.xmax; |
999 if(mv[1] < ymin) mv[1] = ymin; | 999 if(mv[1] < ymin) mv[1] = ymin; |
1000 if(mv[1] > ymax) mv[1] = ymax; | 1000 if(mv[1] > ymax) mv[1] = ymax; |
1001 } | 1001 } |
1011 int mask= (1<<shift)-1; | 1011 int mask= (1<<shift)-1; |
1012 int x, y, i; | 1012 int x, y, i; |
1013 int d=0; | 1013 int d=0; |
1014 me_cmp_func cmpf= s->dsp.sse[0]; | 1014 me_cmp_func cmpf= s->dsp.sse[0]; |
1015 me_cmp_func chroma_cmpf= s->dsp.sse[1]; | 1015 me_cmp_func chroma_cmpf= s->dsp.sse[1]; |
1016 | 1016 |
1017 if(p_type && USES_LIST(mb_type, 1)){ | 1017 if(p_type && USES_LIST(mb_type, 1)){ |
1018 av_log(c->avctx, AV_LOG_ERROR, "backward motion vector in P frame\n"); | 1018 av_log(c->avctx, AV_LOG_ERROR, "backward motion vector in P frame\n"); |
1019 return INT_MAX/2; | 1019 return INT_MAX/2; |
1020 } | 1020 } |
1021 assert(IS_INTRA(mb_type) || USES_LIST(mb_type,0) || USES_LIST(mb_type,1)); | 1021 assert(IS_INTRA(mb_type) || USES_LIST(mb_type,0) || USES_LIST(mb_type,1)); |
1022 | 1022 |
1023 for(i=0; i<4; i++){ | 1023 for(i=0; i<4; i++){ |
1024 int xy= s->block_index[i]; | 1024 int xy= s->block_index[i]; |
1025 clip_input_mv(s, p->motion_val[0][xy], !!IS_INTERLACED(mb_type)); | 1025 clip_input_mv(s, p->motion_val[0][xy], !!IS_INTERLACED(mb_type)); |
1026 clip_input_mv(s, p->motion_val[1][xy], !!IS_INTERLACED(mb_type)); | 1026 clip_input_mv(s, p->motion_val[1][xy], !!IS_INTERLACED(mb_type)); |
1027 } | 1027 } |
1029 if(IS_INTERLACED(mb_type)){ | 1029 if(IS_INTERLACED(mb_type)){ |
1030 int xy2= xy + s->b8_stride; | 1030 int xy2= xy + s->b8_stride; |
1031 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTRA; | 1031 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTRA; |
1032 c->stride<<=1; | 1032 c->stride<<=1; |
1033 c->uvstride<<=1; | 1033 c->uvstride<<=1; |
1034 | 1034 |
1035 if(!(s->flags & CODEC_FLAG_INTERLACED_ME)){ | 1035 if(!(s->flags & CODEC_FLAG_INTERLACED_ME)){ |
1036 av_log(c->avctx, AV_LOG_ERROR, "Interlaced macroblock selected but interlaced motion estimation disabled\n"); | 1036 av_log(c->avctx, AV_LOG_ERROR, "Interlaced macroblock selected but interlaced motion estimation disabled\n"); |
1037 return INT_MAX/2; | 1037 return INT_MAX/2; |
1038 } | 1038 } |
1039 | 1039 |
1056 *(uint32_t*)s->b_field_mv_table[0][0][field_select0][mb_xy]= *(uint32_t*)p->motion_val[0][xy ]; | 1056 *(uint32_t*)s->b_field_mv_table[0][0][field_select0][mb_xy]= *(uint32_t*)p->motion_val[0][xy ]; |
1057 *(uint32_t*)s->b_field_mv_table[0][1][field_select1][mb_xy]= *(uint32_t*)p->motion_val[0][xy2]; | 1057 *(uint32_t*)s->b_field_mv_table[0][1][field_select1][mb_xy]= *(uint32_t*)p->motion_val[0][xy2]; |
1058 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_FORWARD_I; | 1058 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_FORWARD_I; |
1059 } | 1059 } |
1060 | 1060 |
1061 x= p->motion_val[0][xy ][0]; | 1061 x= p->motion_val[0][xy ][0]; |
1062 y= p->motion_val[0][xy ][1]; | 1062 y= p->motion_val[0][xy ][1]; |
1063 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select0, 0, cmpf, chroma_cmpf, flags); | 1063 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select0, 0, cmpf, chroma_cmpf, flags); |
1064 x= p->motion_val[0][xy2][0]; | 1064 x= p->motion_val[0][xy2][0]; |
1065 y= p->motion_val[0][xy2][1]; | 1065 y= p->motion_val[0][xy2][1]; |
1066 d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select1, 1, cmpf, chroma_cmpf, flags); | 1066 d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select1, 1, cmpf, chroma_cmpf, flags); |
1067 } | 1067 } |
1068 if(USES_LIST(mb_type, 1)){ | 1068 if(USES_LIST(mb_type, 1)){ |
1069 int field_select0= p->ref_index[1][xy ]; | 1069 int field_select0= p->ref_index[1][xy ]; |
1080 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_BIDIR_I; | 1080 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_BIDIR_I; |
1081 }else{ | 1081 }else{ |
1082 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_BACKWARD_I; | 1082 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_BACKWARD_I; |
1083 } | 1083 } |
1084 | 1084 |
1085 x= p->motion_val[1][xy ][0]; | 1085 x= p->motion_val[1][xy ][0]; |
1086 y= p->motion_val[1][xy ][1]; | 1086 y= p->motion_val[1][xy ][1]; |
1087 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select0+2, 0, cmpf, chroma_cmpf, flags); | 1087 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select0+2, 0, cmpf, chroma_cmpf, flags); |
1088 x= p->motion_val[1][xy2][0]; | 1088 x= p->motion_val[1][xy2][0]; |
1089 y= p->motion_val[1][xy2][1]; | 1089 y= p->motion_val[1][xy2][1]; |
1090 d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select1+2, 1, cmpf, chroma_cmpf, flags); | 1090 d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select1+2, 1, cmpf, chroma_cmpf, flags); |
1091 //FIXME bidir scores | 1091 //FIXME bidir scores |
1092 } | 1092 } |
1093 c->stride>>=1; | 1093 c->stride>>=1; |
1100 cmpf= s->dsp.sse[1]; | 1100 cmpf= s->dsp.sse[1]; |
1101 chroma_cmpf= s->dsp.sse[1]; | 1101 chroma_cmpf= s->dsp.sse[1]; |
1102 init_mv4_ref(c); | 1102 init_mv4_ref(c); |
1103 for(i=0; i<4; i++){ | 1103 for(i=0; i<4; i++){ |
1104 xy= s->block_index[i]; | 1104 xy= s->block_index[i]; |
1105 x= p->motion_val[0][xy][0]; | 1105 x= p->motion_val[0][xy][0]; |
1106 y= p->motion_val[0][xy][1]; | 1106 y= p->motion_val[0][xy][1]; |
1107 d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 1, 8, i, i, cmpf, chroma_cmpf, flags); | 1107 d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 1, 8, i, i, cmpf, chroma_cmpf, flags); |
1108 } | 1108 } |
1109 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTER4V; | 1109 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTER4V; |
1110 }else{ | 1110 }else{ |
1118 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_BIDIR; | 1118 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_BIDIR; |
1119 }else{ | 1119 }else{ |
1120 *(uint32_t*)s->b_forw_mv_table[mb_xy]= *(uint32_t*)p->motion_val[0][xy]; | 1120 *(uint32_t*)s->b_forw_mv_table[mb_xy]= *(uint32_t*)p->motion_val[0][xy]; |
1121 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_FORWARD; | 1121 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_FORWARD; |
1122 } | 1122 } |
1123 x= p->motion_val[0][xy][0]; | 1123 x= p->motion_val[0][xy][0]; |
1124 y= p->motion_val[0][xy][1]; | 1124 y= p->motion_val[0][xy][1]; |
1125 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 16, 0, 0, cmpf, chroma_cmpf, flags); | 1125 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 16, 0, 0, cmpf, chroma_cmpf, flags); |
1126 }else if(USES_LIST(mb_type, 1)){ | 1126 }else if(USES_LIST(mb_type, 1)){ |
1127 *(uint32_t*)s->b_back_mv_table[mb_xy]= *(uint32_t*)p->motion_val[1][xy]; | 1127 *(uint32_t*)s->b_back_mv_table[mb_xy]= *(uint32_t*)p->motion_val[1][xy]; |
1128 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_BACKWARD; | 1128 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_BACKWARD; |
1129 | 1129 |
1130 x= p->motion_val[1][xy][0]; | 1130 x= p->motion_val[1][xy][0]; |
1131 y= p->motion_val[1][xy][1]; | 1131 y= p->motion_val[1][xy][1]; |
1132 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 16, 2, 0, cmpf, chroma_cmpf, flags); | 1132 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 16, 2, 0, cmpf, chroma_cmpf, flags); |
1133 }else | 1133 }else |
1134 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTRA; | 1134 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTRA; |
1135 } | 1135 } |
1144 int sum, varc, vard, mx, my, dmin; | 1144 int sum, varc, vard, mx, my, dmin; |
1145 int P[10][2]; | 1145 int P[10][2]; |
1146 const int shift= 1+s->quarter_sample; | 1146 const int shift= 1+s->quarter_sample; |
1147 int mb_type=0; | 1147 int mb_type=0; |
1148 Picture * const pic= &s->current_picture; | 1148 Picture * const pic= &s->current_picture; |
1149 | 1149 |
1150 init_ref(c, s->new_picture.data, s->last_picture.data, NULL, 16*mb_x, 16*mb_y, 0); | 1150 init_ref(c, s->new_picture.data, s->last_picture.data, NULL, 16*mb_x, 16*mb_y, 0); |
1151 | 1151 |
1152 assert(s->quarter_sample==0 || s->quarter_sample==1); | 1152 assert(s->quarter_sample==0 || s->quarter_sample==1); |
1153 assert(s->linesize == c->stride); | 1153 assert(s->linesize == c->stride); |
1154 assert(s->uvlinesize == c->uvstride); | 1154 assert(s->uvlinesize == c->uvstride); |
1170 pic->mb_var [s->mb_stride * mb_y + mb_x] = varc; | 1170 pic->mb_var [s->mb_stride * mb_y + mb_x] = varc; |
1171 c->mb_var_sum_temp += varc; | 1171 c->mb_var_sum_temp += varc; |
1172 | 1172 |
1173 if(c->avctx->me_threshold){ | 1173 if(c->avctx->me_threshold){ |
1174 vard= (check_input_motion(s, mb_x, mb_y, 1)+128)>>8; | 1174 vard= (check_input_motion(s, mb_x, mb_y, 1)+128)>>8; |
1175 | 1175 |
1176 if(vard<c->avctx->me_threshold){ | 1176 if(vard<c->avctx->me_threshold){ |
1177 pic->mc_mb_var[s->mb_stride * mb_y + mb_x] = vard; | 1177 pic->mc_mb_var[s->mb_stride * mb_y + mb_x] = vard; |
1178 c->mc_mb_var_sum_temp += vard; | 1178 c->mc_mb_var_sum_temp += vard; |
1179 if (vard <= 64 || vard < varc) { //FIXME | 1179 if (vard <= 64 || vard < varc) { //FIXME |
1180 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc); | 1180 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc); |
1229 P_TOPRIGHT[0] = s->current_picture.motion_val[0][mot_xy - mot_stride + 2][0]; | 1229 P_TOPRIGHT[0] = s->current_picture.motion_val[0][mot_xy - mot_stride + 2][0]; |
1230 P_TOPRIGHT[1] = s->current_picture.motion_val[0][mot_xy - mot_stride + 2][1]; | 1230 P_TOPRIGHT[1] = s->current_picture.motion_val[0][mot_xy - mot_stride + 2][1]; |
1231 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift); | 1231 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift); |
1232 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift); | 1232 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift); |
1233 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift); | 1233 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift); |
1234 | 1234 |
1235 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); | 1235 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); |
1236 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | 1236 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); |
1237 | 1237 |
1238 if(s->out_format == FMT_H263){ | 1238 if(s->out_format == FMT_H263){ |
1239 c->pred_x = P_MEDIAN[0]; | 1239 c->pred_x = P_MEDIAN[0]; |
1246 c->pred_x= P_LEFT[0]; | 1246 c->pred_x= P_LEFT[0]; |
1247 c->pred_y= P_LEFT[1]; | 1247 c->pred_y= P_LEFT[1]; |
1248 } | 1248 } |
1249 | 1249 |
1250 } | 1250 } |
1251 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, s->p_mv_table, (1<<16)>>shift, 0, 16); | 1251 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, s->p_mv_table, (1<<16)>>shift, 0, 16); |
1252 | 1252 |
1253 break; | 1253 break; |
1254 } | 1254 } |
1255 | 1255 |
1256 /* At this point (mx,my) are full-pell and the relative displacement */ | 1256 /* At this point (mx,my) are full-pell and the relative displacement */ |
1257 ppix = c->ref[0][0] + (my * s->linesize) + mx; | 1257 ppix = c->ref[0][0] + (my * s->linesize) + mx; |
1258 | 1258 |
1259 vard = (s->dsp.sse[0](NULL, pix, ppix, s->linesize, 16)+128)>>8; | 1259 vard = (s->dsp.sse[0](NULL, pix, ppix, s->linesize, 16)+128)>>8; |
1260 | 1260 |
1261 pic->mc_mb_var[s->mb_stride * mb_y + mb_x] = vard; | 1261 pic->mc_mb_var[s->mb_stride * mb_y + mb_x] = vard; |
1262 // pic->mb_cmp_score[s->mb_stride * mb_y + mb_x] = dmin; | 1262 // pic->mb_cmp_score[s->mb_stride * mb_y + mb_x] = dmin; |
1263 c->mc_mb_var_sum_temp += vard; | 1263 c->mc_mb_var_sum_temp += vard; |
1264 | 1264 |
1265 #if 0 | 1265 #if 0 |
1266 printf("varc=%4d avg_var=%4d (sum=%4d) vard=%4d mx=%2d my=%2d\n", | 1266 printf("varc=%4d avg_var=%4d (sum=%4d) vard=%4d mx=%2d my=%2d\n", |
1267 varc, s->avg_mb_var, sum, vard, mx - xx, my - yy); | 1267 varc, s->avg_mb_var, sum, vard, mx - xx, my - yy); |
1268 #endif | 1268 #endif |
1269 if(mb_type){ | 1269 if(mb_type){ |
1340 if(dmin_i < dmin){ | 1340 if(dmin_i < dmin){ |
1341 mb_type = CANDIDATE_MB_TYPE_INTER_I; | 1341 mb_type = CANDIDATE_MB_TYPE_INTER_I; |
1342 dmin= dmin_i; | 1342 dmin= dmin_i; |
1343 } | 1343 } |
1344 } | 1344 } |
1345 | 1345 |
1346 // pic->mb_cmp_score[s->mb_stride * mb_y + mb_x] = dmin; | 1346 // pic->mb_cmp_score[s->mb_stride * mb_y + mb_x] = dmin; |
1347 set_p_mv_tables(s, mx, my, mb_type!=CANDIDATE_MB_TYPE_INTER4V); | 1347 set_p_mv_tables(s, mx, my, mb_type!=CANDIDATE_MB_TYPE_INTER4V); |
1348 | 1348 |
1349 /* get intra luma score */ | 1349 /* get intra luma score */ |
1350 if((c->avctx->mb_cmp&0xFF)==FF_CMP_SSE){ | 1350 if((c->avctx->mb_cmp&0xFF)==FF_CMP_SSE){ |
1351 intra_score= (varc<<8) - 500; //FIXME dont scale it down so we dont have to fix it | 1351 intra_score= (varc<<8) - 500; //FIXME dont scale it down so we dont have to fix it |
1352 }else{ | 1352 }else{ |
1353 int mean= (sum+128)>>8; | 1353 int mean= (sum+128)>>8; |
1354 mean*= 0x01010101; | 1354 mean*= 0x01010101; |
1355 | 1355 |
1356 for(i=0; i<16; i++){ | 1356 for(i=0; i<16; i++){ |
1357 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 0]) = mean; | 1357 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 0]) = mean; |
1358 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 4]) = mean; | 1358 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 4]) = mean; |
1359 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 8]) = mean; | 1359 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 8]) = mean; |
1360 *(uint32_t*)(&c->scratchpad[i*s->linesize+12]) = mean; | 1360 *(uint32_t*)(&c->scratchpad[i*s->linesize+12]) = mean; |
1366 /* get chroma score */ | 1366 /* get chroma score */ |
1367 if(c->avctx->mb_cmp&FF_CMP_CHROMA){ | 1367 if(c->avctx->mb_cmp&FF_CMP_CHROMA){ |
1368 for(i=1; i<3; i++){ | 1368 for(i=1; i<3; i++){ |
1369 uint8_t *dest_c; | 1369 uint8_t *dest_c; |
1370 int mean; | 1370 int mean; |
1371 | 1371 |
1372 if(s->out_format == FMT_H263){ | 1372 if(s->out_format == FMT_H263){ |
1373 mean= (s->dc_val[i][mb_x + mb_y*s->b8_stride] + 4)>>3; //FIXME not exact but simple ;) | 1373 mean= (s->dc_val[i][mb_x + mb_y*s->b8_stride] + 4)>>3; //FIXME not exact but simple ;) |
1374 }else{ | 1374 }else{ |
1375 mean= (s->last_dc[i] + 4)>>3; | 1375 mean= (s->last_dc[i] + 4)>>3; |
1376 } | 1376 } |
1377 dest_c = s->new_picture.data[i] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8; | 1377 dest_c = s->new_picture.data[i] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8; |
1378 | 1378 |
1379 mean*= 0x01010101; | 1379 mean*= 0x01010101; |
1380 for(i=0; i<8; i++){ | 1380 for(i=0; i<8; i++){ |
1381 *(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 0]) = mean; | 1381 *(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 0]) = mean; |
1382 *(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 4]) = mean; | 1382 *(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 4]) = mean; |
1383 } | 1383 } |
1384 | 1384 |
1385 intra_score+= s->dsp.mb_cmp[1](s, c->scratchpad, dest_c, s->uvlinesize); | 1385 intra_score+= s->dsp.mb_cmp[1](s, c->scratchpad, dest_c, s->uvlinesize); |
1386 } | 1386 } |
1387 } | 1387 } |
1388 #endif | 1388 #endif |
1389 intra_score += c->mb_penalty_factor*16; | 1389 intra_score += c->mb_penalty_factor*16; |
1390 | 1390 |
1391 if(intra_score < dmin){ | 1391 if(intra_score < dmin){ |
1392 mb_type= CANDIDATE_MB_TYPE_INTRA; | 1392 mb_type= CANDIDATE_MB_TYPE_INTRA; |
1393 s->current_picture.mb_type[mb_y*s->mb_stride + mb_x]= CANDIDATE_MB_TYPE_INTRA; //FIXME cleanup | 1393 s->current_picture.mb_type[mb_y*s->mb_stride + mb_x]= CANDIDATE_MB_TYPE_INTRA; //FIXME cleanup |
1394 }else | 1394 }else |
1395 s->current_picture.mb_type[mb_y*s->mb_stride + mb_x]= 0; | 1395 s->current_picture.mb_type[mb_y*s->mb_stride + mb_x]= 0; |
1396 | 1396 |
1397 if (vard <= 64 || vard < varc) { //FIXME | 1397 if (vard <= 64 || vard < varc) { //FIXME |
1398 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc); | 1398 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc); |
1399 }else{ | 1399 }else{ |
1400 c->scene_change_score+= s->qscale; | 1400 c->scene_change_score+= s->qscale; |
1401 } | 1401 } |
1411 int mx, my, dmin; | 1411 int mx, my, dmin; |
1412 int P[10][2]; | 1412 int P[10][2]; |
1413 const int shift= 1+s->quarter_sample; | 1413 const int shift= 1+s->quarter_sample; |
1414 const int xy= mb_x + mb_y*s->mb_stride; | 1414 const int xy= mb_x + mb_y*s->mb_stride; |
1415 init_ref(c, s->new_picture.data, s->last_picture.data, NULL, 16*mb_x, 16*mb_y, 0); | 1415 init_ref(c, s->new_picture.data, s->last_picture.data, NULL, 16*mb_x, 16*mb_y, 0); |
1416 | 1416 |
1417 assert(s->quarter_sample==0 || s->quarter_sample==1); | 1417 assert(s->quarter_sample==0 || s->quarter_sample==1); |
1418 | 1418 |
1419 c->pre_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_pre_cmp); | 1419 c->pre_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_pre_cmp); |
1420 c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV; | 1420 c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV; |
1421 | 1421 |
1430 /* special case for first line */ | 1430 /* special case for first line */ |
1431 if (s->first_slice_line) { | 1431 if (s->first_slice_line) { |
1432 c->pred_x= P_LEFT[0]; | 1432 c->pred_x= P_LEFT[0]; |
1433 c->pred_y= P_LEFT[1]; | 1433 c->pred_y= P_LEFT[1]; |
1434 P_TOP[0]= P_TOPRIGHT[0]= P_MEDIAN[0]= | 1434 P_TOP[0]= P_TOPRIGHT[0]= P_MEDIAN[0]= |
1435 P_TOP[1]= P_TOPRIGHT[1]= P_MEDIAN[1]= 0; //FIXME | 1435 P_TOP[1]= P_TOPRIGHT[1]= P_MEDIAN[1]= 0; //FIXME |
1436 } else { | 1436 } else { |
1437 P_TOP[0] = s->p_mv_table[xy + s->mb_stride ][0]; | 1437 P_TOP[0] = s->p_mv_table[xy + s->mb_stride ][0]; |
1438 P_TOP[1] = s->p_mv_table[xy + s->mb_stride ][1]; | 1438 P_TOP[1] = s->p_mv_table[xy + s->mb_stride ][1]; |
1439 P_TOPRIGHT[0] = s->p_mv_table[xy + s->mb_stride - 1][0]; | 1439 P_TOPRIGHT[0] = s->p_mv_table[xy + s->mb_stride - 1][0]; |
1440 P_TOPRIGHT[1] = s->p_mv_table[xy + s->mb_stride - 1][1]; | 1440 P_TOPRIGHT[1] = s->p_mv_table[xy + s->mb_stride - 1][1]; |
1441 if(P_TOP[1] < (c->ymin<<shift)) P_TOP[1] = (c->ymin<<shift); | 1441 if(P_TOP[1] < (c->ymin<<shift)) P_TOP[1] = (c->ymin<<shift); |
1442 if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); | 1442 if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); |
1443 if(P_TOPRIGHT[1] < (c->ymin<<shift)) P_TOPRIGHT[1]= (c->ymin<<shift); | 1443 if(P_TOPRIGHT[1] < (c->ymin<<shift)) P_TOPRIGHT[1]= (c->ymin<<shift); |
1444 | 1444 |
1445 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); | 1445 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); |
1446 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | 1446 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); |
1447 | 1447 |
1448 c->pred_x = P_MEDIAN[0]; | 1448 c->pred_x = P_MEDIAN[0]; |
1449 c->pred_y = P_MEDIAN[1]; | 1449 c->pred_y = P_MEDIAN[1]; |
1450 } | 1450 } |
1451 | 1451 |
1452 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, s->p_mv_table, (1<<16)>>shift, 0, 16); | 1452 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, s->p_mv_table, (1<<16)>>shift, 0, 16); |
1453 | 1453 |
1454 s->p_mv_table[xy][0] = mx<<shift; | 1454 s->p_mv_table[xy][0] = mx<<shift; |
1455 s->p_mv_table[xy][1] = my<<shift; | 1455 s->p_mv_table[xy][1] = my<<shift; |
1456 | 1456 |
1457 return dmin; | 1457 return dmin; |
1458 } | 1458 } |
1459 | 1459 |
1460 static int ff_estimate_motion_b(MpegEncContext * s, | 1460 static int ff_estimate_motion_b(MpegEncContext * s, |
1461 int mb_x, int mb_y, int16_t (*mv_table)[2], int ref_index, int f_code) | 1461 int mb_x, int mb_y, int16_t (*mv_table)[2], int ref_index, int f_code) |
1466 const int shift= 1+s->quarter_sample; | 1466 const int shift= 1+s->quarter_sample; |
1467 const int mot_stride = s->mb_stride; | 1467 const int mot_stride = s->mb_stride; |
1468 const int mot_xy = mb_y*mot_stride + mb_x; | 1468 const int mot_xy = mb_y*mot_stride + mb_x; |
1469 uint8_t * const mv_penalty= c->mv_penalty[f_code] + MAX_MV; | 1469 uint8_t * const mv_penalty= c->mv_penalty[f_code] + MAX_MV; |
1470 int mv_scale; | 1470 int mv_scale; |
1471 | 1471 |
1472 c->penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp); | 1472 c->penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp); |
1473 c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp); | 1473 c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp); |
1474 c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp); | 1474 c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp); |
1475 c->current_mv_penalty= mv_penalty; | 1475 c->current_mv_penalty= mv_penalty; |
1476 | 1476 |
1516 P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1 ][0]; | 1516 P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1 ][0]; |
1517 P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1 ][1]; | 1517 P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1 ][1]; |
1518 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1]= (c->ymax<<shift); | 1518 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1]= (c->ymax<<shift); |
1519 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift); | 1519 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift); |
1520 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift); | 1520 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift); |
1521 | 1521 |
1522 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); | 1522 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); |
1523 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | 1523 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); |
1524 } | 1524 } |
1525 c->pred_x= P_LEFT[0]; | 1525 c->pred_x= P_LEFT[0]; |
1526 c->pred_y= P_LEFT[1]; | 1526 c->pred_y= P_LEFT[1]; |
1527 } | 1527 } |
1528 | 1528 |
1529 if(mv_table == s->b_forw_mv_table){ | 1529 if(mv_table == s->b_forw_mv_table){ |
1530 mv_scale= (s->pb_time<<16) / (s->pp_time<<shift); | 1530 mv_scale= (s->pb_time<<16) / (s->pp_time<<shift); |
1531 }else{ | 1531 }else{ |
1532 mv_scale= ((s->pb_time - s->pp_time)<<16) / (s->pp_time<<shift); | 1532 mv_scale= ((s->pb_time - s->pp_time)<<16) / (s->pp_time<<shift); |
1533 } | 1533 } |
1534 | 1534 |
1535 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, ref_index, s->p_mv_table, mv_scale, 0, 16); | 1535 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, ref_index, s->p_mv_table, mv_scale, 0, 16); |
1536 | 1536 |
1537 break; | 1537 break; |
1538 } | 1538 } |
1539 | 1539 |
1540 dmin= c->sub_motion_search(s, &mx, &my, dmin, 0, ref_index, 0, 16); | 1540 dmin= c->sub_motion_search(s, &mx, &my, dmin, 0, ref_index, 0, 16); |
1541 | 1541 |
1542 if(c->avctx->me_sub_cmp != c->avctx->mb_cmp && !c->skip) | 1542 if(c->avctx->me_sub_cmp != c->avctx->mb_cmp && !c->skip) |
1543 dmin= ff_get_mb_score(s, mx, my, 0, ref_index, 0, 16, 1); | 1543 dmin= ff_get_mb_score(s, mx, my, 0, ref_index, 0, 16, 1); |
1544 | 1544 |
1545 //printf("%d %d %d %d//", s->mb_x, s->mb_y, mx, my); | 1545 //printf("%d %d %d %d//", s->mb_x, s->mb_y, mx, my); |
1546 // s->mb_type[mb_y*s->mb_width + mb_x]= mb_type; | 1546 // s->mb_type[mb_y*s->mb_width + mb_x]= mb_type; |
1581 s->dsp.put_qpel_pixels_tab[0][dxy](dest_y , ptr , stride); | 1581 s->dsp.put_qpel_pixels_tab[0][dxy](dest_y , ptr , stride); |
1582 | 1582 |
1583 dxy = ((motion_by & 3) << 2) | (motion_bx & 3); | 1583 dxy = ((motion_by & 3) << 2) | (motion_bx & 3); |
1584 src_x = motion_bx >> 2; | 1584 src_x = motion_bx >> 2; |
1585 src_y = motion_by >> 2; | 1585 src_y = motion_by >> 2; |
1586 | 1586 |
1587 ptr = ref2_data[0] + (src_y * stride) + src_x; | 1587 ptr = ref2_data[0] + (src_y * stride) + src_x; |
1588 s->dsp.avg_qpel_pixels_tab[size][dxy](dest_y , ptr , stride); | 1588 s->dsp.avg_qpel_pixels_tab[size][dxy](dest_y , ptr , stride); |
1589 }else{ | 1589 }else{ |
1590 dxy = ((motion_fy & 1) << 1) | (motion_fx & 1); | 1590 dxy = ((motion_fy & 1) << 1) | (motion_fx & 1); |
1591 src_x = motion_fx >> 1; | 1591 src_x = motion_fx >> 1; |
1595 s->dsp.put_pixels_tab[size][dxy](dest_y , ptr , stride, h); | 1595 s->dsp.put_pixels_tab[size][dxy](dest_y , ptr , stride, h); |
1596 | 1596 |
1597 dxy = ((motion_by & 1) << 1) | (motion_bx & 1); | 1597 dxy = ((motion_by & 1) << 1) | (motion_bx & 1); |
1598 src_x = motion_bx >> 1; | 1598 src_x = motion_bx >> 1; |
1599 src_y = motion_by >> 1; | 1599 src_y = motion_by >> 1; |
1600 | 1600 |
1601 ptr = ref2_data[0] + (src_y * stride) + src_x; | 1601 ptr = ref2_data[0] + (src_y * stride) + src_x; |
1602 s->dsp.avg_pixels_tab[size][dxy](dest_y , ptr , stride, h); | 1602 s->dsp.avg_pixels_tab[size][dxy](dest_y , ptr , stride, h); |
1603 } | 1603 } |
1604 | 1604 |
1605 fbmin = (mv_penalty[motion_fx-pred_fx] + mv_penalty[motion_fy-pred_fy])*c->mb_penalty_factor | 1605 fbmin = (mv_penalty[motion_fx-pred_fx] + mv_penalty[motion_fy-pred_fy])*c->mb_penalty_factor |
1606 +(mv_penalty[motion_bx-pred_bx] + mv_penalty[motion_by-pred_by])*c->mb_penalty_factor | 1606 +(mv_penalty[motion_bx-pred_bx] + mv_penalty[motion_by-pred_by])*c->mb_penalty_factor |
1607 + s->dsp.mb_cmp[size](s, src_data[0], dest_y, stride, h); //FIXME new_pic | 1607 + s->dsp.mb_cmp[size](s, src_data[0], dest_y, stride, h); //FIXME new_pic |
1608 | 1608 |
1609 if(c->avctx->mb_cmp&FF_CMP_CHROMA){ | 1609 if(c->avctx->mb_cmp&FF_CMP_CHROMA){ |
1610 } | 1610 } |
1611 //FIXME CHROMA !!! | 1611 //FIXME CHROMA !!! |
1612 | 1612 |
1613 return fbmin; | 1613 return fbmin; |
1614 } | 1614 } |
1615 | 1615 |
1616 /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/ | 1616 /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/ |
1617 static inline int bidir_refine(MpegEncContext * s, int mb_x, int mb_y) | 1617 static inline int bidir_refine(MpegEncContext * s, int mb_x, int mb_y) |
1627 int motion_fy= s->b_bidir_forw_mv_table[xy][1]= s->b_forw_mv_table[xy][1]; | 1627 int motion_fy= s->b_bidir_forw_mv_table[xy][1]= s->b_forw_mv_table[xy][1]; |
1628 int motion_bx= s->b_bidir_back_mv_table[xy][0]= s->b_back_mv_table[xy][0]; | 1628 int motion_bx= s->b_bidir_back_mv_table[xy][0]= s->b_back_mv_table[xy][0]; |
1629 int motion_by= s->b_bidir_back_mv_table[xy][1]= s->b_back_mv_table[xy][1]; | 1629 int motion_by= s->b_bidir_back_mv_table[xy][1]= s->b_back_mv_table[xy][1]; |
1630 | 1630 |
1631 //FIXME do refinement and add flag | 1631 //FIXME do refinement and add flag |
1632 | 1632 |
1633 fbmin= check_bidir_mv(s, motion_fx, motion_fy, | 1633 fbmin= check_bidir_mv(s, motion_fx, motion_fy, |
1634 motion_bx, motion_by, | 1634 motion_bx, motion_by, |
1635 pred_fx, pred_fy, | 1635 pred_fx, pred_fy, |
1636 pred_bx, pred_by, | 1636 pred_bx, pred_by, |
1637 0, 16); | 1637 0, 16); |
1649 int dmin, i; | 1649 int dmin, i; |
1650 const int time_pp= s->pp_time; | 1650 const int time_pp= s->pp_time; |
1651 const int time_pb= s->pb_time; | 1651 const int time_pb= s->pb_time; |
1652 int mx, my, xmin, xmax, ymin, ymax; | 1652 int mx, my, xmin, xmax, ymin, ymax; |
1653 int16_t (*mv_table)[2]= s->b_direct_mv_table; | 1653 int16_t (*mv_table)[2]= s->b_direct_mv_table; |
1654 | 1654 |
1655 c->current_mv_penalty= c->mv_penalty[1] + MAX_MV; | 1655 c->current_mv_penalty= c->mv_penalty[1] + MAX_MV; |
1656 ymin= xmin=(-32)>>shift; | 1656 ymin= xmin=(-32)>>shift; |
1657 ymax= xmax= 31>>shift; | 1657 ymax= xmax= 31>>shift; |
1658 | 1658 |
1659 if(IS_8X8(s->next_picture.mb_type[mot_xy])){ | 1659 if(IS_8X8(s->next_picture.mb_type[mot_xy])){ |
1663 } | 1663 } |
1664 | 1664 |
1665 for(i=0; i<4; i++){ | 1665 for(i=0; i<4; i++){ |
1666 int index= s->block_index[i]; | 1666 int index= s->block_index[i]; |
1667 int min, max; | 1667 int min, max; |
1668 | 1668 |
1669 c->co_located_mv[i][0]= s->next_picture.motion_val[0][index][0]; | 1669 c->co_located_mv[i][0]= s->next_picture.motion_val[0][index][0]; |
1670 c->co_located_mv[i][1]= s->next_picture.motion_val[0][index][1]; | 1670 c->co_located_mv[i][1]= s->next_picture.motion_val[0][index][1]; |
1671 c->direct_basis_mv[i][0]= c->co_located_mv[i][0]*time_pb/time_pp + ((i& 1)<<(shift+3)); | 1671 c->direct_basis_mv[i][0]= c->co_located_mv[i][0]*time_pb/time_pp + ((i& 1)<<(shift+3)); |
1672 c->direct_basis_mv[i][1]= c->co_located_mv[i][1]*time_pb/time_pp + ((i>>1)<<(shift+3)); | 1672 c->direct_basis_mv[i][1]= c->co_located_mv[i][1]*time_pb/time_pp + ((i>>1)<<(shift+3)); |
1673 // c->direct_basis_mv[1][i][0]= c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(shift+3); | 1673 // c->direct_basis_mv[1][i][0]= c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(shift+3); |
1684 min= FFMIN(c->direct_basis_mv[i][1], c->direct_basis_mv[i][1] - c->co_located_mv[i][1])>>shift; | 1684 min= FFMIN(c->direct_basis_mv[i][1], c->direct_basis_mv[i][1] - c->co_located_mv[i][1])>>shift; |
1685 max+= 16*mb_y + 1; // +-1 is for the simpler rounding | 1685 max+= 16*mb_y + 1; // +-1 is for the simpler rounding |
1686 min+= 16*mb_y - 1; | 1686 min+= 16*mb_y - 1; |
1687 ymax= FFMIN(ymax, s->height - max); | 1687 ymax= FFMIN(ymax, s->height - max); |
1688 ymin= FFMAX(ymin, - 16 - min); | 1688 ymin= FFMAX(ymin, - 16 - min); |
1689 | 1689 |
1690 if(s->mv_type == MV_TYPE_16X16) break; | 1690 if(s->mv_type == MV_TYPE_16X16) break; |
1691 } | 1691 } |
1692 | 1692 |
1693 assert(xmax <= 15 && ymax <= 15 && xmin >= -16 && ymin >= -16); | 1693 assert(xmax <= 15 && ymax <= 15 && xmin >= -16 && ymin >= -16); |
1694 | 1694 |
1695 if(xmax < 0 || xmin >0 || ymax < 0 || ymin > 0){ | 1695 if(xmax < 0 || xmin >0 || ymax < 0 || ymin > 0){ |
1696 s->b_direct_mv_table[mot_xy][0]= 0; | 1696 s->b_direct_mv_table[mot_xy][0]= 0; |
1697 s->b_direct_mv_table[mot_xy][1]= 0; | 1697 s->b_direct_mv_table[mot_xy][1]= 0; |
1698 | 1698 |
1699 return 256*256*256*64; | 1699 return 256*256*256*64; |
1700 } | 1700 } |
1701 | 1701 |
1702 c->xmin= xmin; | 1702 c->xmin= xmin; |
1703 c->ymin= ymin; | 1703 c->ymin= ymin; |
1704 c->xmax= xmax; | 1704 c->xmax= xmax; |
1705 c->ymax= ymax; | 1705 c->ymax= ymax; |
1706 c->flags |= FLAG_DIRECT; | 1706 c->flags |= FLAG_DIRECT; |
1715 if (!s->first_slice_line) { //FIXME maybe allow this over thread boundary as its cliped | 1715 if (!s->first_slice_line) { //FIXME maybe allow this over thread boundary as its cliped |
1716 P_TOP[0] = clip(mv_table[mot_xy - mot_stride ][0], xmin<<shift, xmax<<shift); | 1716 P_TOP[0] = clip(mv_table[mot_xy - mot_stride ][0], xmin<<shift, xmax<<shift); |
1717 P_TOP[1] = clip(mv_table[mot_xy - mot_stride ][1], ymin<<shift, ymax<<shift); | 1717 P_TOP[1] = clip(mv_table[mot_xy - mot_stride ][1], ymin<<shift, ymax<<shift); |
1718 P_TOPRIGHT[0] = clip(mv_table[mot_xy - mot_stride + 1 ][0], xmin<<shift, xmax<<shift); | 1718 P_TOPRIGHT[0] = clip(mv_table[mot_xy - mot_stride + 1 ][0], xmin<<shift, xmax<<shift); |
1719 P_TOPRIGHT[1] = clip(mv_table[mot_xy - mot_stride + 1 ][1], ymin<<shift, ymax<<shift); | 1719 P_TOPRIGHT[1] = clip(mv_table[mot_xy - mot_stride + 1 ][1], ymin<<shift, ymax<<shift); |
1720 | 1720 |
1721 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); | 1721 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); |
1722 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | 1722 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); |
1723 } | 1723 } |
1724 | 1724 |
1725 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, mv_table, 1<<(16-shift), 0, 16); | 1725 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, mv_table, 1<<(16-shift), 0, 16); |
1726 if(c->sub_flags&FLAG_QPEL) | 1726 if(c->sub_flags&FLAG_QPEL) |
1727 dmin = qpel_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16); | 1727 dmin = qpel_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16); |
1728 else | 1728 else |
1729 dmin = hpel_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16); | 1729 dmin = hpel_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16); |
1730 | 1730 |
1731 if(c->avctx->me_sub_cmp != c->avctx->mb_cmp && !c->skip) | 1731 if(c->avctx->me_sub_cmp != c->avctx->mb_cmp && !c->skip) |
1732 dmin= ff_get_mb_score(s, mx, my, 0, 0, 0, 16, 1); | 1732 dmin= ff_get_mb_score(s, mx, my, 0, 0, 0, 16, 1); |
1733 | 1733 |
1734 get_limits(s, 16*mb_x, 16*mb_y); //restore c->?min/max, maybe not needed | 1734 get_limits(s, 16*mb_x, 16*mb_y); //restore c->?min/max, maybe not needed |
1735 | 1735 |
1736 s->b_direct_mv_table[mot_xy][0]= mx; | 1736 s->b_direct_mv_table[mot_xy][0]= mx; |
1737 s->b_direct_mv_table[mot_xy][1]= my; | 1737 s->b_direct_mv_table[mot_xy][1]= my; |
1738 c->flags &= ~FLAG_DIRECT; | 1738 c->flags &= ~FLAG_DIRECT; |
1750 int type=0; | 1750 int type=0; |
1751 const int xy = mb_y*s->mb_stride + mb_x; | 1751 const int xy = mb_y*s->mb_stride + mb_x; |
1752 init_ref(c, s->new_picture.data, s->last_picture.data, s->next_picture.data, 16*mb_x, 16*mb_y, 2); | 1752 init_ref(c, s->new_picture.data, s->last_picture.data, s->next_picture.data, 16*mb_x, 16*mb_y, 2); |
1753 | 1753 |
1754 get_limits(s, 16*mb_x, 16*mb_y); | 1754 get_limits(s, 16*mb_x, 16*mb_y); |
1755 | 1755 |
1756 c->skip=0; | 1756 c->skip=0; |
1757 if(c->avctx->me_threshold){ | 1757 if(c->avctx->me_threshold){ |
1758 int vard= (check_input_motion(s, mb_x, mb_y, 0)+128)>>8; | 1758 int vard= (check_input_motion(s, mb_x, mb_y, 0)+128)>>8; |
1759 | 1759 |
1760 if(vard<c->avctx->me_threshold){ | 1760 if(vard<c->avctx->me_threshold){ |
1761 // pix = c->src[0][0]; | 1761 // pix = c->src[0][0]; |
1762 // sum = s->dsp.pix_sum(pix, s->linesize); | 1762 // sum = s->dsp.pix_sum(pix, s->linesize); |
1763 // varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8; | 1763 // varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8; |
1764 | 1764 |
1765 // pic->mb_var [s->mb_stride * mb_y + mb_x] = varc; | 1765 // pic->mb_var [s->mb_stride * mb_y + mb_x] = varc; |
1766 s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] = vard; | 1766 s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] = vard; |
1767 /* pic->mb_mean [s->mb_stride * mb_y + mb_x] = (sum+128)>>8; | 1767 /* pic->mb_mean [s->mb_stride * mb_y + mb_x] = (sum+128)>>8; |
1768 c->mb_var_sum_temp += varc;*/ | 1768 c->mb_var_sum_temp += varc;*/ |
1769 c->mc_mb_var_sum_temp += vard; | 1769 c->mc_mb_var_sum_temp += vard; |
1810 else | 1810 else |
1811 dmin= INT_MAX; | 1811 dmin= INT_MAX; |
1812 //FIXME penalty stuff for non mpeg4 | 1812 //FIXME penalty stuff for non mpeg4 |
1813 c->skip=0; | 1813 c->skip=0; |
1814 fmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, 0, s->f_code) + 3*penalty_factor; | 1814 fmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, 0, s->f_code) + 3*penalty_factor; |
1815 | 1815 |
1816 c->skip=0; | 1816 c->skip=0; |
1817 bmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, 2, s->b_code) + 2*penalty_factor; | 1817 bmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, 2, s->b_code) + 2*penalty_factor; |
1818 //printf(" %d %d ", s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1]); | 1818 //printf(" %d %d ", s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1]); |
1819 | 1819 |
1820 c->skip=0; | 1820 c->skip=0; |
1821 fbmin= bidir_refine(s, mb_x, mb_y) + penalty_factor; | 1821 fbmin= bidir_refine(s, mb_x, mb_y) + penalty_factor; |
1822 //printf("%d %d %d %d\n", dmin, fmin, bmin, fbmin); | 1822 //printf("%d %d %d %d\n", dmin, fmin, bmin, fbmin); |
1823 | 1823 |
1824 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | 1824 if(s->flags & CODEC_FLAG_INTERLACED_ME){ |
1825 //FIXME mb type penalty | 1825 //FIXME mb type penalty |
1826 c->skip=0; | 1826 c->skip=0; |
1827 c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV; | 1827 c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV; |
1828 fimin= interlaced_search(s, 0, | 1828 fimin= interlaced_search(s, 0, |
1836 fimin= bimin= INT_MAX; | 1836 fimin= bimin= INT_MAX; |
1837 | 1837 |
1838 { | 1838 { |
1839 int score= fmin; | 1839 int score= fmin; |
1840 type = CANDIDATE_MB_TYPE_FORWARD; | 1840 type = CANDIDATE_MB_TYPE_FORWARD; |
1841 | 1841 |
1842 if (dmin <= score){ | 1842 if (dmin <= score){ |
1843 score = dmin; | 1843 score = dmin; |
1844 type = CANDIDATE_MB_TYPE_DIRECT; | 1844 type = CANDIDATE_MB_TYPE_DIRECT; |
1845 } | 1845 } |
1846 if(bmin<score){ | 1846 if(bmin<score){ |
1847 score=bmin; | 1847 score=bmin; |
1848 type= CANDIDATE_MB_TYPE_BACKWARD; | 1848 type= CANDIDATE_MB_TYPE_BACKWARD; |
1849 } | 1849 } |
1850 if(fbmin<score){ | 1850 if(fbmin<score){ |
1851 score=fbmin; | 1851 score=fbmin; |
1852 type= CANDIDATE_MB_TYPE_BIDIR; | 1852 type= CANDIDATE_MB_TYPE_BIDIR; |
1853 } | 1853 } |
1857 } | 1857 } |
1858 if(bimin<score){ | 1858 if(bimin<score){ |
1859 score=bimin; | 1859 score=bimin; |
1860 type= CANDIDATE_MB_TYPE_BACKWARD_I; | 1860 type= CANDIDATE_MB_TYPE_BACKWARD_I; |
1861 } | 1861 } |
1862 | 1862 |
1863 score= ((unsigned)(score*score + 128*256))>>16; | 1863 score= ((unsigned)(score*score + 128*256))>>16; |
1864 c->mc_mb_var_sum_temp += score; | 1864 c->mc_mb_var_sum_temp += score; |
1865 s->current_picture.mc_mb_var[mb_y*s->mb_stride + mb_x] = score; //FIXME use SSE | 1865 s->current_picture.mc_mb_var[mb_y*s->mb_stride + mb_x] = score; //FIXME use SSE |
1866 } | 1866 } |
1867 | 1867 |
1874 if(fimin < INT_MAX && bimin < INT_MAX){ | 1874 if(fimin < INT_MAX && bimin < INT_MAX){ |
1875 type |= CANDIDATE_MB_TYPE_BIDIR_I; | 1875 type |= CANDIDATE_MB_TYPE_BIDIR_I; |
1876 } | 1876 } |
1877 //FIXME something smarter | 1877 //FIXME something smarter |
1878 if(dmin>256*256*16) type&= ~CANDIDATE_MB_TYPE_DIRECT; //dont try direct mode if its invalid for this MB | 1878 if(dmin>256*256*16) type&= ~CANDIDATE_MB_TYPE_DIRECT; //dont try direct mode if its invalid for this MB |
1879 #if 0 | 1879 #if 0 |
1880 if(s->out_format == FMT_MPEG1) | 1880 if(s->out_format == FMT_MPEG1) |
1881 type |= CANDIDATE_MB_TYPE_INTRA; | 1881 type |= CANDIDATE_MB_TYPE_INTRA; |
1882 #endif | 1882 #endif |
1883 } | 1883 } |
1884 | 1884 |
1893 int i, y, range= s->avctx->me_range ? s->avctx->me_range : (INT_MAX/2); | 1893 int i, y, range= s->avctx->me_range ? s->avctx->me_range : (INT_MAX/2); |
1894 uint8_t * fcode_tab= s->fcode_tab; | 1894 uint8_t * fcode_tab= s->fcode_tab; |
1895 int best_fcode=-1; | 1895 int best_fcode=-1; |
1896 int best_score=-10000000; | 1896 int best_score=-10000000; |
1897 | 1897 |
1898 if(s->msmpeg4_version) | 1898 if(s->msmpeg4_version) |
1899 range= FFMIN(range, 16); | 1899 range= FFMIN(range, 16); |
1900 else if(s->codec_id == CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL) | 1900 else if(s->codec_id == CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL) |
1901 range= FFMIN(range, 256); | 1901 range= FFMIN(range, 256); |
1902 | 1902 |
1903 for(i=0; i<8; i++) score[i]= s->mb_num*(8-i); | 1903 for(i=0; i<8; i++) score[i]= s->mb_num*(8-i); |
1910 int mx= mv_table[xy][0]; | 1910 int mx= mv_table[xy][0]; |
1911 int my= mv_table[xy][1]; | 1911 int my= mv_table[xy][1]; |
1912 int fcode= FFMAX(fcode_tab[mx + MAX_MV], | 1912 int fcode= FFMAX(fcode_tab[mx + MAX_MV], |
1913 fcode_tab[my + MAX_MV]); | 1913 fcode_tab[my + MAX_MV]); |
1914 int j; | 1914 int j; |
1915 | 1915 |
1916 if(mx >= range || mx < -range || | 1916 if(mx >= range || mx < -range || |
1917 my >= range || my < -range) | 1917 my >= range || my < -range) |
1918 continue; | 1918 continue; |
1919 | 1919 |
1920 for(j=0; j<fcode && j<8; j++){ | 1920 for(j=0; j<fcode && j<8; j++){ |
1921 if(s->pict_type==B_TYPE || s->current_picture.mc_mb_var[xy] < s->current_picture.mb_var[xy]) | 1921 if(s->pict_type==B_TYPE || s->current_picture.mc_mb_var[xy] < s->current_picture.mb_var[xy]) |
1922 score[j]-= 170; | 1922 score[j]-= 170; |
1923 } | 1923 } |
1924 } | 1924 } |
1925 xy++; | 1925 xy++; |
1926 } | 1926 } |
1927 } | 1927 } |
1928 | 1928 |
1929 for(i=1; i<8; i++){ | 1929 for(i=1; i<8; i++){ |
1930 if(score[i] > best_score){ | 1930 if(score[i] > best_score){ |
1931 best_score= score[i]; | 1931 best_score= score[i]; |
1932 best_fcode= i; | 1932 best_fcode= i; |
1933 } | 1933 } |
1954 | 1954 |
1955 range = (((s->out_format == FMT_MPEG1 || s->msmpeg4_version) ? 8 : 16) << f_code); | 1955 range = (((s->out_format == FMT_MPEG1 || s->msmpeg4_version) ? 8 : 16) << f_code); |
1956 | 1956 |
1957 assert(range <= 16 || !s->msmpeg4_version); | 1957 assert(range <= 16 || !s->msmpeg4_version); |
1958 assert(range <=256 || !(s->codec_id == CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL)); | 1958 assert(range <=256 || !(s->codec_id == CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL)); |
1959 | 1959 |
1960 if(c->avctx->me_range && range > c->avctx->me_range) range= c->avctx->me_range; | 1960 if(c->avctx->me_range && range > c->avctx->me_range) range= c->avctx->me_range; |
1961 | 1961 |
1962 //printf("%d no:%d %d//\n", clip, noclip, f_code); | 1962 //printf("%d no:%d %d//\n", clip, noclip, f_code); |
1963 if(s->flags&CODEC_FLAG_4MV){ | 1963 if(s->flags&CODEC_FLAG_4MV){ |
1964 const int wrap= s->b8_stride; | 1964 const int wrap= s->b8_stride; |
1965 | 1965 |
1966 /* clip / convert to intra 8x8 type MVs */ | 1966 /* clip / convert to intra 8x8 type MVs */ |
1994 | 1994 |
1995 /** | 1995 /** |
1996 * | 1996 * |
1997 * @param truncate 1 for truncation, 0 for using intra | 1997 * @param truncate 1 for truncation, 0 for using intra |
1998 */ | 1998 */ |
1999 void ff_fix_long_mvs(MpegEncContext * s, uint8_t *field_select_table, int field_select, | 1999 void ff_fix_long_mvs(MpegEncContext * s, uint8_t *field_select_table, int field_select, |
2000 int16_t (*mv_table)[2], int f_code, int type, int truncate) | 2000 int16_t (*mv_table)[2], int f_code, int type, int truncate) |
2001 { | 2001 { |
2002 MotionEstContext * const c= &s->me; | 2002 MotionEstContext * const c= &s->me; |
2003 int y, h_range, v_range; | 2003 int y, h_range, v_range; |
2004 | 2004 |