3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer
6 * new motion estimation (X1/EPZS) by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
35 #include "mpegvideo.h"
40 #define SQ(a) ((a)*(a))
44 #define P_TOPRIGHT P[3]
48 static inline int sad_hpel_motion_search(MpegEncContext
* s
,
49 int *mx_ptr
, int *my_ptr
, int dmin
,
50 int src_index
, int ref_index
,
53 static inline int update_map_generation(MotionEstContext
*c
)
55 c
->map_generation
+= 1<<(ME_MAP_MV_BITS
*2);
56 if(c
->map_generation
==0){
57 c
->map_generation
= 1<<(ME_MAP_MV_BITS
*2);
58 memset(c
->map
, 0, sizeof(uint32_t)*ME_MAP_SIZE
);
60 return c
->map_generation
;
63 /* shape adaptive search stuff */
64 typedef struct Minima
{
70 static int minima_cmp(const void *a
, const void *b
){
71 const Minima
*da
= (const Minima
*) a
;
72 const Minima
*db
= (const Minima
*) b
;
74 return da
->height
- db
->height
;
77 #define FLAG_QPEL 1 //must be 1
81 static inline void init_ref(MotionEstContext
*c
, uint8_t *src
[3], uint8_t *ref
[3], uint8_t *ref2
[3], int x
, int y
, int ref_index
){
82 const int offset
[3]= {
84 ((y
*c
->uvstride
+ x
)>>1),
85 ((y
*c
->uvstride
+ x
)>>1),
89 c
->src
[0][i
]= src
[i
] + offset
[i
];
90 c
->ref
[0][i
]= ref
[i
] + offset
[i
];
94 c
->ref
[ref_index
][i
]= ref2
[i
] + offset
[i
];
99 static int get_flags(MotionEstContext
*c
, int direct
, int chroma
){
100 return ((c
->avctx
->flags
&CODEC_FLAG_QPEL
) ? FLAG_QPEL
: 0)
101 + (direct
? FLAG_DIRECT
: 0)
102 + (chroma
? FLAG_CHROMA
: 0);
105 /*! \brief compares a block (either a full macroblock or a partition thereof)
106 against a proposed motion-compensated prediction of that block
108 static av_always_inline
int cmp(MpegEncContext
*s
, const int x
, const int y
, const int subx
, const int suby
,
109 const int size
, const int h
, int ref_index
, int src_index
,
110 me_cmp_func cmp_func
, me_cmp_func chroma_cmp_func
, const int flags
){
111 MotionEstContext
* const c
= &s
->me
;
112 const int stride
= c
->stride
;
113 const int uvstride
= c
->uvstride
;
114 const int qpel
= flags
&FLAG_QPEL
;
115 const int chroma
= flags
&FLAG_CHROMA
;
116 const int dxy
= subx
+ (suby
<<(1+qpel
)); //FIXME log2_subpel?
117 const int hx
= subx
+ (x
<<(1+qpel
));
118 const int hy
= suby
+ (y
<<(1+qpel
));
119 uint8_t * const * const ref
= c
->ref
[ref_index
];
120 uint8_t * const * const src
= c
->src
[src_index
];
122 //FIXME check chroma 4mv, (no crashes ...)
123 if(flags
&FLAG_DIRECT
){
124 assert(x
>= c
->xmin
&& hx
<= c
->xmax
<<(qpel
+1) && y
>= c
->ymin
&& hy
<= c
->ymax
<<(qpel
+1));
125 if(x
>= c
->xmin
&& hx
<= c
->xmax
<<(qpel
+1) && y
>= c
->ymin
&& hy
<= c
->ymax
<<(qpel
+1)){
126 const int time_pp
= s
->pp_time
;
127 const int time_pb
= s
->pb_time
;
128 const int mask
= 2*qpel
+1;
129 if(s
->mv_type
==MV_TYPE_8X8
){
132 int fx
= c
->direct_basis_mv
[i
][0] + hx
;
133 int fy
= c
->direct_basis_mv
[i
][1] + hy
;
134 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));
135 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));
136 int fxy
= (fx
&mask
) + ((fy
&mask
)<<(qpel
+1));
137 int bxy
= (bx
&mask
) + ((by
&mask
)<<(qpel
+1));
139 uint8_t *dst
= c
->temp
+ 8*(i
&1) + 8*stride
*(i
>>1);
141 c
->qpel_put
[1][fxy
](dst
, ref
[0] + (fx
>>2) + (fy
>>2)*stride
, stride
);
142 c
->qpel_avg
[1][bxy
](dst
, ref
[8] + (bx
>>2) + (by
>>2)*stride
, stride
);
144 c
->hpel_put
[1][fxy
](dst
, ref
[0] + (fx
>>1) + (fy
>>1)*stride
, stride
, 8);
145 c
->hpel_avg
[1][bxy
](dst
, ref
[8] + (bx
>>1) + (by
>>1)*stride
, stride
, 8);
149 int fx
= c
->direct_basis_mv
[0][0] + hx
;
150 int fy
= c
->direct_basis_mv
[0][1] + hy
;
151 int bx
= hx
? fx
- c
->co_located_mv
[0][0] : (c
->co_located_mv
[0][0]*(time_pb
- time_pp
)/time_pp
);
152 int by
= hy
? fy
- c
->co_located_mv
[0][1] : (c
->co_located_mv
[0][1]*(time_pb
- time_pp
)/time_pp
);
153 int fxy
= (fx
&mask
) + ((fy
&mask
)<<(qpel
+1));
154 int bxy
= (bx
&mask
) + ((by
&mask
)<<(qpel
+1));
157 c
->qpel_put
[1][fxy
](c
->temp
, ref
[0] + (fx
>>2) + (fy
>>2)*stride
, stride
);
158 c
->qpel_put
[1][fxy
](c
->temp
+ 8 , ref
[0] + (fx
>>2) + (fy
>>2)*stride
+ 8 , stride
);
159 c
->qpel_put
[1][fxy
](c
->temp
+ 8*stride
, ref
[0] + (fx
>>2) + (fy
>>2)*stride
+ 8*stride
, stride
);
160 c
->qpel_put
[1][fxy
](c
->temp
+ 8 + 8*stride
, ref
[0] + (fx
>>2) + (fy
>>2)*stride
+ 8 + 8*stride
, stride
);
161 c
->qpel_avg
[1][bxy
](c
->temp
, ref
[8] + (bx
>>2) + (by
>>2)*stride
, stride
);
162 c
->qpel_avg
[1][bxy
](c
->temp
+ 8 , ref
[8] + (bx
>>2) + (by
>>2)*stride
+ 8 , stride
);
163 c
->qpel_avg
[1][bxy
](c
->temp
+ 8*stride
, ref
[8] + (bx
>>2) + (by
>>2)*stride
+ 8*stride
, stride
);
164 c
->qpel_avg
[1][bxy
](c
->temp
+ 8 + 8*stride
, ref
[8] + (bx
>>2) + (by
>>2)*stride
+ 8 + 8*stride
, stride
);
166 assert((fx
>>1) + 16*s
->mb_x
>= -16);
167 assert((fy
>>1) + 16*s
->mb_y
>= -16);
168 assert((fx
>>1) + 16*s
->mb_x
<= s
->width
);
169 assert((fy
>>1) + 16*s
->mb_y
<= s
->height
);
170 assert((bx
>>1) + 16*s
->mb_x
>= -16);
171 assert((by
>>1) + 16*s
->mb_y
>= -16);
172 assert((bx
>>1) + 16*s
->mb_x
<= s
->width
);
173 assert((by
>>1) + 16*s
->mb_y
<= s
->height
);
175 c
->hpel_put
[0][fxy
](c
->temp
, ref
[0] + (fx
>>1) + (fy
>>1)*stride
, stride
, 16);
176 c
->hpel_avg
[0][bxy
](c
->temp
, ref
[8] + (bx
>>1) + (by
>>1)*stride
, stride
, 16);
179 d
= cmp_func(s
, c
->temp
, src
[0], stride
, 16);
183 int uvdxy
; /* no, it might not be used uninitialized */
186 c
->qpel_put
[size
][dxy
](c
->temp
, ref
[0] + x
+ y
*stride
, stride
); //FIXME prototype (add h)
192 uvdxy
= (cx
&1) + 2*(cy
&1);
193 //FIXME x/y wrong, but mpeg4 qpel is sick anyway, we should drop as much of it as possible in favor for h264
196 c
->hpel_put
[size
][dxy
](c
->temp
, ref
[0] + x
+ y
*stride
, stride
, h
);
198 uvdxy
= dxy
| (x
&1) | (2*(y
&1));
200 d
= cmp_func(s
, c
->temp
, src
[0], stride
, h
);
202 d
= cmp_func(s
, src
[0], ref
[0] + x
+ y
*stride
, stride
, h
);
204 uvdxy
= (x
&1) + 2*(y
&1);
207 uint8_t * const uvtemp
= c
->temp
+ 16*stride
;
208 c
->hpel_put
[size
+1][uvdxy
](uvtemp
, ref
[1] + (x
>>1) + (y
>>1)*uvstride
, uvstride
, h
>>1);
209 c
->hpel_put
[size
+1][uvdxy
](uvtemp
+8, ref
[2] + (x
>>1) + (y
>>1)*uvstride
, uvstride
, h
>>1);
210 d
+= chroma_cmp_func(s
, uvtemp
, src
[1], uvstride
, h
>>1);
211 d
+= chroma_cmp_func(s
, uvtemp
+8, src
[2], uvstride
, h
>>1);
216 const int index
= (((y
)<<ME_MAP_SHIFT
) + (x
))&(ME_MAP_SIZE
-1);
220 d
+= (c
->mv_penalty
[hx
- c
->pred_x
] + c
->mv_penalty
[hy
- c
->pred_y
])*c
->penalty_factor
;
225 #include "motion_est_template.c"
227 static int zero_cmp(void *s
, uint8_t *a
, uint8_t *b
, int stride
, int h
){
231 static void zero_hpel(uint8_t *a
, const uint8_t *b
, int stride
, int h
){
234 int ff_init_me(MpegEncContext
*s
){
235 MotionEstContext
* const c
= &s
->me
;
236 int cache_size
= FFMIN(ME_MAP_SIZE
>>ME_MAP_SHIFT
, 1<<ME_MAP_SHIFT
);
237 int dia_size
= FFMAX(FFABS(s
->avctx
->dia_size
)&255, FFABS(s
->avctx
->pre_dia_size
)&255);
239 if(FFMIN(s
->avctx
->dia_size
, s
->avctx
->pre_dia_size
) < -ME_MAP_SIZE
){
240 av_log(s
->avctx
, AV_LOG_ERROR
, "ME_MAP size is too small for SAB diamond\n");
243 //special case of snow is needed because snow uses its own iterative ME code
244 if(s
->me_method
!=ME_ZERO
&& s
->me_method
!=ME_EPZS
&& s
->me_method
!=ME_X1
&& s
->avctx
->codec_id
!= CODEC_ID_SNOW
){
245 av_log(s
->avctx
, AV_LOG_ERROR
, "me_method is only allowed to be set to zero and epzs; for hex,umh,full and others see dia_size\n");
251 if(cache_size
< 2*dia_size
&& !c
->stride
){
252 av_log(s
->avctx
, AV_LOG_INFO
, "ME_MAP size may be a little small for the selected diamond size\n");
255 ff_set_cmp(&s
->dsp
, s
->dsp
.me_pre_cmp
, c
->avctx
->me_pre_cmp
);
256 ff_set_cmp(&s
->dsp
, s
->dsp
.me_cmp
, c
->avctx
->me_cmp
);
257 ff_set_cmp(&s
->dsp
, s
->dsp
.me_sub_cmp
, c
->avctx
->me_sub_cmp
);
258 ff_set_cmp(&s
->dsp
, s
->dsp
.mb_cmp
, c
->avctx
->mb_cmp
);
260 c
->flags
= get_flags(c
, 0, c
->avctx
->me_cmp
&FF_CMP_CHROMA
);
261 c
->sub_flags
= get_flags(c
, 0, c
->avctx
->me_sub_cmp
&FF_CMP_CHROMA
);
262 c
->mb_flags
= get_flags(c
, 0, c
->avctx
->mb_cmp
&FF_CMP_CHROMA
);
264 /*FIXME s->no_rounding b_type*/
265 if(s
->flags
&CODEC_FLAG_QPEL
){
266 c
->sub_motion_search
= qpel_motion_search
;
267 c
->qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
268 if(s
->no_rounding
) c
->qpel_put
= s
->dsp
.put_no_rnd_qpel_pixels_tab
;
269 else c
->qpel_put
= s
->dsp
.put_qpel_pixels_tab
;
271 if(c
->avctx
->me_sub_cmp
&FF_CMP_CHROMA
)
272 c
->sub_motion_search
= hpel_motion_search
;
273 else if( c
->avctx
->me_sub_cmp
== FF_CMP_SAD
274 && c
->avctx
-> me_cmp
== FF_CMP_SAD
275 && c
->avctx
-> mb_cmp
== FF_CMP_SAD
)
276 c
->sub_motion_search
= sad_hpel_motion_search
; // 2050 vs. 2450 cycles
278 c
->sub_motion_search
= hpel_motion_search
;
280 c
->hpel_avg
= s
->dsp
.avg_pixels_tab
;
281 if(s
->no_rounding
) c
->hpel_put
= s
->dsp
.put_no_rnd_pixels_tab
;
282 else c
->hpel_put
= s
->dsp
.put_pixels_tab
;
285 c
->stride
= s
->linesize
;
286 c
->uvstride
= s
->uvlinesize
;
288 c
->stride
= 16*s
->mb_width
+ 32;
289 c
->uvstride
= 8*s
->mb_width
+ 16;
292 /* 8x8 fullpel search would need a 4x4 chroma compare, which we do
293 * not have yet, and even if we had, the motion estimation code
294 * does not expect it. */
295 if(s
->codec_id
!= CODEC_ID_SNOW
){
296 if((c
->avctx
->me_cmp
&FF_CMP_CHROMA
)/* && !s->dsp.me_cmp[2]*/){
297 s
->dsp
.me_cmp
[2]= zero_cmp
;
299 if((c
->avctx
->me_sub_cmp
&FF_CMP_CHROMA
) && !s
->dsp
.me_sub_cmp
[2]){
300 s
->dsp
.me_sub_cmp
[2]= zero_cmp
;
302 c
->hpel_put
[2][0]= c
->hpel_put
[2][1]=
303 c
->hpel_put
[2][2]= c
->hpel_put
[2][3]= zero_hpel
;
306 if(s
->codec_id
== CODEC_ID_H261
){
307 c
->sub_motion_search
= no_sub_motion_search
;
310 c
->temp
= c
->scratchpad
;
316 static int pix_dev(uint8_t * pix
, int line_size
, int mean
)
321 for (i
= 0; i
< 16; i
++) {
322 for (j
= 0; j
< 16; j
+= 8) {
323 s
+= FFABS(pix
[0]-mean
);
324 s
+= FFABS(pix
[1]-mean
);
325 s
+= FFABS(pix
[2]-mean
);
326 s
+= FFABS(pix
[3]-mean
);
327 s
+= FFABS(pix
[4]-mean
);
328 s
+= FFABS(pix
[5]-mean
);
329 s
+= FFABS(pix
[6]-mean
);
330 s
+= FFABS(pix
[7]-mean
);
333 pix
+= line_size
- 16;
339 static inline void no_motion_search(MpegEncContext
* s
,
340 int *mx_ptr
, int *my_ptr
)
342 *mx_ptr
= 16 * s
->mb_x
;
343 *my_ptr
= 16 * s
->mb_y
;
346 #define Z_THRESHOLD 256
348 #define CHECK_SAD_HALF_MV(suffix, x, y) \
350 d= s->dsp.pix_abs[size][(x?1:0)+(y?2:0)](NULL, pix, ptr+((x)>>1), stride, h);\
351 d += (mv_penalty[pen_x + x] + mv_penalty[pen_y + y])*penalty_factor;\
352 COPY3_IF_LT(dminh, d, dx, x, dy, y)\
355 static inline int sad_hpel_motion_search(MpegEncContext
* s
,
356 int *mx_ptr
, int *my_ptr
, int dmin
,
357 int src_index
, int ref_index
,
360 MotionEstContext
* const c
= &s
->me
;
361 const int penalty_factor
= c
->sub_penalty_factor
;
364 int stride
= c
->stride
;
365 const int flags
= c
->sub_flags
;
378 pix
= c
->src
[src_index
][0];
382 ptr
= c
->ref
[ref_index
][0] + (my
* stride
) + mx
;
386 if (mx
> xmin
&& mx
< xmax
&&
387 my
> ymin
&& my
< ymax
) {
390 const int index
= (my
<<ME_MAP_SHIFT
) + mx
;
391 const int t
= score_map
[(index
-(1<<ME_MAP_SHIFT
))&(ME_MAP_SIZE
-1)];
392 const int l
= score_map
[(index
- 1 )&(ME_MAP_SIZE
-1)];
393 const int r
= score_map
[(index
+ 1 )&(ME_MAP_SIZE
-1)];
394 const int b
= score_map
[(index
+(1<<ME_MAP_SHIFT
))&(ME_MAP_SIZE
-1)];
404 CHECK_SAD_HALF_MV(y2
, 0, -1)
406 CHECK_SAD_HALF_MV(xy2
, -1, -1)
408 CHECK_SAD_HALF_MV(xy2
, +1, -1)
412 CHECK_SAD_HALF_MV(xy2
, -1, +1)
414 CHECK_SAD_HALF_MV(x2
, -1, 0)
416 CHECK_SAD_HALF_MV(xy2
, +1, -1)
418 CHECK_SAD_HALF_MV(xy2
, -1, -1)
422 CHECK_SAD_HALF_MV(xy2
, +1, +1)
424 CHECK_SAD_HALF_MV(x2
, +1, 0)
429 CHECK_SAD_HALF_MV(xy2
, -1, -1)
433 CHECK_SAD_HALF_MV(xy2
, +1, +1)
435 CHECK_SAD_HALF_MV(x2
, -1, 0)
436 CHECK_SAD_HALF_MV(xy2
, -1, +1)
439 CHECK_SAD_HALF_MV(xy2
, +1, -1)
443 CHECK_SAD_HALF_MV(xy2
, -1, +1)
445 CHECK_SAD_HALF_MV(x2
, +1, 0)
446 CHECK_SAD_HALF_MV(xy2
, +1, +1)
448 CHECK_SAD_HALF_MV(y2
, 0, +1)
463 static inline void set_p_mv_tables(MpegEncContext
* s
, int mx
, int my
, int mv4
)
465 const int xy
= s
->mb_x
+ s
->mb_y
*s
->mb_stride
;
467 s
->p_mv_table
[xy
][0] = mx
;
468 s
->p_mv_table
[xy
][1] = my
;
470 /* has already been set to the 4 MV if 4MV is done */
472 int mot_xy
= s
->block_index
[0];
474 s
->current_picture
.motion_val
[0][mot_xy
][0]= mx
;
475 s
->current_picture
.motion_val
[0][mot_xy
][1]= my
;
476 s
->current_picture
.motion_val
[0][mot_xy
+1][0]= mx
;
477 s
->current_picture
.motion_val
[0][mot_xy
+1][1]= my
;
479 mot_xy
+= s
->b8_stride
;
480 s
->current_picture
.motion_val
[0][mot_xy
][0]= mx
;
481 s
->current_picture
.motion_val
[0][mot_xy
][1]= my
;
482 s
->current_picture
.motion_val
[0][mot_xy
+1][0]= mx
;
483 s
->current_picture
.motion_val
[0][mot_xy
+1][1]= my
;
488 * get fullpel ME search limits.
490 static inline void get_limits(MpegEncContext
*s
, int x
, int y
)
492 MotionEstContext
* const c
= &s
->me
;
493 int range
= c
->avctx
->me_range
>> (1 + !!(c
->flags
&FLAG_QPEL
));
495 if(c->avctx->me_range) c->range= c->avctx->me_range >> 1;
498 if (s
->unrestricted_mv
) {
501 c
->xmax
= - x
+ s
->mb_width
*16;
502 c
->ymax
= - y
+ s
->mb_height
*16;
503 } else if (s
->out_format
== FMT_H261
){
504 // Search range of H261 is different from other codec standards
505 c
->xmin
= (x
> 15) ? - 15 : 0;
506 c
->ymin
= (y
> 15) ? - 15 : 0;
507 c
->xmax
= (x
< s
->mb_width
* 16 - 16) ? 15 : 0;
508 c
->ymax
= (y
< s
->mb_height
* 16 - 16) ? 15 : 0;
512 c
->xmax
= - x
+ s
->mb_width
*16 - 16;
513 c
->ymax
= - y
+ s
->mb_height
*16 - 16;
516 c
->xmin
= FFMAX(c
->xmin
,-range
);
517 c
->xmax
= FFMIN(c
->xmax
, range
);
518 c
->ymin
= FFMAX(c
->ymin
,-range
);
519 c
->ymax
= FFMIN(c
->ymax
, range
);
523 static inline void init_mv4_ref(MotionEstContext
*c
){
524 const int stride
= c
->stride
;
526 c
->ref
[1][0] = c
->ref
[0][0] + 8;
527 c
->ref
[2][0] = c
->ref
[0][0] + 8*stride
;
528 c
->ref
[3][0] = c
->ref
[2][0] + 8;
529 c
->src
[1][0] = c
->src
[0][0] + 8;
530 c
->src
[2][0] = c
->src
[0][0] + 8*stride
;
531 c
->src
[3][0] = c
->src
[2][0] + 8;
534 static inline int h263_mv4_search(MpegEncContext
*s
, int mx
, int my
, int shift
)
536 MotionEstContext
* const c
= &s
->me
;
541 int dmin_sum
=0, mx4_sum
=0, my4_sum
=0;
543 const int stride
= c
->stride
;
544 uint8_t *mv_penalty
= c
->current_mv_penalty
;
548 for(block
=0; block
<4; block
++){
550 int pred_x4
, pred_y4
;
552 static const int off
[4]= {2, 1, 1, -1};
553 const int mot_stride
= s
->b8_stride
;
554 const int mot_xy
= s
->block_index
[block
];
556 P_LEFT
[0] = s
->current_picture
.motion_val
[0][mot_xy
- 1][0];
557 P_LEFT
[1] = s
->current_picture
.motion_val
[0][mot_xy
- 1][1];
559 if(P_LEFT
[0] > (c
->xmax
<<shift
)) P_LEFT
[0] = (c
->xmax
<<shift
);
561 /* special case for first line */
562 if (s
->first_slice_line
&& block
<2) {
563 c
->pred_x
= pred_x4
= P_LEFT
[0];
564 c
->pred_y
= pred_y4
= P_LEFT
[1];
566 P_TOP
[0] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
][0];
567 P_TOP
[1] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
][1];
568 P_TOPRIGHT
[0] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
+ off
[block
]][0];
569 P_TOPRIGHT
[1] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
+ off
[block
]][1];
570 if(P_TOP
[1] > (c
->ymax
<<shift
)) P_TOP
[1] = (c
->ymax
<<shift
);
571 if(P_TOPRIGHT
[0] < (c
->xmin
<<shift
)) P_TOPRIGHT
[0]= (c
->xmin
<<shift
);
572 if(P_TOPRIGHT
[0] > (c
->xmax
<<shift
)) P_TOPRIGHT
[0]= (c
->xmax
<<shift
);
573 if(P_TOPRIGHT
[1] > (c
->ymax
<<shift
)) P_TOPRIGHT
[1]= (c
->ymax
<<shift
);
575 P_MEDIAN
[0]= mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
576 P_MEDIAN
[1]= mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
578 c
->pred_x
= pred_x4
= P_MEDIAN
[0];
579 c
->pred_y
= pred_y4
= P_MEDIAN
[1];
584 dmin4
= epzs_motion_search4(s
, &mx4
, &my4
, P
, block
, block
, s
->p_mv_table
, (1<<16)>>shift
);
586 dmin4
= c
->sub_motion_search(s
, &mx4
, &my4
, dmin4
, block
, block
, size
, h
);
588 if(s
->dsp
.me_sub_cmp
[0] != s
->dsp
.mb_cmp
[0]){
590 const int offset
= ((block
&1) + (block
>>1)*stride
)*8;
591 uint8_t *dest_y
= c
->scratchpad
+ offset
;
592 if(s
->quarter_sample
){
593 uint8_t *ref
= c
->ref
[block
][0] + (mx4
>>2) + (my4
>>2)*stride
;
594 dxy
= ((my4
& 3) << 2) | (mx4
& 3);
597 s
->dsp
.put_no_rnd_qpel_pixels_tab
[1][dxy
](dest_y
, ref
, stride
);
599 s
->dsp
.put_qpel_pixels_tab
[1][dxy
](dest_y
, ref
, stride
);
601 uint8_t *ref
= c
->ref
[block
][0] + (mx4
>>1) + (my4
>>1)*stride
;
602 dxy
= ((my4
& 1) << 1) | (mx4
& 1);
605 s
->dsp
.put_no_rnd_pixels_tab
[1][dxy
](dest_y
, ref
, stride
, h
);
607 s
->dsp
.put_pixels_tab
[1][dxy
](dest_y
, ref
, stride
, h
);
609 dmin_sum
+= (mv_penalty
[mx4
-pred_x4
] + mv_penalty
[my4
-pred_y4
])*c
->mb_penalty_factor
;
613 if(s
->quarter_sample
){
621 s
->current_picture
.motion_val
[0][ s
->block_index
[block
] ][0]= mx4
;
622 s
->current_picture
.motion_val
[0][ s
->block_index
[block
] ][1]= my4
;
624 if(mx4
!= mx
|| my4
!= my
) same
=0;
630 if(s
->dsp
.me_sub_cmp
[0] != s
->dsp
.mb_cmp
[0]){
631 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);
634 if(c
->avctx
->mb_cmp
&FF_CMP_CHROMA
){
639 mx
= ff_h263_round_chroma(mx4_sum
);
640 my
= ff_h263_round_chroma(my4_sum
);
641 dxy
= ((my
& 1) << 1) | (mx
& 1);
643 offset
= (s
->mb_x
*8 + (mx
>>1)) + (s
->mb_y
*8 + (my
>>1))*s
->uvlinesize
;
646 s
->dsp
.put_no_rnd_pixels_tab
[1][dxy
](c
->scratchpad
, s
->last_picture
.data
[1] + offset
, s
->uvlinesize
, 8);
647 s
->dsp
.put_no_rnd_pixels_tab
[1][dxy
](c
->scratchpad
+8 , s
->last_picture
.data
[2] + offset
, s
->uvlinesize
, 8);
649 s
->dsp
.put_pixels_tab
[1][dxy
](c
->scratchpad
, s
->last_picture
.data
[1] + offset
, s
->uvlinesize
, 8);
650 s
->dsp
.put_pixels_tab
[1][dxy
](c
->scratchpad
+8 , s
->last_picture
.data
[2] + offset
, s
->uvlinesize
, 8);
653 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);
654 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);
660 switch(c
->avctx
->mb_cmp
&0xFF){
662 return dmin_sum+ 32*s->qscale*s->qscale;*/
666 return dmin_sum
+ 11*c
->mb_penalty_factor
;
670 static inline void init_interlaced_ref(MpegEncContext
*s
, int ref_index
){
671 MotionEstContext
* const c
= &s
->me
;
673 c
->ref
[1+ref_index
][0] = c
->ref
[0+ref_index
][0] + s
->linesize
;
674 c
->src
[1][0] = c
->src
[0][0] + s
->linesize
;
675 if(c
->flags
& FLAG_CHROMA
){
676 c
->ref
[1+ref_index
][1] = c
->ref
[0+ref_index
][1] + s
->uvlinesize
;
677 c
->ref
[1+ref_index
][2] = c
->ref
[0+ref_index
][2] + s
->uvlinesize
;
678 c
->src
[1][1] = c
->src
[0][1] + s
->uvlinesize
;
679 c
->src
[1][2] = c
->src
[0][2] + s
->uvlinesize
;
683 static int interlaced_search(MpegEncContext
*s
, int ref_index
,
684 int16_t (*mv_tables
[2][2])[2], uint8_t *field_select_tables
[2], int mx
, int my
, int user_field_select
)
686 MotionEstContext
* const c
= &s
->me
;
691 uint8_t * const mv_penalty
= c
->current_mv_penalty
;
693 const int stride
= 2*s
->linesize
;
695 const int mot_stride
= s
->mb_stride
;
696 const int xy
= s
->mb_x
+ s
->mb_y
*mot_stride
;
702 init_interlaced_ref(s
, ref_index
);
704 for(block
=0; block
<2; block
++){
706 int best_dmin
= INT_MAX
;
709 for(field_select
=0; field_select
<2; field_select
++){
710 int dmin
, mx_i
, my_i
;
711 int16_t (*mv_table
)[2]= mv_tables
[block
][field_select
];
713 if(user_field_select
){
714 assert(field_select
==0 || field_select
==1);
715 assert(field_select_tables
[block
][xy
]==0 || field_select_tables
[block
][xy
]==1);
716 if(field_select_tables
[block
][xy
] != field_select
)
720 P_LEFT
[0] = mv_table
[xy
- 1][0];
721 P_LEFT
[1] = mv_table
[xy
- 1][1];
722 if(P_LEFT
[0] > (c
->xmax
<<1)) P_LEFT
[0] = (c
->xmax
<<1);
724 c
->pred_x
= P_LEFT
[0];
725 c
->pred_y
= P_LEFT
[1];
727 if(!s
->first_slice_line
){
728 P_TOP
[0] = mv_table
[xy
- mot_stride
][0];
729 P_TOP
[1] = mv_table
[xy
- mot_stride
][1];
730 P_TOPRIGHT
[0] = mv_table
[xy
- mot_stride
+ 1][0];
731 P_TOPRIGHT
[1] = mv_table
[xy
- mot_stride
+ 1][1];
732 if(P_TOP
[1] > (c
->ymax
<<1)) P_TOP
[1] = (c
->ymax
<<1);
733 if(P_TOPRIGHT
[0] < (c
->xmin
<<1)) P_TOPRIGHT
[0]= (c
->xmin
<<1);
734 if(P_TOPRIGHT
[0] > (c
->xmax
<<1)) P_TOPRIGHT
[0]= (c
->xmax
<<1);
735 if(P_TOPRIGHT
[1] > (c
->ymax
<<1)) P_TOPRIGHT
[1]= (c
->ymax
<<1);
737 P_MEDIAN
[0]= mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
738 P_MEDIAN
[1]= mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
740 P_MV1
[0]= mx
; //FIXME not correct if block != field_select
743 dmin
= epzs_motion_search2(s
, &mx_i
, &my_i
, P
, block
, field_select
+ref_index
, mv_table
, (1<<16)>>1);
745 dmin
= c
->sub_motion_search(s
, &mx_i
, &my_i
, dmin
, block
, field_select
+ref_index
, size
, h
);
747 mv_table
[xy
][0]= mx_i
;
748 mv_table
[xy
][1]= my_i
;
750 if(s
->dsp
.me_sub_cmp
[0] != s
->dsp
.mb_cmp
[0]){
754 uint8_t *ref
= c
->ref
[field_select
+ref_index
][0] + (mx_i
>>1) + (my_i
>>1)*stride
;
755 dxy
= ((my_i
& 1) << 1) | (mx_i
& 1);
758 s
->dsp
.put_no_rnd_pixels_tab
[size
][dxy
](c
->scratchpad
, ref
, stride
, h
);
760 s
->dsp
.put_pixels_tab
[size
][dxy
](c
->scratchpad
, ref
, stride
, h
);
762 dmin
= s
->dsp
.mb_cmp
[size
](s
, c
->src
[block
][0], c
->scratchpad
, stride
, h
);
763 dmin
+= (mv_penalty
[mx_i
-c
->pred_x
] + mv_penalty
[my_i
-c
->pred_y
] + 1)*c
->mb_penalty_factor
;
765 dmin
+= c
->mb_penalty_factor
; //field_select bits
767 dmin
+= field_select
!= block
; //slightly prefer same field
769 if(dmin
< best_dmin
){
771 best_field
= field_select
;
775 int16_t (*mv_table
)[2]= mv_tables
[block
][best_field
];
777 if(mv_table
[xy
][0] != mx
) same
=0; //FIXME check if these checks work and are any good at all
778 if(mv_table
[xy
][1]&1) same
=0;
779 if(mv_table
[xy
][1]*2 != my
) same
=0;
780 if(best_field
!= block
) same
=0;
783 field_select_tables
[block
][xy
]= best_field
;
784 dmin_sum
+= best_dmin
;
795 switch(c
->avctx
->mb_cmp
&0xFF){
797 return dmin_sum+ 32*s->qscale*s->qscale;*/
801 return dmin_sum
+ 11*c
->mb_penalty_factor
;
805 static void clip_input_mv(MpegEncContext
* s
, int16_t *mv
, int interlaced
){
806 int ymax
= s
->me
.ymax
>>interlaced
;
807 int ymin
= s
->me
.ymin
>>interlaced
;
809 if(mv
[0] < s
->me
.xmin
) mv
[0] = s
->me
.xmin
;
810 if(mv
[0] > s
->me
.xmax
) mv
[0] = s
->me
.xmax
;
811 if(mv
[1] < ymin
) mv
[1] = ymin
;
812 if(mv
[1] > ymax
) mv
[1] = ymax
;
815 static inline int check_input_motion(MpegEncContext
* s
, int mb_x
, int mb_y
, int p_type
){
816 MotionEstContext
* const c
= &s
->me
;
817 Picture
*p
= s
->current_picture_ptr
;
818 int mb_xy
= mb_x
+ mb_y
*s
->mb_stride
;
819 int xy
= 2*mb_x
+ 2*mb_y
*s
->b8_stride
;
820 int mb_type
= s
->current_picture
.mb_type
[mb_xy
];
822 int shift
= (flags
&FLAG_QPEL
) + 1;
823 int mask
= (1<<shift
)-1;
826 me_cmp_func cmpf
= s
->dsp
.sse
[0];
827 me_cmp_func chroma_cmpf
= s
->dsp
.sse
[1];
829 if(p_type
&& USES_LIST(mb_type
, 1)){
830 av_log(c
->avctx
, AV_LOG_ERROR
, "backward motion vector in P frame\n");
833 assert(IS_INTRA(mb_type
) || USES_LIST(mb_type
,0) || USES_LIST(mb_type
,1));
836 int xy
= s
->block_index
[i
];
837 clip_input_mv(s
, p
->motion_val
[0][xy
], !!IS_INTERLACED(mb_type
));
838 clip_input_mv(s
, p
->motion_val
[1][xy
], !!IS_INTERLACED(mb_type
));
841 if(IS_INTERLACED(mb_type
)){
842 int xy2
= xy
+ s
->b8_stride
;
843 s
->mb_type
[mb_xy
]=CANDIDATE_MB_TYPE_INTRA
;
847 if(!(s
->flags
& CODEC_FLAG_INTERLACED_ME
)){
848 av_log(c
->avctx
, AV_LOG_ERROR
, "Interlaced macroblock selected but interlaced motion estimation disabled\n");
852 if(USES_LIST(mb_type
, 0)){
853 int field_select0
= p
->ref_index
[0][xy
];
854 int field_select1
= p
->ref_index
[0][xy2
];
855 assert(field_select0
==0 ||field_select0
==1);
856 assert(field_select1
==0 ||field_select1
==1);
857 init_interlaced_ref(s
, 0);
860 s
->p_field_select_table
[0][mb_xy
]= field_select0
;
861 s
->p_field_select_table
[1][mb_xy
]= field_select1
;
862 *(uint32_t*)s
->p_field_mv_table
[0][field_select0
][mb_xy
]= *(uint32_t*)p
->motion_val
[0][xy
];
863 *(uint32_t*)s
->p_field_mv_table
[1][field_select1
][mb_xy
]= *(uint32_t*)p
->motion_val
[0][xy2
];
864 s
->mb_type
[mb_xy
]=CANDIDATE_MB_TYPE_INTER_I
;
866 s
->b_field_select_table
[0][0][mb_xy
]= field_select0
;
867 s
->b_field_select_table
[0][1][mb_xy
]= field_select1
;
868 *(uint32_t*)s
->b_field_mv_table
[0][0][field_select0
][mb_xy
]= *(uint32_t*)p
->motion_val
[0][xy
];
869 *(uint32_t*)s
->b_field_mv_table
[0][1][field_select1
][mb_xy
]= *(uint32_t*)p
->motion_val
[0][xy2
];
870 s
->mb_type
[mb_xy
]= CANDIDATE_MB_TYPE_FORWARD_I
;
873 x
= p
->motion_val
[0][xy
][0];
874 y
= p
->motion_val
[0][xy
][1];
875 d
= cmp(s
, x
>>shift
, y
>>shift
, x
&mask
, y
&mask
, 0, 8, field_select0
, 0, cmpf
, chroma_cmpf
, flags
);
876 x
= p
->motion_val
[0][xy2
][0];
877 y
= p
->motion_val
[0][xy2
][1];
878 d
+= cmp(s
, x
>>shift
, y
>>shift
, x
&mask
, y
&mask
, 0, 8, field_select1
, 1, cmpf
, chroma_cmpf
, flags
);
880 if(USES_LIST(mb_type
, 1)){
881 int field_select0
= p
->ref_index
[1][xy
];
882 int field_select1
= p
->ref_index
[1][xy2
];
883 assert(field_select0
==0 ||field_select0
==1);
884 assert(field_select1
==0 ||field_select1
==1);
885 init_interlaced_ref(s
, 2);
887 s
->b_field_select_table
[1][0][mb_xy
]= field_select0
;
888 s
->b_field_select_table
[1][1][mb_xy
]= field_select1
;
889 *(uint32_t*)s
->b_field_mv_table
[1][0][field_select0
][mb_xy
]= *(uint32_t*)p
->motion_val
[1][xy
];
890 *(uint32_t*)s
->b_field_mv_table
[1][1][field_select1
][mb_xy
]= *(uint32_t*)p
->motion_val
[1][xy2
];
891 if(USES_LIST(mb_type
, 0)){
892 s
->mb_type
[mb_xy
]= CANDIDATE_MB_TYPE_BIDIR_I
;
894 s
->mb_type
[mb_xy
]= CANDIDATE_MB_TYPE_BACKWARD_I
;
897 x
= p
->motion_val
[1][xy
][0];
898 y
= p
->motion_val
[1][xy
][1];
899 d
= cmp(s
, x
>>shift
, y
>>shift
, x
&mask
, y
&mask
, 0, 8, field_select0
+2, 0, cmpf
, chroma_cmpf
, flags
);
900 x
= p
->motion_val
[1][xy2
][0];
901 y
= p
->motion_val
[1][xy2
][1];
902 d
+= cmp(s
, x
>>shift
, y
>>shift
, x
&mask
, y
&mask
, 0, 8, field_select1
+2, 1, cmpf
, chroma_cmpf
, flags
);
907 }else if(IS_8X8(mb_type
)){
908 if(!(s
->flags
& CODEC_FLAG_4MV
)){
909 av_log(c
->avctx
, AV_LOG_ERROR
, "4MV macroblock selected but 4MV encoding disabled\n");
913 chroma_cmpf
= s
->dsp
.sse
[1];
916 xy
= s
->block_index
[i
];
917 x
= p
->motion_val
[0][xy
][0];
918 y
= p
->motion_val
[0][xy
][1];
919 d
+= cmp(s
, x
>>shift
, y
>>shift
, x
&mask
, y
&mask
, 1, 8, i
, i
, cmpf
, chroma_cmpf
, flags
);
921 s
->mb_type
[mb_xy
]=CANDIDATE_MB_TYPE_INTER4V
;
923 if(USES_LIST(mb_type
, 0)){
925 *(uint32_t*)s
->p_mv_table
[mb_xy
]= *(uint32_t*)p
->motion_val
[0][xy
];
926 s
->mb_type
[mb_xy
]=CANDIDATE_MB_TYPE_INTER
;
927 }else if(USES_LIST(mb_type
, 1)){
928 *(uint32_t*)s
->b_bidir_forw_mv_table
[mb_xy
]= *(uint32_t*)p
->motion_val
[0][xy
];
929 *(uint32_t*)s
->b_bidir_back_mv_table
[mb_xy
]= *(uint32_t*)p
->motion_val
[1][xy
];
930 s
->mb_type
[mb_xy
]=CANDIDATE_MB_TYPE_BIDIR
;
932 *(uint32_t*)s
->b_forw_mv_table
[mb_xy
]= *(uint32_t*)p
->motion_val
[0][xy
];
933 s
->mb_type
[mb_xy
]=CANDIDATE_MB_TYPE_FORWARD
;
935 x
= p
->motion_val
[0][xy
][0];
936 y
= p
->motion_val
[0][xy
][1];
937 d
= cmp(s
, x
>>shift
, y
>>shift
, x
&mask
, y
&mask
, 0, 16, 0, 0, cmpf
, chroma_cmpf
, flags
);
938 }else if(USES_LIST(mb_type
, 1)){
939 *(uint32_t*)s
->b_back_mv_table
[mb_xy
]= *(uint32_t*)p
->motion_val
[1][xy
];
940 s
->mb_type
[mb_xy
]=CANDIDATE_MB_TYPE_BACKWARD
;
942 x
= p
->motion_val
[1][xy
][0];
943 y
= p
->motion_val
[1][xy
][1];
944 d
= cmp(s
, x
>>shift
, y
>>shift
, x
&mask
, y
&mask
, 0, 16, 2, 0, cmpf
, chroma_cmpf
, flags
);
946 s
->mb_type
[mb_xy
]=CANDIDATE_MB_TYPE_INTRA
;
951 void ff_estimate_p_frame_motion(MpegEncContext
* s
,
954 MotionEstContext
* const c
= &s
->me
;
956 int sum
, mx
, my
, dmin
;
957 int varc
; ///< the variance of the block (sum of squared (p[y][x]-average))
958 int vard
; ///< sum of squared differences with the estimated motion vector
960 const int shift
= 1+s
->quarter_sample
;
962 Picture
* const pic
= &s
->current_picture
;
964 init_ref(c
, s
->new_picture
.data
, s
->last_picture
.data
, NULL
, 16*mb_x
, 16*mb_y
, 0);
966 assert(s
->quarter_sample
==0 || s
->quarter_sample
==1);
967 assert(s
->linesize
== c
->stride
);
968 assert(s
->uvlinesize
== c
->uvstride
);
970 c
->penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->me_cmp
);
971 c
->sub_penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->me_sub_cmp
);
972 c
->mb_penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->mb_cmp
);
973 c
->current_mv_penalty
= c
->mv_penalty
[s
->f_code
] + MAX_MV
;
975 get_limits(s
, 16*mb_x
, 16*mb_y
);
978 /* intra / predictive decision */
980 sum
= s
->dsp
.pix_sum(pix
, s
->linesize
);
981 varc
= s
->dsp
.pix_norm1(pix
, s
->linesize
) - (((unsigned)(sum
*sum
))>>8) + 500;
983 pic
->mb_mean
[s
->mb_stride
* mb_y
+ mb_x
] = (sum
+128)>>8;
984 pic
->mb_var
[s
->mb_stride
* mb_y
+ mb_x
] = (varc
+128)>>8;
985 c
->mb_var_sum_temp
+= (varc
+128)>>8;
987 if(c
->avctx
->me_threshold
){
988 vard
= check_input_motion(s
, mb_x
, mb_y
, 1);
990 if((vard
+128)>>8 < c
->avctx
->me_threshold
){
991 int p_score
= FFMIN(vard
, varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*100);
992 int i_score
= varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*20;
993 pic
->mc_mb_var
[s
->mb_stride
* mb_y
+ mb_x
] = (vard
+128)>>8;
994 c
->mc_mb_var_sum_temp
+= (vard
+128)>>8;
995 c
->scene_change_score
+= ff_sqrt(p_score
) - ff_sqrt(i_score
);
998 if((vard
+128)>>8 < c
->avctx
->mb_threshold
)
999 mb_type
= s
->mb_type
[mb_x
+ mb_y
*s
->mb_stride
];
1002 switch(s
->me_method
) {
1005 no_motion_search(s
, &mx
, &my
);
1013 const int mot_stride
= s
->b8_stride
;
1014 const int mot_xy
= s
->block_index
[0];
1016 P_LEFT
[0] = s
->current_picture
.motion_val
[0][mot_xy
- 1][0];
1017 P_LEFT
[1] = s
->current_picture
.motion_val
[0][mot_xy
- 1][1];
1019 if(P_LEFT
[0] > (c
->xmax
<<shift
)) P_LEFT
[0] = (c
->xmax
<<shift
);
1021 if(!s
->first_slice_line
) {
1022 P_TOP
[0] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
][0];
1023 P_TOP
[1] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
][1];
1024 P_TOPRIGHT
[0] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
+ 2][0];
1025 P_TOPRIGHT
[1] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
+ 2][1];
1026 if(P_TOP
[1] > (c
->ymax
<<shift
)) P_TOP
[1] = (c
->ymax
<<shift
);
1027 if(P_TOPRIGHT
[0] < (c
->xmin
<<shift
)) P_TOPRIGHT
[0]= (c
->xmin
<<shift
);
1028 if(P_TOPRIGHT
[1] > (c
->ymax
<<shift
)) P_TOPRIGHT
[1]= (c
->ymax
<<shift
);
1030 P_MEDIAN
[0]= mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
1031 P_MEDIAN
[1]= mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
1033 if(s
->out_format
== FMT_H263
){
1034 c
->pred_x
= P_MEDIAN
[0];
1035 c
->pred_y
= P_MEDIAN
[1];
1036 }else { /* mpeg1 at least */
1037 c
->pred_x
= P_LEFT
[0];
1038 c
->pred_y
= P_LEFT
[1];
1041 c
->pred_x
= P_LEFT
[0];
1042 c
->pred_y
= P_LEFT
[1];
1046 dmin
= ff_epzs_motion_search(s
, &mx
, &my
, P
, 0, 0, s
->p_mv_table
, (1<<16)>>shift
, 0, 16);
1051 /* At this point (mx,my) are full-pell and the relative displacement */
1052 ppix
= c
->ref
[0][0] + (my
* s
->linesize
) + mx
;
1054 vard
= s
->dsp
.sse
[0](NULL
, pix
, ppix
, s
->linesize
, 16);
1056 pic
->mc_mb_var
[s
->mb_stride
* mb_y
+ mb_x
] = (vard
+128)>>8;
1057 // pic->mb_cmp_score[s->mb_stride * mb_y + mb_x] = dmin;
1058 c
->mc_mb_var_sum_temp
+= (vard
+128)>>8;
1061 printf("varc=%4d avg_var=%4d (sum=%4d) vard=%4d mx=%2d my=%2d\n",
1062 varc
, s
->avg_mb_var
, sum
, vard
, mx
- xx
, my
- yy
);
1065 int p_score
= FFMIN(vard
, varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*100);
1066 int i_score
= varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*20;
1067 c
->scene_change_score
+= ff_sqrt(p_score
) - ff_sqrt(i_score
);
1069 if(mb_type
== CANDIDATE_MB_TYPE_INTER
){
1070 c
->sub_motion_search(s
, &mx
, &my
, dmin
, 0, 0, 0, 16);
1071 set_p_mv_tables(s
, mx
, my
, 1);
1076 if(mb_type
== CANDIDATE_MB_TYPE_INTER4V
){
1077 h263_mv4_search(s
, mx
, my
, shift
);
1079 set_p_mv_tables(s
, mx
, my
, 0);
1081 if(mb_type
== CANDIDATE_MB_TYPE_INTER_I
){
1082 interlaced_search(s
, 0, s
->p_field_mv_table
, s
->p_field_select_table
, mx
, my
, 1);
1084 }else if(c
->avctx
->mb_decision
> FF_MB_DECISION_SIMPLE
){
1085 int p_score
= FFMIN(vard
, varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*100);
1086 int i_score
= varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*20;
1087 c
->scene_change_score
+= ff_sqrt(p_score
) - ff_sqrt(i_score
);
1089 if (vard
*2 + 200*256 > varc
)
1090 mb_type
|= CANDIDATE_MB_TYPE_INTRA
;
1091 if (varc
*2 + 200*256 > vard
|| s
->qscale
> 24){
1092 // if (varc*2 + 200*256 + 50*(s->lambda2>>FF_LAMBDA_SHIFT) > vard){
1093 mb_type
|= CANDIDATE_MB_TYPE_INTER
;
1094 c
->sub_motion_search(s
, &mx
, &my
, dmin
, 0, 0, 0, 16);
1095 if(s
->flags
&CODEC_FLAG_MV0
)
1097 mb_type
|= CANDIDATE_MB_TYPE_SKIPPED
; //FIXME check difference
1102 if((s
->flags
&CODEC_FLAG_4MV
)
1103 && !c
->skip
&& varc
>50<<8 && vard
>10<<8){
1104 if(h263_mv4_search(s
, mx
, my
, shift
) < INT_MAX
)
1105 mb_type
|=CANDIDATE_MB_TYPE_INTER4V
;
1107 set_p_mv_tables(s
, mx
, my
, 0);
1109 set_p_mv_tables(s
, mx
, my
, 1);
1110 if((s
->flags
&CODEC_FLAG_INTERLACED_ME
)
1111 && !c
->skip
){ //FIXME varc/d checks
1112 if(interlaced_search(s
, 0, s
->p_field_mv_table
, s
->p_field_select_table
, mx
, my
, 0) < INT_MAX
)
1113 mb_type
|= CANDIDATE_MB_TYPE_INTER_I
;
1117 mb_type
= CANDIDATE_MB_TYPE_INTER
;
1119 dmin
= c
->sub_motion_search(s
, &mx
, &my
, dmin
, 0, 0, 0, 16);
1120 if(c
->avctx
->me_sub_cmp
!= c
->avctx
->mb_cmp
&& !c
->skip
)
1121 dmin
= ff_get_mb_score(s
, mx
, my
, 0, 0, 0, 16, 1);
1123 if((s
->flags
&CODEC_FLAG_4MV
)
1124 && !c
->skip
&& varc
>50<<8 && vard
>10<<8){
1125 int dmin4
= h263_mv4_search(s
, mx
, my
, shift
);
1127 mb_type
= CANDIDATE_MB_TYPE_INTER4V
;
1131 if((s
->flags
&CODEC_FLAG_INTERLACED_ME
)
1132 && !c
->skip
){ //FIXME varc/d checks
1133 int dmin_i
= interlaced_search(s
, 0, s
->p_field_mv_table
, s
->p_field_select_table
, mx
, my
, 0);
1135 mb_type
= CANDIDATE_MB_TYPE_INTER_I
;
1140 // pic->mb_cmp_score[s->mb_stride * mb_y + mb_x] = dmin;
1141 set_p_mv_tables(s
, mx
, my
, mb_type
!=CANDIDATE_MB_TYPE_INTER4V
);
1143 /* get intra luma score */
1144 if((c
->avctx
->mb_cmp
&0xFF)==FF_CMP_SSE
){
1145 intra_score
= varc
- 500;
1147 int mean
= (sum
+128)>>8;
1150 for(i
=0; i
<16; i
++){
1151 *(uint32_t*)(&c
->scratchpad
[i
*s
->linesize
+ 0]) = mean
;
1152 *(uint32_t*)(&c
->scratchpad
[i
*s
->linesize
+ 4]) = mean
;
1153 *(uint32_t*)(&c
->scratchpad
[i
*s
->linesize
+ 8]) = mean
;
1154 *(uint32_t*)(&c
->scratchpad
[i
*s
->linesize
+12]) = mean
;
1157 intra_score
= s
->dsp
.mb_cmp
[0](s
, c
->scratchpad
, pix
, s
->linesize
, 16);
1160 /* get chroma score */
1161 if(c
->avctx
->mb_cmp
&FF_CMP_CHROMA
){
1166 if(s
->out_format
== FMT_H263
){
1167 mean
= (s
->dc_val
[i
][mb_x
+ mb_y
*s
->b8_stride
] + 4)>>3; //FIXME not exact but simple ;)
1169 mean
= (s
->last_dc
[i
] + 4)>>3;
1171 dest_c
= s
->new_picture
.data
[i
] + (mb_y
* 8 * (s
->uvlinesize
)) + mb_x
* 8;
1175 *(uint32_t*)(&c
->scratchpad
[i
*s
->uvlinesize
+ 0]) = mean
;
1176 *(uint32_t*)(&c
->scratchpad
[i
*s
->uvlinesize
+ 4]) = mean
;
1179 intra_score
+= s
->dsp
.mb_cmp
[1](s
, c
->scratchpad
, dest_c
, s
->uvlinesize
);
1183 intra_score
+= c
->mb_penalty_factor
*16;
1185 if(intra_score
< dmin
){
1186 mb_type
= CANDIDATE_MB_TYPE_INTRA
;
1187 s
->current_picture
.mb_type
[mb_y
*s
->mb_stride
+ mb_x
]= CANDIDATE_MB_TYPE_INTRA
; //FIXME cleanup
1189 s
->current_picture
.mb_type
[mb_y
*s
->mb_stride
+ mb_x
]= 0;
1192 int p_score
= FFMIN(vard
, varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*100);
1193 int i_score
= varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*20;
1194 c
->scene_change_score
+= ff_sqrt(p_score
) - ff_sqrt(i_score
);
1198 s
->mb_type
[mb_y
*s
->mb_stride
+ mb_x
]= mb_type
;
1201 int ff_pre_estimate_p_frame_motion(MpegEncContext
* s
,
1204 MotionEstContext
* const c
= &s
->me
;
1207 const int shift
= 1+s
->quarter_sample
;
1208 const int xy
= mb_x
+ mb_y
*s
->mb_stride
;
1209 init_ref(c
, s
->new_picture
.data
, s
->last_picture
.data
, NULL
, 16*mb_x
, 16*mb_y
, 0);
1211 assert(s
->quarter_sample
==0 || s
->quarter_sample
==1);
1213 c
->pre_penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->me_pre_cmp
);
1214 c
->current_mv_penalty
= c
->mv_penalty
[s
->f_code
] + MAX_MV
;
1216 get_limits(s
, 16*mb_x
, 16*mb_y
);
1219 P_LEFT
[0] = s
->p_mv_table
[xy
+ 1][0];
1220 P_LEFT
[1] = s
->p_mv_table
[xy
+ 1][1];
1222 if(P_LEFT
[0] < (c
->xmin
<<shift
)) P_LEFT
[0] = (c
->xmin
<<shift
);
1224 /* special case for first line */
1225 if (s
->first_slice_line
) {
1226 c
->pred_x
= P_LEFT
[0];
1227 c
->pred_y
= P_LEFT
[1];
1228 P_TOP
[0]= P_TOPRIGHT
[0]= P_MEDIAN
[0]=
1229 P_TOP
[1]= P_TOPRIGHT
[1]= P_MEDIAN
[1]= 0; //FIXME
1231 P_TOP
[0] = s
->p_mv_table
[xy
+ s
->mb_stride
][0];
1232 P_TOP
[1] = s
->p_mv_table
[xy
+ s
->mb_stride
][1];
1233 P_TOPRIGHT
[0] = s
->p_mv_table
[xy
+ s
->mb_stride
- 1][0];
1234 P_TOPRIGHT
[1] = s
->p_mv_table
[xy
+ s
->mb_stride
- 1][1];
1235 if(P_TOP
[1] < (c
->ymin
<<shift
)) P_TOP
[1] = (c
->ymin
<<shift
);
1236 if(P_TOPRIGHT
[0] > (c
->xmax
<<shift
)) P_TOPRIGHT
[0]= (c
->xmax
<<shift
);
1237 if(P_TOPRIGHT
[1] < (c
->ymin
<<shift
)) P_TOPRIGHT
[1]= (c
->ymin
<<shift
);
1239 P_MEDIAN
[0]= mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
1240 P_MEDIAN
[1]= mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
1242 c
->pred_x
= P_MEDIAN
[0];
1243 c
->pred_y
= P_MEDIAN
[1];
1246 dmin
= ff_epzs_motion_search(s
, &mx
, &my
, P
, 0, 0, s
->p_mv_table
, (1<<16)>>shift
, 0, 16);
1248 s
->p_mv_table
[xy
][0] = mx
<<shift
;
1249 s
->p_mv_table
[xy
][1] = my
<<shift
;
1254 static int ff_estimate_motion_b(MpegEncContext
* s
,
1255 int mb_x
, int mb_y
, int16_t (*mv_table
)[2], int ref_index
, int f_code
)
1257 MotionEstContext
* const c
= &s
->me
;
1260 const int shift
= 1+s
->quarter_sample
;
1261 const int mot_stride
= s
->mb_stride
;
1262 const int mot_xy
= mb_y
*mot_stride
+ mb_x
;
1263 uint8_t * const mv_penalty
= c
->mv_penalty
[f_code
] + MAX_MV
;
1266 c
->penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->me_cmp
);
1267 c
->sub_penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->me_sub_cmp
);
1268 c
->mb_penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->mb_cmp
);
1269 c
->current_mv_penalty
= mv_penalty
;
1271 get_limits(s
, 16*mb_x
, 16*mb_y
);
1273 switch(s
->me_method
) {
1276 no_motion_search(s
, &mx
, &my
);
1284 P_LEFT
[0] = mv_table
[mot_xy
- 1][0];
1285 P_LEFT
[1] = mv_table
[mot_xy
- 1][1];
1287 if(P_LEFT
[0] > (c
->xmax
<<shift
)) P_LEFT
[0] = (c
->xmax
<<shift
);
1289 /* special case for first line */
1290 if (!s
->first_slice_line
) {
1291 P_TOP
[0] = mv_table
[mot_xy
- mot_stride
][0];
1292 P_TOP
[1] = mv_table
[mot_xy
- mot_stride
][1];
1293 P_TOPRIGHT
[0] = mv_table
[mot_xy
- mot_stride
+ 1 ][0];
1294 P_TOPRIGHT
[1] = mv_table
[mot_xy
- mot_stride
+ 1 ][1];
1295 if(P_TOP
[1] > (c
->ymax
<<shift
)) P_TOP
[1]= (c
->ymax
<<shift
);
1296 if(P_TOPRIGHT
[0] < (c
->xmin
<<shift
)) P_TOPRIGHT
[0]= (c
->xmin
<<shift
);
1297 if(P_TOPRIGHT
[1] > (c
->ymax
<<shift
)) P_TOPRIGHT
[1]= (c
->ymax
<<shift
);
1299 P_MEDIAN
[0]= mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
1300 P_MEDIAN
[1]= mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
1302 c
->pred_x
= P_LEFT
[0];
1303 c
->pred_y
= P_LEFT
[1];
1306 if(mv_table
== s
->b_forw_mv_table
){
1307 mv_scale
= (s
->pb_time
<<16) / (s
->pp_time
<<shift
);
1309 mv_scale
= ((s
->pb_time
- s
->pp_time
)<<16) / (s
->pp_time
<<shift
);
1312 dmin
= ff_epzs_motion_search(s
, &mx
, &my
, P
, 0, ref_index
, s
->p_mv_table
, mv_scale
, 0, 16);
1317 dmin
= c
->sub_motion_search(s
, &mx
, &my
, dmin
, 0, ref_index
, 0, 16);
1319 if(c
->avctx
->me_sub_cmp
!= c
->avctx
->mb_cmp
&& !c
->skip
)
1320 dmin
= ff_get_mb_score(s
, mx
, my
, 0, ref_index
, 0, 16, 1);
1322 //printf("%d %d %d %d//", s->mb_x, s->mb_y, mx, my);
1323 // s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
1324 mv_table
[mot_xy
][0]= mx
;
1325 mv_table
[mot_xy
][1]= my
;
1330 static inline int check_bidir_mv(MpegEncContext
* s
,
1331 int motion_fx
, int motion_fy
,
1332 int motion_bx
, int motion_by
,
1333 int pred_fx
, int pred_fy
,
1334 int pred_bx
, int pred_by
,
1338 //FIXME better f_code prediction (max mv & distance)
1340 MotionEstContext
* const c
= &s
->me
;
1341 uint8_t * const mv_penalty_f
= c
->mv_penalty
[s
->f_code
] + MAX_MV
; // f_code of the prev frame
1342 uint8_t * const mv_penalty_b
= c
->mv_penalty
[s
->b_code
] + MAX_MV
; // f_code of the prev frame
1343 int stride
= c
->stride
;
1344 uint8_t *dest_y
= c
->scratchpad
;
1349 uint8_t **src_data
= c
->src
[0];
1350 uint8_t **ref_data
= c
->ref
[0];
1351 uint8_t **ref2_data
= c
->ref
[2];
1353 if(s
->quarter_sample
){
1354 dxy
= ((motion_fy
& 3) << 2) | (motion_fx
& 3);
1355 src_x
= motion_fx
>> 2;
1356 src_y
= motion_fy
>> 2;
1358 ptr
= ref_data
[0] + (src_y
* stride
) + src_x
;
1359 s
->dsp
.put_qpel_pixels_tab
[0][dxy
](dest_y
, ptr
, stride
);
1361 dxy
= ((motion_by
& 3) << 2) | (motion_bx
& 3);
1362 src_x
= motion_bx
>> 2;
1363 src_y
= motion_by
>> 2;
1365 ptr
= ref2_data
[0] + (src_y
* stride
) + src_x
;
1366 s
->dsp
.avg_qpel_pixels_tab
[size
][dxy
](dest_y
, ptr
, stride
);
1368 dxy
= ((motion_fy
& 1) << 1) | (motion_fx
& 1);
1369 src_x
= motion_fx
>> 1;
1370 src_y
= motion_fy
>> 1;
1372 ptr
= ref_data
[0] + (src_y
* stride
) + src_x
;
1373 s
->dsp
.put_pixels_tab
[size
][dxy
](dest_y
, ptr
, stride
, h
);
1375 dxy
= ((motion_by
& 1) << 1) | (motion_bx
& 1);
1376 src_x
= motion_bx
>> 1;
1377 src_y
= motion_by
>> 1;
1379 ptr
= ref2_data
[0] + (src_y
* stride
) + src_x
;
1380 s
->dsp
.avg_pixels_tab
[size
][dxy
](dest_y
, ptr
, stride
, h
);
1383 fbmin
= (mv_penalty_f
[motion_fx
-pred_fx
] + mv_penalty_f
[motion_fy
-pred_fy
])*c
->mb_penalty_factor
1384 +(mv_penalty_b
[motion_bx
-pred_bx
] + mv_penalty_b
[motion_by
-pred_by
])*c
->mb_penalty_factor
1385 + s
->dsp
.mb_cmp
[size
](s
, src_data
[0], dest_y
, stride
, h
); //FIXME new_pic
1387 if(c
->avctx
->mb_cmp
&FF_CMP_CHROMA
){
1394 /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/
1395 static inline int bidir_refine(MpegEncContext
* s
, int mb_x
, int mb_y
)
1397 MotionEstContext
* const c
= &s
->me
;
1398 const int mot_stride
= s
->mb_stride
;
1399 const int xy
= mb_y
*mot_stride
+ mb_x
;
1401 int pred_fx
= s
->b_bidir_forw_mv_table
[xy
-1][0];
1402 int pred_fy
= s
->b_bidir_forw_mv_table
[xy
-1][1];
1403 int pred_bx
= s
->b_bidir_back_mv_table
[xy
-1][0];
1404 int pred_by
= s
->b_bidir_back_mv_table
[xy
-1][1];
1405 int motion_fx
= s
->b_bidir_forw_mv_table
[xy
][0]= s
->b_forw_mv_table
[xy
][0];
1406 int motion_fy
= s
->b_bidir_forw_mv_table
[xy
][1]= s
->b_forw_mv_table
[xy
][1];
1407 int motion_bx
= s
->b_bidir_back_mv_table
[xy
][0]= s
->b_back_mv_table
[xy
][0];
1408 int motion_by
= s
->b_bidir_back_mv_table
[xy
][1]= s
->b_back_mv_table
[xy
][1];
1409 const int flags
= c
->sub_flags
;
1410 const int qpel
= flags
&FLAG_QPEL
;
1411 const int shift
= 1+qpel
;
1412 const int xmin
= c
->xmin
<<shift
;
1413 const int ymin
= c
->ymin
<<shift
;
1414 const int xmax
= c
->xmax
<<shift
;
1415 const int ymax
= c
->ymax
<<shift
;
1416 uint8_t map
[8][8][8][8];
1418 memset(map
,0,sizeof(map
));
1419 #define BIDIR_MAP(fx,fy,bx,by) \
1420 map[(motion_fx+fx)&7][(motion_fy+fy)&7][(motion_bx+bx)&7][(motion_by+by)&7]
1421 BIDIR_MAP(0,0,0,0) = 1;
1423 fbmin
= check_bidir_mv(s
, motion_fx
, motion_fy
,
1424 motion_bx
, motion_by
,
1429 if(s
->avctx
->bidir_refine
){
1431 #define CHECK_BIDIR(fx,fy,bx,by)\
1432 if( !BIDIR_MAP(fx,fy,bx,by)\
1433 &&(fx<=0 || motion_fx+fx<=xmax) && (fy<=0 || motion_fy+fy<=ymax) && (bx<=0 || motion_bx+bx<=xmax) && (by<=0 || motion_by+by<=ymax)\
1434 &&(fx>=0 || motion_fx+fx>=xmin) && (fy>=0 || motion_fy+fy>=ymin) && (bx>=0 || motion_bx+bx>=xmin) && (by>=0 || motion_by+by>=ymin)){\
1435 BIDIR_MAP(fx,fy,bx,by) = 1;\
1436 score= check_bidir_mv(s, motion_fx+fx, motion_fy+fy, motion_bx+bx, motion_by+by, pred_fx, pred_fy, pred_bx, pred_by, 0, 16);\
1446 #define CHECK_BIDIR2(a,b,c,d)\
1447 CHECK_BIDIR(a,b,c,d)\
1448 CHECK_BIDIR(-(a),-(b),-(c),-(d))
1450 #define CHECK_BIDIRR(a,b,c,d)\
1451 CHECK_BIDIR2(a,b,c,d)\
1452 CHECK_BIDIR2(b,c,d,a)\
1453 CHECK_BIDIR2(c,d,a,b)\
1454 CHECK_BIDIR2(d,a,b,c)
1459 CHECK_BIDIRR( 0, 0, 0, 1)
1460 if(s
->avctx
->bidir_refine
> 1){
1461 CHECK_BIDIRR( 0, 0, 1, 1)
1462 CHECK_BIDIR2( 0, 1, 0, 1)
1463 CHECK_BIDIR2( 1, 0, 1, 0)
1464 CHECK_BIDIRR( 0, 0,-1, 1)
1465 CHECK_BIDIR2( 0,-1, 0, 1)
1466 CHECK_BIDIR2(-1, 0, 1, 0)
1467 if(s
->avctx
->bidir_refine
> 2){
1468 CHECK_BIDIRR( 0, 1, 1, 1)
1469 CHECK_BIDIRR( 0,-1, 1, 1)
1470 CHECK_BIDIRR( 0, 1,-1, 1)
1471 CHECK_BIDIRR( 0, 1, 1,-1)
1472 if(s
->avctx
->bidir_refine
> 3){
1473 CHECK_BIDIR2( 1, 1, 1, 1)
1474 CHECK_BIDIRR( 1, 1, 1,-1)
1475 CHECK_BIDIR2( 1, 1,-1,-1)
1476 CHECK_BIDIR2( 1,-1,-1, 1)
1477 CHECK_BIDIR2( 1,-1, 1,-1)
1484 s
->b_bidir_forw_mv_table
[xy
][0]= motion_fx
;
1485 s
->b_bidir_forw_mv_table
[xy
][1]= motion_fy
;
1486 s
->b_bidir_back_mv_table
[xy
][0]= motion_bx
;
1487 s
->b_bidir_back_mv_table
[xy
][1]= motion_by
;
1492 static inline int direct_search(MpegEncContext
* s
, int mb_x
, int mb_y
)
1494 MotionEstContext
* const c
= &s
->me
;
1496 const int mot_stride
= s
->mb_stride
;
1497 const int mot_xy
= mb_y
*mot_stride
+ mb_x
;
1498 const int shift
= 1+s
->quarter_sample
;
1500 const int time_pp
= s
->pp_time
;
1501 const int time_pb
= s
->pb_time
;
1502 int mx
, my
, xmin
, xmax
, ymin
, ymax
;
1503 int16_t (*mv_table
)[2]= s
->b_direct_mv_table
;
1505 c
->current_mv_penalty
= c
->mv_penalty
[1] + MAX_MV
;
1506 ymin
= xmin
=(-32)>>shift
;
1507 ymax
= xmax
= 31>>shift
;
1509 if(IS_8X8(s
->next_picture
.mb_type
[mot_xy
])){
1510 s
->mv_type
= MV_TYPE_8X8
;
1512 s
->mv_type
= MV_TYPE_16X16
;
1516 int index
= s
->block_index
[i
];
1519 c
->co_located_mv
[i
][0]= s
->next_picture
.motion_val
[0][index
][0];
1520 c
->co_located_mv
[i
][1]= s
->next_picture
.motion_val
[0][index
][1];
1521 c
->direct_basis_mv
[i
][0]= c
->co_located_mv
[i
][0]*time_pb
/time_pp
+ ((i
& 1)<<(shift
+3));
1522 c
->direct_basis_mv
[i
][1]= c
->co_located_mv
[i
][1]*time_pb
/time_pp
+ ((i
>>1)<<(shift
+3));
1523 // c->direct_basis_mv[1][i][0]= c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(shift+3);
1524 // c->direct_basis_mv[1][i][1]= c->co_located_mv[i][1]*(time_pb - time_pp)/time_pp + ((i>>1)<<(shift+3);
1526 max
= FFMAX(c
->direct_basis_mv
[i
][0], c
->direct_basis_mv
[i
][0] - c
->co_located_mv
[i
][0])>>shift
;
1527 min
= FFMIN(c
->direct_basis_mv
[i
][0], c
->direct_basis_mv
[i
][0] - c
->co_located_mv
[i
][0])>>shift
;
1528 max
+= 16*mb_x
+ 1; // +-1 is for the simpler rounding
1530 xmax
= FFMIN(xmax
, s
->width
- max
);
1531 xmin
= FFMAX(xmin
, - 16 - min
);
1533 max
= FFMAX(c
->direct_basis_mv
[i
][1], c
->direct_basis_mv
[i
][1] - c
->co_located_mv
[i
][1])>>shift
;
1534 min
= FFMIN(c
->direct_basis_mv
[i
][1], c
->direct_basis_mv
[i
][1] - c
->co_located_mv
[i
][1])>>shift
;
1535 max
+= 16*mb_y
+ 1; // +-1 is for the simpler rounding
1537 ymax
= FFMIN(ymax
, s
->height
- max
);
1538 ymin
= FFMAX(ymin
, - 16 - min
);
1540 if(s
->mv_type
== MV_TYPE_16X16
) break;
1543 assert(xmax
<= 15 && ymax
<= 15 && xmin
>= -16 && ymin
>= -16);
1545 if(xmax
< 0 || xmin
>0 || ymax
< 0 || ymin
> 0){
1546 s
->b_direct_mv_table
[mot_xy
][0]= 0;
1547 s
->b_direct_mv_table
[mot_xy
][1]= 0;
1549 return 256*256*256*64;
1556 c
->flags
|= FLAG_DIRECT
;
1557 c
->sub_flags
|= FLAG_DIRECT
;
1561 P_LEFT
[0] = av_clip(mv_table
[mot_xy
- 1][0], xmin
<<shift
, xmax
<<shift
);
1562 P_LEFT
[1] = av_clip(mv_table
[mot_xy
- 1][1], ymin
<<shift
, ymax
<<shift
);
1564 /* special case for first line */
1565 if (!s
->first_slice_line
) { //FIXME maybe allow this over thread boundary as it is clipped
1566 P_TOP
[0] = av_clip(mv_table
[mot_xy
- mot_stride
][0], xmin
<<shift
, xmax
<<shift
);
1567 P_TOP
[1] = av_clip(mv_table
[mot_xy
- mot_stride
][1], ymin
<<shift
, ymax
<<shift
);
1568 P_TOPRIGHT
[0] = av_clip(mv_table
[mot_xy
- mot_stride
+ 1 ][0], xmin
<<shift
, xmax
<<shift
);
1569 P_TOPRIGHT
[1] = av_clip(mv_table
[mot_xy
- mot_stride
+ 1 ][1], ymin
<<shift
, ymax
<<shift
);
1571 P_MEDIAN
[0]= mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
1572 P_MEDIAN
[1]= mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
1575 dmin
= ff_epzs_motion_search(s
, &mx
, &my
, P
, 0, 0, mv_table
, 1<<(16-shift
), 0, 16);
1576 if(c
->sub_flags
&FLAG_QPEL
)
1577 dmin
= qpel_motion_search(s
, &mx
, &my
, dmin
, 0, 0, 0, 16);
1579 dmin
= hpel_motion_search(s
, &mx
, &my
, dmin
, 0, 0, 0, 16);
1581 if(c
->avctx
->me_sub_cmp
!= c
->avctx
->mb_cmp
&& !c
->skip
)
1582 dmin
= ff_get_mb_score(s
, mx
, my
, 0, 0, 0, 16, 1);
1584 get_limits(s
, 16*mb_x
, 16*mb_y
); //restore c->?min/max, maybe not needed
1586 mv_table
[mot_xy
][0]= mx
;
1587 mv_table
[mot_xy
][1]= my
;
1588 c
->flags
&= ~FLAG_DIRECT
;
1589 c
->sub_flags
&= ~FLAG_DIRECT
;
1594 void ff_estimate_b_frame_motion(MpegEncContext
* s
,
1597 MotionEstContext
* const c
= &s
->me
;
1598 const int penalty_factor
= c
->mb_penalty_factor
;
1599 int fmin
, bmin
, dmin
, fbmin
, bimin
, fimin
;
1601 const int xy
= mb_y
*s
->mb_stride
+ mb_x
;
1602 init_ref(c
, s
->new_picture
.data
, s
->last_picture
.data
, s
->next_picture
.data
, 16*mb_x
, 16*mb_y
, 2);
1604 get_limits(s
, 16*mb_x
, 16*mb_y
);
1608 if(s
->codec_id
== CODEC_ID_MPEG4
&& s
->next_picture
.mbskip_table
[xy
]){
1609 int score
= direct_search(s
, mb_x
, mb_y
); //FIXME just check 0,0
1611 score
= ((unsigned)(score
*score
+ 128*256))>>16;
1612 c
->mc_mb_var_sum_temp
+= score
;
1613 s
->current_picture
.mc_mb_var
[mb_y
*s
->mb_stride
+ mb_x
] = score
; //FIXME use SSE
1614 s
->mb_type
[mb_y
*s
->mb_stride
+ mb_x
]= CANDIDATE_MB_TYPE_DIRECT0
;
1619 if(c
->avctx
->me_threshold
){
1620 int vard
= check_input_motion(s
, mb_x
, mb_y
, 0);
1622 if((vard
+128)>>8 < c
->avctx
->me_threshold
){
1623 // pix = c->src[0][0];
1624 // sum = s->dsp.pix_sum(pix, s->linesize);
1625 // varc = s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500;
1627 // pic->mb_var [s->mb_stride * mb_y + mb_x] = (varc+128)>>8;
1628 s
->current_picture
.mc_mb_var
[s
->mb_stride
* mb_y
+ mb_x
] = (vard
+128)>>8;
1629 /* pic->mb_mean [s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
1630 c->mb_var_sum_temp += (varc+128)>>8;*/
1631 c
->mc_mb_var_sum_temp
+= (vard
+128)>>8;
1632 /* if (vard <= 64<<8 || vard < varc) {
1633 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
1635 c->scene_change_score+= s->qscale * s->avctx->scenechange_factor;
1639 if((vard
+128)>>8 < c
->avctx
->mb_threshold
){
1640 type
= s
->mb_type
[mb_y
*s
->mb_stride
+ mb_x
];
1641 if(type
== CANDIDATE_MB_TYPE_DIRECT
){
1642 direct_search(s
, mb_x
, mb_y
);
1644 if(type
== CANDIDATE_MB_TYPE_FORWARD
|| type
== CANDIDATE_MB_TYPE_BIDIR
){
1646 ff_estimate_motion_b(s
, mb_x
, mb_y
, s
->b_forw_mv_table
, 0, s
->f_code
);
1648 if(type
== CANDIDATE_MB_TYPE_BACKWARD
|| type
== CANDIDATE_MB_TYPE_BIDIR
){
1650 ff_estimate_motion_b(s
, mb_x
, mb_y
, s
->b_back_mv_table
, 2, s
->b_code
);
1652 if(type
== CANDIDATE_MB_TYPE_FORWARD_I
|| type
== CANDIDATE_MB_TYPE_BIDIR_I
){
1654 c
->current_mv_penalty
= c
->mv_penalty
[s
->f_code
] + MAX_MV
;
1655 interlaced_search(s
, 0,
1656 s
->b_field_mv_table
[0], s
->b_field_select_table
[0],
1657 s
->b_forw_mv_table
[xy
][0], s
->b_forw_mv_table
[xy
][1], 1);
1659 if(type
== CANDIDATE_MB_TYPE_BACKWARD_I
|| type
== CANDIDATE_MB_TYPE_BIDIR_I
){
1661 c
->current_mv_penalty
= c
->mv_penalty
[s
->b_code
] + MAX_MV
;
1662 interlaced_search(s
, 2,
1663 s
->b_field_mv_table
[1], s
->b_field_select_table
[1],
1664 s
->b_back_mv_table
[xy
][0], s
->b_back_mv_table
[xy
][1], 1);
1670 if (s
->codec_id
== CODEC_ID_MPEG4
)
1671 dmin
= direct_search(s
, mb_x
, mb_y
);
1674 //FIXME penalty stuff for non mpeg4
1676 fmin
= ff_estimate_motion_b(s
, mb_x
, mb_y
, s
->b_forw_mv_table
, 0, s
->f_code
) + 3*penalty_factor
;
1679 bmin
= ff_estimate_motion_b(s
, mb_x
, mb_y
, s
->b_back_mv_table
, 2, s
->b_code
) + 2*penalty_factor
;
1680 //printf(" %d %d ", s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1]);
1683 fbmin
= bidir_refine(s
, mb_x
, mb_y
) + penalty_factor
;
1684 //printf("%d %d %d %d\n", dmin, fmin, bmin, fbmin);
1686 if(s
->flags
& CODEC_FLAG_INTERLACED_ME
){
1687 //FIXME mb type penalty
1689 c
->current_mv_penalty
= c
->mv_penalty
[s
->f_code
] + MAX_MV
;
1690 fimin
= interlaced_search(s
, 0,
1691 s
->b_field_mv_table
[0], s
->b_field_select_table
[0],
1692 s
->b_forw_mv_table
[xy
][0], s
->b_forw_mv_table
[xy
][1], 0);
1693 c
->current_mv_penalty
= c
->mv_penalty
[s
->b_code
] + MAX_MV
;
1694 bimin
= interlaced_search(s
, 2,
1695 s
->b_field_mv_table
[1], s
->b_field_select_table
[1],
1696 s
->b_back_mv_table
[xy
][0], s
->b_back_mv_table
[xy
][1], 0);
1698 fimin
= bimin
= INT_MAX
;
1702 type
= CANDIDATE_MB_TYPE_FORWARD
;
1706 type
= CANDIDATE_MB_TYPE_DIRECT
;
1710 type
= CANDIDATE_MB_TYPE_BACKWARD
;
1714 type
= CANDIDATE_MB_TYPE_BIDIR
;
1718 type
= CANDIDATE_MB_TYPE_FORWARD_I
;
1722 type
= CANDIDATE_MB_TYPE_BACKWARD_I
;
1725 score
= ((unsigned)(score
*score
+ 128*256))>>16;
1726 c
->mc_mb_var_sum_temp
+= score
;
1727 s
->current_picture
.mc_mb_var
[mb_y
*s
->mb_stride
+ mb_x
] = score
; //FIXME use SSE
1730 if(c
->avctx
->mb_decision
> FF_MB_DECISION_SIMPLE
){
1731 type
= CANDIDATE_MB_TYPE_FORWARD
| CANDIDATE_MB_TYPE_BACKWARD
| CANDIDATE_MB_TYPE_BIDIR
| CANDIDATE_MB_TYPE_DIRECT
;
1733 type
|= CANDIDATE_MB_TYPE_FORWARD_I
;
1735 type
|= CANDIDATE_MB_TYPE_BACKWARD_I
;
1736 if(fimin
< INT_MAX
&& bimin
< INT_MAX
){
1737 type
|= CANDIDATE_MB_TYPE_BIDIR_I
;
1739 //FIXME something smarter
1740 if(dmin
>256*256*16) type
&= ~CANDIDATE_MB_TYPE_DIRECT
; //do not try direct mode if it is invalid for this MB
1741 if(s
->codec_id
== CODEC_ID_MPEG4
&& type
&CANDIDATE_MB_TYPE_DIRECT
&& s
->flags
&CODEC_FLAG_MV0
&& *(uint32_t*)s
->b_direct_mv_table
[xy
])
1742 type
|= CANDIDATE_MB_TYPE_DIRECT0
;
1744 if(s
->out_format
== FMT_MPEG1
)
1745 type
|= CANDIDATE_MB_TYPE_INTRA
;
1749 s
->mb_type
[mb_y
*s
->mb_stride
+ mb_x
]= type
;
1752 /* find best f_code for ME which do unlimited searches */
1753 int ff_get_best_fcode(MpegEncContext
* s
, int16_t (*mv_table
)[2], int type
)
1755 if(s
->me_method
>=ME_EPZS
){
1757 int i
, y
, range
= s
->avctx
->me_range
? s
->avctx
->me_range
: (INT_MAX
/2);
1758 uint8_t * fcode_tab
= s
->fcode_tab
;
1760 int best_score
=-10000000;
1762 if(s
->msmpeg4_version
)
1763 range
= FFMIN(range
, 16);
1764 else if(s
->codec_id
== CODEC_ID_MPEG2VIDEO
&& s
->avctx
->strict_std_compliance
>= FF_COMPLIANCE_NORMAL
)
1765 range
= FFMIN(range
, 256);
1767 for(i
=0; i
<8; i
++) score
[i
]= s
->mb_num
*(8-i
);
1769 for(y
=0; y
<s
->mb_height
; y
++){
1771 int xy
= y
*s
->mb_stride
;
1772 for(x
=0; x
<s
->mb_width
; x
++){
1773 if(s
->mb_type
[xy
] & type
){
1774 int mx
= mv_table
[xy
][0];
1775 int my
= mv_table
[xy
][1];
1776 int fcode
= FFMAX(fcode_tab
[mx
+ MAX_MV
],
1777 fcode_tab
[my
+ MAX_MV
]);
1780 if(mx
>= range
|| mx
< -range
||
1781 my
>= range
|| my
< -range
)
1784 for(j
=0; j
<fcode
&& j
<8; j
++){
1785 if(s
->pict_type
==FF_B_TYPE
|| s
->current_picture
.mc_mb_var
[xy
] < s
->current_picture
.mb_var
[xy
])
1794 if(score
[i
] > best_score
){
1795 best_score
= score
[i
];
1798 // printf("%d %d\n", i, score[i]);
1801 // printf("fcode: %d type: %d\n", i, s->pict_type);
1803 /* for(i=0; i<=MAX_FCODE; i++){
1804 printf("%d ", mv_num[i]);
1812 void ff_fix_long_p_mvs(MpegEncContext
* s
)
1814 MotionEstContext
* const c
= &s
->me
;
1815 const int f_code
= s
->f_code
;
1817 assert(s
->pict_type
==FF_P_TYPE
);
1819 range
= (((s
->out_format
== FMT_MPEG1
|| s
->msmpeg4_version
) ? 8 : 16) << f_code
);
1821 assert(range
<= 16 || !s
->msmpeg4_version
);
1822 assert(range
<=256 || !(s
->codec_id
== CODEC_ID_MPEG2VIDEO
&& s
->avctx
->strict_std_compliance
>= FF_COMPLIANCE_NORMAL
));
1824 if(c
->avctx
->me_range
&& range
> c
->avctx
->me_range
) range
= c
->avctx
->me_range
;
1826 //printf("%d no:%d %d//\n", clip, noclip, f_code);
1827 if(s
->flags
&CODEC_FLAG_4MV
){
1828 const int wrap
= s
->b8_stride
;
1830 /* clip / convert to intra 8x8 type MVs */
1831 for(y
=0; y
<s
->mb_height
; y
++){
1833 int i
= y
*s
->mb_stride
;
1836 for(x
=0; x
<s
->mb_width
; x
++){
1837 if(s
->mb_type
[i
]&CANDIDATE_MB_TYPE_INTER4V
){
1839 for(block
=0; block
<4; block
++){
1840 int off
= (block
& 1) + (block
>>1)*wrap
;
1841 int mx
= s
->current_picture
.motion_val
[0][ xy
+ off
][0];
1842 int my
= s
->current_picture
.motion_val
[0][ xy
+ off
][1];
1844 if( mx
>=range
|| mx
<-range
1845 || my
>=range
|| my
<-range
){
1846 s
->mb_type
[i
] &= ~CANDIDATE_MB_TYPE_INTER4V
;
1847 s
->mb_type
[i
] |= CANDIDATE_MB_TYPE_INTRA
;
1848 s
->current_picture
.mb_type
[i
]= CANDIDATE_MB_TYPE_INTRA
;
1861 * @param truncate 1 for truncation, 0 for using intra
1863 void ff_fix_long_mvs(MpegEncContext
* s
, uint8_t *field_select_table
, int field_select
,
1864 int16_t (*mv_table
)[2], int f_code
, int type
, int truncate
)
1866 MotionEstContext
* const c
= &s
->me
;
1867 int y
, h_range
, v_range
;
1869 // RAL: 8 in MPEG-1, 16 in MPEG-4
1870 int range
= (((s
->out_format
== FMT_MPEG1
|| s
->msmpeg4_version
) ? 8 : 16) << f_code
);
1872 if(c
->avctx
->me_range
&& range
> c
->avctx
->me_range
) range
= c
->avctx
->me_range
;
1875 v_range
= field_select_table
? range
>>1 : range
;
1877 /* clip / convert to intra 16x16 type MVs */
1878 for(y
=0; y
<s
->mb_height
; y
++){
1880 int xy
= y
*s
->mb_stride
;
1881 for(x
=0; x
<s
->mb_width
; x
++){
1882 if (s
->mb_type
[xy
] & type
){ // RAL: "type" test added...
1883 if(field_select_table
==NULL
|| field_select_table
[xy
] == field_select
){
1884 if( mv_table
[xy
][0] >=h_range
|| mv_table
[xy
][0] <-h_range
1885 || mv_table
[xy
][1] >=v_range
|| mv_table
[xy
][1] <-v_range
){
1888 if (mv_table
[xy
][0] > h_range
-1) mv_table
[xy
][0]= h_range
-1;
1889 else if(mv_table
[xy
][0] < -h_range
) mv_table
[xy
][0]= -h_range
;
1890 if (mv_table
[xy
][1] > v_range
-1) mv_table
[xy
][1]= v_range
-1;
1891 else if(mv_table
[xy
][1] < -v_range
) mv_table
[xy
][1]= -v_range
;
1893 s
->mb_type
[xy
] &= ~type
;
1894 s
->mb_type
[xy
] |= CANDIDATE_MB_TYPE_INTRA
;