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
36 #include "mpegutils.h"
37 #include "mpegvideo.h"
44 #define P_TOPRIGHT P[3]
48 #define ME_MAP_SHIFT 3
49 #define ME_MAP_MV_BITS 11
51 static int sad_hpel_motion_search(MpegEncContext
* s
,
52 int *mx_ptr
, int *my_ptr
, int dmin
,
53 int src_index
, int ref_index
,
56 static inline unsigned update_map_generation(MotionEstContext
*c
)
58 c
->map_generation
+= 1<<(ME_MAP_MV_BITS
*2);
59 if(c
->map_generation
==0){
60 c
->map_generation
= 1<<(ME_MAP_MV_BITS
*2);
61 memset(c
->map
, 0, sizeof(uint32_t)*ME_MAP_SIZE
);
63 return c
->map_generation
;
66 /* shape adaptive search stuff */
67 typedef struct Minima
{
73 static int minima_cmp(const void *a
, const void *b
){
74 const Minima
*da
= (const Minima
*) a
;
75 const Minima
*db
= (const Minima
*) b
;
77 return da
->height
- db
->height
;
80 #define FLAG_QPEL 1 //must be 1
84 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
){
85 const int offset
[3]= {
87 ((y
*c
->uvstride
+ x
)>>1),
88 ((y
*c
->uvstride
+ x
)>>1),
92 c
->src
[0][i
]= src
[i
] + offset
[i
];
93 c
->ref
[0][i
]= ref
[i
] + offset
[i
];
97 c
->ref
[ref_index
][i
]= ref2
[i
] + offset
[i
];
102 static int get_flags(MotionEstContext
*c
, int direct
, int chroma
){
103 return ((c
->avctx
->flags
&CODEC_FLAG_QPEL
) ? FLAG_QPEL
: 0)
104 + (direct
? FLAG_DIRECT
: 0)
105 + (chroma
? FLAG_CHROMA
: 0);
108 static av_always_inline
int cmp_direct_inline(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
, int qpel
){
111 MotionEstContext
* const c
= &s
->me
;
112 const int stride
= c
->stride
;
113 const int hx
= subx
+ (x
<<(1+qpel
));
114 const int hy
= suby
+ (y
<<(1+qpel
));
115 uint8_t * const * const ref
= c
->ref
[ref_index
];
116 uint8_t * const * const src
= c
->src
[src_index
];
118 //FIXME check chroma 4mv, (no crashes ...)
119 av_assert2(x
>= c
->xmin
&& hx
<= c
->xmax
<<(qpel
+1) && y
>= c
->ymin
&& hy
<= c
->ymax
<<(qpel
+1));
120 if(x
>= c
->xmin
&& hx
<= c
->xmax
<<(qpel
+1) && y
>= c
->ymin
&& hy
<= c
->ymax
<<(qpel
+1)){
121 const int time_pp
= s
->pp_time
;
122 const int time_pb
= s
->pb_time
;
123 const int mask
= 2*qpel
+1;
124 if(s
->mv_type
==MV_TYPE_8X8
){
127 int fx
= c
->direct_basis_mv
[i
][0] + hx
;
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));
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));
132 int bxy
= (bx
&mask
) + ((by
&mask
)<<(qpel
+1));
134 uint8_t *dst
= c
->temp
+ 8*(i
&1) + 8*stride
*(i
>>1);
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
);
139 c
->hpel_put
[1][fxy
](dst
, ref
[0] + (fx
>>1) + (fy
>>1)*stride
, stride
, 8);
140 c
->hpel_avg
[1][bxy
](dst
, ref
[8] + (bx
>>1) + (by
>>1)*stride
, stride
, 8);
144 int fx
= c
->direct_basis_mv
[0][0] + hx
;
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
);
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));
149 int bxy
= (bx
&mask
) + ((by
&mask
)<<(qpel
+1));
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
);
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
);
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
);
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
);
161 av_assert2((fx
>>1) + 16*s
->mb_x
>= -16);
162 av_assert2((fy
>>1) + 16*s
->mb_y
>= -16);
163 av_assert2((fx
>>1) + 16*s
->mb_x
<= s
->width
);
164 av_assert2((fy
>>1) + 16*s
->mb_y
<= s
->height
);
165 av_assert2((bx
>>1) + 16*s
->mb_x
>= -16);
166 av_assert2((by
>>1) + 16*s
->mb_y
>= -16);
167 av_assert2((bx
>>1) + 16*s
->mb_x
<= s
->width
);
168 av_assert2((by
>>1) + 16*s
->mb_y
<= s
->height
);
170 c
->hpel_put
[0][fxy
](c
->temp
, ref
[0] + (fx
>>1) + (fy
>>1)*stride
, stride
, 16);
171 c
->hpel_avg
[0][bxy
](c
->temp
, ref
[8] + (bx
>>1) + (by
>>1)*stride
, stride
, 16);
174 d
= cmp_func(s
, c
->temp
, src
[0], stride
, 16);
180 static av_always_inline
int cmp_inline(MpegEncContext
*s
, const int x
, const int y
, const int subx
, const int suby
,
181 const int size
, const int h
, int ref_index
, int src_index
,
182 me_cmp_func cmp_func
, me_cmp_func chroma_cmp_func
, int qpel
, int chroma
){
183 MotionEstContext
* const c
= &s
->me
;
184 const int stride
= c
->stride
;
185 const int uvstride
= c
->uvstride
;
186 const int dxy
= subx
+ (suby
<<(1+qpel
)); //FIXME log2_subpel?
187 const int hx
= subx
+ (x
<<(1+qpel
));
188 const int hy
= suby
+ (y
<<(1+qpel
));
189 uint8_t * const * const ref
= c
->ref
[ref_index
];
190 uint8_t * const * const src
= c
->src
[src_index
];
192 //FIXME check chroma 4mv, (no crashes ...)
193 int uvdxy
; /* no, it might not be used uninitialized */
196 c
->qpel_put
[size
][dxy
](c
->temp
, ref
[0] + x
+ y
*stride
, stride
); //FIXME prototype (add h)
202 uvdxy
= (cx
&1) + 2*(cy
&1);
203 //FIXME x/y wrong, but mpeg4 qpel is sick anyway, we should drop as much of it as possible in favor for h264
206 c
->hpel_put
[size
][dxy
](c
->temp
, ref
[0] + x
+ y
*stride
, stride
, h
);
208 uvdxy
= dxy
| (x
&1) | (2*(y
&1));
210 d
= cmp_func(s
, c
->temp
, src
[0], stride
, h
);
212 d
= cmp_func(s
, src
[0], ref
[0] + x
+ y
*stride
, stride
, h
);
214 uvdxy
= (x
&1) + 2*(y
&1);
217 uint8_t * const uvtemp
= c
->temp
+ 16*stride
;
218 c
->hpel_put
[size
+1][uvdxy
](uvtemp
, ref
[1] + (x
>>1) + (y
>>1)*uvstride
, uvstride
, h
>>1);
219 c
->hpel_put
[size
+1][uvdxy
](uvtemp
+8, ref
[2] + (x
>>1) + (y
>>1)*uvstride
, uvstride
, h
>>1);
220 d
+= chroma_cmp_func(s
, uvtemp
, src
[1], uvstride
, h
>>1);
221 d
+= chroma_cmp_func(s
, uvtemp
+8, src
[2], uvstride
, h
>>1);
226 static int cmp_simple(MpegEncContext
*s
, const int x
, const int y
,
227 int ref_index
, int src_index
,
228 me_cmp_func cmp_func
, me_cmp_func chroma_cmp_func
){
229 return cmp_inline(s
,x
,y
,0,0,0,16,ref_index
,src_index
, cmp_func
, chroma_cmp_func
, 0, 0);
232 static int cmp_fpel_internal(MpegEncContext
*s
, const int x
, const int y
,
233 const int size
, const int h
, int ref_index
, int src_index
,
234 me_cmp_func cmp_func
, me_cmp_func chroma_cmp_func
, const int flags
){
235 if(flags
&FLAG_DIRECT
){
236 return cmp_direct_inline(s
,x
,y
,0,0,size
,h
,ref_index
,src_index
, cmp_func
, chroma_cmp_func
, flags
&FLAG_QPEL
);
238 return cmp_inline(s
,x
,y
,0,0,size
,h
,ref_index
,src_index
, cmp_func
, chroma_cmp_func
, 0, flags
&FLAG_CHROMA
);
242 static int cmp_internal(MpegEncContext
*s
, const int x
, const int y
, const int subx
, const int suby
,
243 const int size
, const int h
, int ref_index
, int src_index
,
244 me_cmp_func cmp_func
, me_cmp_func chroma_cmp_func
, const int flags
){
245 if(flags
&FLAG_DIRECT
){
246 return cmp_direct_inline(s
,x
,y
,subx
,suby
,size
,h
,ref_index
,src_index
, cmp_func
, chroma_cmp_func
, flags
&FLAG_QPEL
);
248 return cmp_inline(s
,x
,y
,subx
,suby
,size
,h
,ref_index
,src_index
, cmp_func
, chroma_cmp_func
, flags
&FLAG_QPEL
, flags
&FLAG_CHROMA
);
252 /** @brief compares a block (either a full macroblock or a partition thereof)
253 against a proposed motion-compensated prediction of that block
255 static av_always_inline
int cmp(MpegEncContext
*s
, const int x
, const int y
, const int subx
, const int suby
,
256 const int size
, const int h
, int ref_index
, int src_index
,
257 me_cmp_func cmp_func
, me_cmp_func chroma_cmp_func
, const int flags
){
258 if(av_builtin_constant_p(flags
) && av_builtin_constant_p(h
) && av_builtin_constant_p(size
)
259 && av_builtin_constant_p(subx
) && av_builtin_constant_p(suby
)
260 && flags
==0 && h
==16 && size
==0 && subx
==0 && suby
==0){
261 return cmp_simple(s
,x
,y
,ref_index
,src_index
, cmp_func
, chroma_cmp_func
);
262 }else if(av_builtin_constant_p(subx
) && av_builtin_constant_p(suby
)
263 && subx
==0 && suby
==0){
264 return cmp_fpel_internal(s
,x
,y
,size
,h
,ref_index
,src_index
, cmp_func
, chroma_cmp_func
,flags
);
266 return cmp_internal(s
,x
,y
,subx
,suby
,size
,h
,ref_index
,src_index
, cmp_func
, chroma_cmp_func
, flags
);
270 static int cmp_hpel(MpegEncContext
*s
, const int x
, const int y
, const int subx
, const int suby
,
271 const int size
, const int h
, int ref_index
, int src_index
,
272 me_cmp_func cmp_func
, me_cmp_func chroma_cmp_func
, const int flags
){
273 if(flags
&FLAG_DIRECT
){
274 return cmp_direct_inline(s
,x
,y
,subx
,suby
,size
,h
,ref_index
,src_index
, cmp_func
, chroma_cmp_func
, 0);
276 return cmp_inline(s
,x
,y
,subx
,suby
,size
,h
,ref_index
,src_index
, cmp_func
, chroma_cmp_func
, 0, flags
&FLAG_CHROMA
);
280 static int cmp_qpel(MpegEncContext
*s
, const int x
, const int y
, const int subx
, const int suby
,
281 const int size
, const int h
, int ref_index
, int src_index
,
282 me_cmp_func cmp_func
, me_cmp_func chroma_cmp_func
, const int flags
){
283 if(flags
&FLAG_DIRECT
){
284 return cmp_direct_inline(s
,x
,y
,subx
,suby
,size
,h
,ref_index
,src_index
, cmp_func
, chroma_cmp_func
, 1);
286 return cmp_inline(s
,x
,y
,subx
,suby
,size
,h
,ref_index
,src_index
, cmp_func
, chroma_cmp_func
, 1, flags
&FLAG_CHROMA
);
290 #include "motion_est_template.c"
292 static int zero_cmp(MpegEncContext
*s
, uint8_t *a
, uint8_t *b
,
298 static void zero_hpel(uint8_t *a
, const uint8_t *b
, ptrdiff_t stride
, int h
){
301 int ff_init_me(MpegEncContext
*s
){
302 MotionEstContext
* const c
= &s
->me
;
303 int cache_size
= FFMIN(ME_MAP_SIZE
>>ME_MAP_SHIFT
, 1<<ME_MAP_SHIFT
);
304 int dia_size
= FFMAX(FFABS(s
->avctx
->dia_size
)&255, FFABS(s
->avctx
->pre_dia_size
)&255);
306 if(FFMIN(s
->avctx
->dia_size
, s
->avctx
->pre_dia_size
) < -FFMIN(ME_MAP_SIZE
, MAX_SAB_SIZE
)){
307 av_log(s
->avctx
, AV_LOG_ERROR
, "ME_MAP size is too small for SAB diamond\n");
310 //special case of snow is needed because snow uses its own iterative ME code
311 if(s
->me_method
!=ME_ZERO
&& s
->me_method
!=ME_EPZS
&& s
->me_method
!=ME_X1
&& s
->avctx
->codec_id
!= AV_CODEC_ID_SNOW
){
312 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");
318 if(cache_size
< 2*dia_size
&& !c
->stride
){
319 av_log(s
->avctx
, AV_LOG_INFO
, "ME_MAP size may be a little small for the selected diamond size\n");
322 ff_set_cmp(&s
->mecc
, s
->mecc
.me_pre_cmp
, c
->avctx
->me_pre_cmp
);
323 ff_set_cmp(&s
->mecc
, s
->mecc
.me_cmp
, c
->avctx
->me_cmp
);
324 ff_set_cmp(&s
->mecc
, s
->mecc
.me_sub_cmp
, c
->avctx
->me_sub_cmp
);
325 ff_set_cmp(&s
->mecc
, s
->mecc
.mb_cmp
, c
->avctx
->mb_cmp
);
327 c
->flags
= get_flags(c
, 0, c
->avctx
->me_cmp
&FF_CMP_CHROMA
);
328 c
->sub_flags
= get_flags(c
, 0, c
->avctx
->me_sub_cmp
&FF_CMP_CHROMA
);
329 c
->mb_flags
= get_flags(c
, 0, c
->avctx
->mb_cmp
&FF_CMP_CHROMA
);
331 /*FIXME s->no_rounding b_type*/
332 if(s
->flags
&CODEC_FLAG_QPEL
){
333 c
->sub_motion_search
= qpel_motion_search
;
334 c
->qpel_avg
= s
->qdsp
.avg_qpel_pixels_tab
;
336 c
->qpel_put
= s
->qdsp
.put_no_rnd_qpel_pixels_tab
;
338 c
->qpel_put
= s
->qdsp
.put_qpel_pixels_tab
;
340 if(c
->avctx
->me_sub_cmp
&FF_CMP_CHROMA
)
341 c
->sub_motion_search
= hpel_motion_search
;
342 else if( c
->avctx
->me_sub_cmp
== FF_CMP_SAD
343 && c
->avctx
-> me_cmp
== FF_CMP_SAD
344 && c
->avctx
-> mb_cmp
== FF_CMP_SAD
)
345 c
->sub_motion_search
= sad_hpel_motion_search
; // 2050 vs. 2450 cycles
347 c
->sub_motion_search
= hpel_motion_search
;
349 c
->hpel_avg
= s
->hdsp
.avg_pixels_tab
;
351 c
->hpel_put
= s
->hdsp
.put_no_rnd_pixels_tab
;
353 c
->hpel_put
= s
->hdsp
.put_pixels_tab
;
356 c
->stride
= s
->linesize
;
357 c
->uvstride
= s
->uvlinesize
;
359 c
->stride
= 16*s
->mb_width
+ 32;
360 c
->uvstride
= 8*s
->mb_width
+ 16;
363 /* 8x8 fullpel search would need a 4x4 chroma compare, which we do
364 * not have yet, and even if we had, the motion estimation code
365 * does not expect it. */
366 if (s
->codec_id
!= AV_CODEC_ID_SNOW
) {
367 if ((c
->avctx
->me_cmp
& FF_CMP_CHROMA
) /* && !s->mecc.me_cmp[2] */)
368 s
->mecc
.me_cmp
[2] = zero_cmp
;
369 if ((c
->avctx
->me_sub_cmp
& FF_CMP_CHROMA
) && !s
->mecc
.me_sub_cmp
[2])
370 s
->mecc
.me_sub_cmp
[2] = zero_cmp
;
371 c
->hpel_put
[2][0]= c
->hpel_put
[2][1]=
372 c
->hpel_put
[2][2]= c
->hpel_put
[2][3]= zero_hpel
;
375 if(s
->codec_id
== AV_CODEC_ID_H261
){
376 c
->sub_motion_search
= no_sub_motion_search
;
382 #define CHECK_SAD_HALF_MV(suffix, x, y) \
384 d = s->mecc.pix_abs[size][(x ? 1 : 0) + (y ? 2 : 0)](NULL, pix, ptr + ((x) >> 1), stride, h); \
385 d += (mv_penalty[pen_x + x] + mv_penalty[pen_y + y])*penalty_factor;\
386 COPY3_IF_LT(dminh, d, dx, x, dy, y)\
389 static int sad_hpel_motion_search(MpegEncContext
* s
,
390 int *mx_ptr
, int *my_ptr
, int dmin
,
391 int src_index
, int ref_index
,
394 MotionEstContext
* const c
= &s
->me
;
395 const int penalty_factor
= c
->sub_penalty_factor
;
398 int stride
= c
->stride
;
401 av_assert2(c
->sub_flags
== 0);
409 pix
= c
->src
[src_index
][0];
413 ptr
= c
->ref
[ref_index
][0] + (my
* stride
) + mx
;
417 if (mx
> xmin
&& mx
< xmax
&&
418 my
> ymin
&& my
< ymax
) {
421 const int index
= (my
<<ME_MAP_SHIFT
) + mx
;
422 const int t
= score_map
[(index
-(1<<ME_MAP_SHIFT
))&(ME_MAP_SIZE
-1)];
423 const int l
= score_map
[(index
- 1 )&(ME_MAP_SIZE
-1)];
424 const int r
= score_map
[(index
+ 1 )&(ME_MAP_SIZE
-1)];
425 const int b
= score_map
[(index
+(1<<ME_MAP_SHIFT
))&(ME_MAP_SIZE
-1)];
435 CHECK_SAD_HALF_MV(y2
, 0, -1)
437 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)
447 CHECK_SAD_HALF_MV(xy2
, +1, -1)
449 CHECK_SAD_HALF_MV(xy2
, -1, -1)
453 CHECK_SAD_HALF_MV(xy2
, +1, +1)
455 CHECK_SAD_HALF_MV(x2
, +1, 0)
460 CHECK_SAD_HALF_MV(xy2
, -1, -1)
464 CHECK_SAD_HALF_MV(xy2
, +1, +1)
466 CHECK_SAD_HALF_MV(x2
, -1, 0)
467 CHECK_SAD_HALF_MV(xy2
, -1, +1)
470 CHECK_SAD_HALF_MV(xy2
, +1, -1)
474 CHECK_SAD_HALF_MV(xy2
, -1, +1)
476 CHECK_SAD_HALF_MV(x2
, +1, 0)
477 CHECK_SAD_HALF_MV(xy2
, +1, +1)
479 CHECK_SAD_HALF_MV(y2
, 0, +1)
494 static inline void set_p_mv_tables(MpegEncContext
* s
, int mx
, int my
, int mv4
)
496 const int xy
= s
->mb_x
+ s
->mb_y
*s
->mb_stride
;
498 s
->p_mv_table
[xy
][0] = mx
;
499 s
->p_mv_table
[xy
][1] = my
;
501 /* has already been set to the 4 MV if 4MV is done */
503 int mot_xy
= s
->block_index
[0];
505 s
->current_picture
.motion_val
[0][mot_xy
][0] = mx
;
506 s
->current_picture
.motion_val
[0][mot_xy
][1] = my
;
507 s
->current_picture
.motion_val
[0][mot_xy
+ 1][0] = mx
;
508 s
->current_picture
.motion_val
[0][mot_xy
+ 1][1] = my
;
510 mot_xy
+= s
->b8_stride
;
511 s
->current_picture
.motion_val
[0][mot_xy
][0] = mx
;
512 s
->current_picture
.motion_val
[0][mot_xy
][1] = my
;
513 s
->current_picture
.motion_val
[0][mot_xy
+ 1][0] = mx
;
514 s
->current_picture
.motion_val
[0][mot_xy
+ 1][1] = my
;
519 * get fullpel ME search limits.
521 static inline void get_limits(MpegEncContext
*s
, int x
, int y
)
523 MotionEstContext
* const c
= &s
->me
;
524 int range
= c
->avctx
->me_range
>> (1 + !!(c
->flags
&FLAG_QPEL
));
525 int max_range
= MAX_MV
>> (1 + !!(c
->flags
&FLAG_QPEL
));
527 if(c->avctx->me_range) c->range= c->avctx->me_range >> 1;
530 if (s
->unrestricted_mv
) {
533 c
->xmax
= - x
+ s
->width
;
534 c
->ymax
= - y
+ s
->height
;
535 } else if (s
->out_format
== FMT_H261
){
536 // Search range of H261 is different from other codec standards
537 c
->xmin
= (x
> 15) ? - 15 : 0;
538 c
->ymin
= (y
> 15) ? - 15 : 0;
539 c
->xmax
= (x
< s
->mb_width
* 16 - 16) ? 15 : 0;
540 c
->ymax
= (y
< s
->mb_height
* 16 - 16) ? 15 : 0;
544 c
->xmax
= - x
+ s
->mb_width
*16 - 16;
545 c
->ymax
= - y
+ s
->mb_height
*16 - 16;
547 if(!range
|| range
> max_range
)
550 c
->xmin
= FFMAX(c
->xmin
,-range
);
551 c
->xmax
= FFMIN(c
->xmax
, range
);
552 c
->ymin
= FFMAX(c
->ymin
,-range
);
553 c
->ymax
= FFMIN(c
->ymax
, range
);
557 static inline void init_mv4_ref(MotionEstContext
*c
){
558 const int stride
= c
->stride
;
560 c
->ref
[1][0] = c
->ref
[0][0] + 8;
561 c
->ref
[2][0] = c
->ref
[0][0] + 8*stride
;
562 c
->ref
[3][0] = c
->ref
[2][0] + 8;
563 c
->src
[1][0] = c
->src
[0][0] + 8;
564 c
->src
[2][0] = c
->src
[0][0] + 8*stride
;
565 c
->src
[3][0] = c
->src
[2][0] + 8;
568 static inline int h263_mv4_search(MpegEncContext
*s
, int mx
, int my
, int shift
)
570 MotionEstContext
* const c
= &s
->me
;
575 int dmin_sum
=0, mx4_sum
=0, my4_sum
=0, i
;
577 const int stride
= c
->stride
;
578 uint8_t *mv_penalty
= c
->current_mv_penalty
;
579 int saftey_cliping
= s
->unrestricted_mv
&& (s
->width
&15) && (s
->height
&15);
583 for(block
=0; block
<4; block
++){
585 int pred_x4
, pred_y4
;
587 static const int off
[4]= {2, 1, 1, -1};
588 const int mot_stride
= s
->b8_stride
;
589 const int mot_xy
= s
->block_index
[block
];
592 c
->xmax
= - 16*s
->mb_x
+ s
->width
- 8*(block
&1);
593 c
->ymax
= - 16*s
->mb_y
+ s
->height
- 8*(block
>>1);
596 P_LEFT
[0] = s
->current_picture
.motion_val
[0][mot_xy
- 1][0];
597 P_LEFT
[1] = s
->current_picture
.motion_val
[0][mot_xy
- 1][1];
599 if(P_LEFT
[0] > (c
->xmax
<<shift
)) P_LEFT
[0] = (c
->xmax
<<shift
);
601 /* special case for first line */
602 if (s
->first_slice_line
&& block
<2) {
603 c
->pred_x
= pred_x4
= P_LEFT
[0];
604 c
->pred_y
= pred_y4
= P_LEFT
[1];
606 P_TOP
[0] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
][0];
607 P_TOP
[1] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
][1];
608 P_TOPRIGHT
[0] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
+ off
[block
]][0];
609 P_TOPRIGHT
[1] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
+ off
[block
]][1];
610 if(P_TOP
[1] > (c
->ymax
<<shift
)) P_TOP
[1] = (c
->ymax
<<shift
);
611 if(P_TOPRIGHT
[0] < (c
->xmin
<<shift
)) P_TOPRIGHT
[0]= (c
->xmin
<<shift
);
612 if(P_TOPRIGHT
[0] > (c
->xmax
<<shift
)) P_TOPRIGHT
[0]= (c
->xmax
<<shift
);
613 if(P_TOPRIGHT
[1] > (c
->ymax
<<shift
)) P_TOPRIGHT
[1]= (c
->ymax
<<shift
);
615 P_MEDIAN
[0]= mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
616 P_MEDIAN
[1]= mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
618 c
->pred_x
= pred_x4
= P_MEDIAN
[0];
619 c
->pred_y
= pred_y4
= P_MEDIAN
[1];
625 if (s
->first_slice_line
&& block
<2 && i
>1 && i
<9)
629 if(P
[i
][0] > (c
->xmax
<<shift
)) P
[i
][0]= (c
->xmax
<<shift
);
630 if(P
[i
][1] > (c
->ymax
<<shift
)) P
[i
][1]= (c
->ymax
<<shift
);
633 dmin4
= epzs_motion_search4(s
, &mx4
, &my4
, P
, block
, block
, s
->p_mv_table
, (1<<16)>>shift
);
635 dmin4
= c
->sub_motion_search(s
, &mx4
, &my4
, dmin4
, block
, block
, size
, h
);
637 if (s
->mecc
.me_sub_cmp
[0] != s
->mecc
.mb_cmp
[0]) {
639 const int offset
= ((block
&1) + (block
>>1)*stride
)*8;
640 uint8_t *dest_y
= c
->scratchpad
+ offset
;
641 if(s
->quarter_sample
){
642 uint8_t *ref
= c
->ref
[block
][0] + (mx4
>>2) + (my4
>>2)*stride
;
643 dxy
= ((my4
& 3) << 2) | (mx4
& 3);
646 s
->qdsp
.put_no_rnd_qpel_pixels_tab
[1][dxy
](dest_y
, ref
, stride
);
648 s
->qdsp
.put_qpel_pixels_tab
[1][dxy
](dest_y
, ref
, stride
);
650 uint8_t *ref
= c
->ref
[block
][0] + (mx4
>>1) + (my4
>>1)*stride
;
651 dxy
= ((my4
& 1) << 1) | (mx4
& 1);
654 s
->hdsp
.put_no_rnd_pixels_tab
[1][dxy
](dest_y
, ref
, stride
, h
);
656 s
->hdsp
.put_pixels_tab
[1][dxy
](dest_y
, ref
, stride
, h
);
658 dmin_sum
+= (mv_penalty
[mx4
-pred_x4
] + mv_penalty
[my4
-pred_y4
])*c
->mb_penalty_factor
;
662 if(s
->quarter_sample
){
670 s
->current_picture
.motion_val
[0][s
->block_index
[block
]][0] = mx4
;
671 s
->current_picture
.motion_val
[0][s
->block_index
[block
]][1] = my4
;
673 if(mx4
!= mx
|| my4
!= my
) same
=0;
679 if (s
->mecc
.me_sub_cmp
[0] != s
->mecc
.mb_cmp
[0]) {
680 dmin_sum
+= s
->mecc
.mb_cmp
[0](s
,
681 s
->new_picture
.f
->data
[0] +
682 s
->mb_x
* 16 + s
->mb_y
* 16 * stride
,
683 c
->scratchpad
, stride
, 16);
686 if(c
->avctx
->mb_cmp
&FF_CMP_CHROMA
){
691 mx
= ff_h263_round_chroma(mx4_sum
);
692 my
= ff_h263_round_chroma(my4_sum
);
693 dxy
= ((my
& 1) << 1) | (mx
& 1);
695 offset
= (s
->mb_x
*8 + (mx
>>1)) + (s
->mb_y
*8 + (my
>>1))*s
->uvlinesize
;
698 s
->hdsp
.put_no_rnd_pixels_tab
[1][dxy
](c
->scratchpad
, s
->last_picture
.f
->data
[1] + offset
, s
->uvlinesize
, 8);
699 s
->hdsp
.put_no_rnd_pixels_tab
[1][dxy
](c
->scratchpad
+ 8, s
->last_picture
.f
->data
[2] + offset
, s
->uvlinesize
, 8);
701 s
->hdsp
.put_pixels_tab
[1][dxy
](c
->scratchpad
, s
->last_picture
.f
->data
[1] + offset
, s
->uvlinesize
, 8);
702 s
->hdsp
.put_pixels_tab
[1][dxy
](c
->scratchpad
+ 8, s
->last_picture
.f
->data
[2] + offset
, s
->uvlinesize
, 8);
705 dmin_sum
+= s
->mecc
.mb_cmp
[1](s
, s
->new_picture
.f
->data
[1] + s
->mb_x
* 8 + s
->mb_y
* 8 * s
->uvlinesize
, c
->scratchpad
, s
->uvlinesize
, 8);
706 dmin_sum
+= s
->mecc
.mb_cmp
[1](s
, s
->new_picture
.f
->data
[2] + s
->mb_x
* 8 + s
->mb_y
* 8 * s
->uvlinesize
, c
->scratchpad
+ 8, s
->uvlinesize
, 8);
712 switch(c
->avctx
->mb_cmp
&0xFF){
714 return dmin_sum+ 32*s->qscale*s->qscale;*/
718 return dmin_sum
+ 11*c
->mb_penalty_factor
;
722 static inline void init_interlaced_ref(MpegEncContext
*s
, int ref_index
){
723 MotionEstContext
* const c
= &s
->me
;
725 c
->ref
[1+ref_index
][0] = c
->ref
[0+ref_index
][0] + s
->linesize
;
726 c
->src
[1][0] = c
->src
[0][0] + s
->linesize
;
727 if(c
->flags
& FLAG_CHROMA
){
728 c
->ref
[1+ref_index
][1] = c
->ref
[0+ref_index
][1] + s
->uvlinesize
;
729 c
->ref
[1+ref_index
][2] = c
->ref
[0+ref_index
][2] + s
->uvlinesize
;
730 c
->src
[1][1] = c
->src
[0][1] + s
->uvlinesize
;
731 c
->src
[1][2] = c
->src
[0][2] + s
->uvlinesize
;
735 static int interlaced_search(MpegEncContext
*s
, int ref_index
,
736 int16_t (*mv_tables
[2][2])[2], uint8_t *field_select_tables
[2], int mx
, int my
, int user_field_select
)
738 MotionEstContext
* const c
= &s
->me
;
743 uint8_t * const mv_penalty
= c
->current_mv_penalty
;
745 const int stride
= 2*s
->linesize
;
747 const int mot_stride
= s
->mb_stride
;
748 const int xy
= s
->mb_x
+ s
->mb_y
*mot_stride
;
754 init_interlaced_ref(s
, ref_index
);
756 for(block
=0; block
<2; block
++){
758 int best_dmin
= INT_MAX
;
761 for(field_select
=0; field_select
<2; field_select
++){
762 int dmin
, mx_i
, my_i
;
763 int16_t (*mv_table
)[2]= mv_tables
[block
][field_select
];
765 if(user_field_select
){
766 av_assert1(field_select
==0 || field_select
==1);
767 av_assert1(field_select_tables
[block
][xy
]==0 || field_select_tables
[block
][xy
]==1);
768 if(field_select_tables
[block
][xy
] != field_select
)
772 P_LEFT
[0] = mv_table
[xy
- 1][0];
773 P_LEFT
[1] = mv_table
[xy
- 1][1];
774 if(P_LEFT
[0] > (c
->xmax
<<1)) P_LEFT
[0] = (c
->xmax
<<1);
776 c
->pred_x
= P_LEFT
[0];
777 c
->pred_y
= P_LEFT
[1];
779 if(!s
->first_slice_line
){
780 P_TOP
[0] = mv_table
[xy
- mot_stride
][0];
781 P_TOP
[1] = mv_table
[xy
- mot_stride
][1];
782 P_TOPRIGHT
[0] = mv_table
[xy
- mot_stride
+ 1][0];
783 P_TOPRIGHT
[1] = mv_table
[xy
- mot_stride
+ 1][1];
784 if(P_TOP
[1] > (c
->ymax
<<1)) P_TOP
[1] = (c
->ymax
<<1);
785 if(P_TOPRIGHT
[0] < (c
->xmin
<<1)) P_TOPRIGHT
[0]= (c
->xmin
<<1);
786 if(P_TOPRIGHT
[0] > (c
->xmax
<<1)) P_TOPRIGHT
[0]= (c
->xmax
<<1);
787 if(P_TOPRIGHT
[1] > (c
->ymax
<<1)) P_TOPRIGHT
[1]= (c
->ymax
<<1);
789 P_MEDIAN
[0]= mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
790 P_MEDIAN
[1]= mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
792 P_MV1
[0]= mx
; //FIXME not correct if block != field_select
795 dmin
= epzs_motion_search2(s
, &mx_i
, &my_i
, P
, block
, field_select
+ref_index
, mv_table
, (1<<16)>>1);
797 dmin
= c
->sub_motion_search(s
, &mx_i
, &my_i
, dmin
, block
, field_select
+ref_index
, size
, h
);
799 mv_table
[xy
][0]= mx_i
;
800 mv_table
[xy
][1]= my_i
;
802 if (s
->mecc
.me_sub_cmp
[0] != s
->mecc
.mb_cmp
[0]) {
806 uint8_t *ref
= c
->ref
[field_select
+ref_index
][0] + (mx_i
>>1) + (my_i
>>1)*stride
;
807 dxy
= ((my_i
& 1) << 1) | (mx_i
& 1);
810 s
->hdsp
.put_no_rnd_pixels_tab
[size
][dxy
](c
->scratchpad
, ref
, stride
, h
);
812 s
->hdsp
.put_pixels_tab
[size
][dxy
](c
->scratchpad
, ref
, stride
, h
);
814 dmin
= s
->mecc
.mb_cmp
[size
](s
, c
->src
[block
][0], c
->scratchpad
, stride
, h
);
815 dmin
+= (mv_penalty
[mx_i
-c
->pred_x
] + mv_penalty
[my_i
-c
->pred_y
] + 1)*c
->mb_penalty_factor
;
817 dmin
+= c
->mb_penalty_factor
; //field_select bits
819 dmin
+= field_select
!= block
; //slightly prefer same field
821 if(dmin
< best_dmin
){
823 best_field
= field_select
;
827 int16_t (*mv_table
)[2]= mv_tables
[block
][best_field
];
829 if(mv_table
[xy
][0] != mx
) same
=0; //FIXME check if these checks work and are any good at all
830 if(mv_table
[xy
][1]&1) same
=0;
831 if(mv_table
[xy
][1]*2 != my
) same
=0;
832 if(best_field
!= block
) same
=0;
835 field_select_tables
[block
][xy
]= best_field
;
836 dmin_sum
+= best_dmin
;
847 switch(c
->avctx
->mb_cmp
&0xFF){
849 return dmin_sum+ 32*s->qscale*s->qscale;*/
853 return dmin_sum
+ 11*c
->mb_penalty_factor
;
857 static inline int get_penalty_factor(int lambda
, int lambda2
, int type
){
861 return lambda
>>FF_LAMBDA_SHIFT
;
863 return (3*lambda
)>>(FF_LAMBDA_SHIFT
+1);
865 return (4*lambda
)>>(FF_LAMBDA_SHIFT
);
867 return (2*lambda
)>>(FF_LAMBDA_SHIFT
);
870 return (2*lambda
)>>FF_LAMBDA_SHIFT
;
875 return lambda2
>>FF_LAMBDA_SHIFT
;
881 void ff_estimate_p_frame_motion(MpegEncContext
* s
,
884 MotionEstContext
* const c
= &s
->me
;
886 int sum
, mx
, my
, dmin
;
887 int varc
; ///< the variance of the block (sum of squared (p[y][x]-average))
888 int vard
; ///< sum of squared differences with the estimated motion vector
890 const int shift
= 1+s
->quarter_sample
;
892 Picture
* const pic
= &s
->current_picture
;
894 init_ref(c
, s
->new_picture
.f
->data
, s
->last_picture
.f
->data
, NULL
, 16*mb_x
, 16*mb_y
, 0);
896 av_assert0(s
->quarter_sample
==0 || s
->quarter_sample
==1);
897 av_assert0(s
->linesize
== c
->stride
);
898 av_assert0(s
->uvlinesize
== c
->uvstride
);
900 c
->penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->me_cmp
);
901 c
->sub_penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->me_sub_cmp
);
902 c
->mb_penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->mb_cmp
);
903 c
->current_mv_penalty
= c
->mv_penalty
[s
->f_code
] + MAX_MV
;
905 get_limits(s
, 16*mb_x
, 16*mb_y
);
908 /* intra / predictive decision */
910 sum
= s
->mpvencdsp
.pix_sum(pix
, s
->linesize
);
911 varc
= s
->mpvencdsp
.pix_norm1(pix
, s
->linesize
) -
912 (((unsigned) sum
* sum
) >> 8) + 500;
914 pic
->mb_mean
[s
->mb_stride
* mb_y
+ mb_x
] = (sum
+128)>>8;
915 pic
->mb_var
[s
->mb_stride
* mb_y
+ mb_x
] = (varc
+128)>>8;
916 c
->mb_var_sum_temp
+= (varc
+128)>>8;
918 switch(s
->me_method
) {
928 const int mot_stride
= s
->b8_stride
;
929 const int mot_xy
= s
->block_index
[0];
931 P_LEFT
[0] = s
->current_picture
.motion_val
[0][mot_xy
- 1][0];
932 P_LEFT
[1] = s
->current_picture
.motion_val
[0][mot_xy
- 1][1];
934 if(P_LEFT
[0] > (c
->xmax
<<shift
)) P_LEFT
[0] = (c
->xmax
<<shift
);
936 if(!s
->first_slice_line
) {
937 P_TOP
[0] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
][0];
938 P_TOP
[1] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
][1];
939 P_TOPRIGHT
[0] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
+ 2][0];
940 P_TOPRIGHT
[1] = s
->current_picture
.motion_val
[0][mot_xy
- mot_stride
+ 2][1];
941 if(P_TOP
[1] > (c
->ymax
<<shift
)) P_TOP
[1] = (c
->ymax
<<shift
);
942 if(P_TOPRIGHT
[0] < (c
->xmin
<<shift
)) P_TOPRIGHT
[0]= (c
->xmin
<<shift
);
943 if(P_TOPRIGHT
[1] > (c
->ymax
<<shift
)) P_TOPRIGHT
[1]= (c
->ymax
<<shift
);
945 P_MEDIAN
[0]= mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
946 P_MEDIAN
[1]= mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
948 if(s
->out_format
== FMT_H263
){
949 c
->pred_x
= P_MEDIAN
[0];
950 c
->pred_y
= P_MEDIAN
[1];
951 }else { /* mpeg1 at least */
952 c
->pred_x
= P_LEFT
[0];
953 c
->pred_y
= P_LEFT
[1];
956 c
->pred_x
= P_LEFT
[0];
957 c
->pred_y
= P_LEFT
[1];
961 dmin
= ff_epzs_motion_search(s
, &mx
, &my
, P
, 0, 0, s
->p_mv_table
, (1<<16)>>shift
, 0, 16);
966 /* At this point (mx,my) are full-pell and the relative displacement */
967 ppix
= c
->ref
[0][0] + (my
* s
->linesize
) + mx
;
969 vard
= s
->mecc
.sse
[0](NULL
, pix
, ppix
, s
->linesize
, 16);
971 pic
->mc_mb_var
[s
->mb_stride
* mb_y
+ mb_x
] = (vard
+128)>>8;
972 c
->mc_mb_var_sum_temp
+= (vard
+128)>>8;
975 int p_score
= FFMIN(vard
, varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*100);
976 int i_score
= varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*20;
977 c
->scene_change_score
+= ff_sqrt(p_score
) - ff_sqrt(i_score
);
979 if(mb_type
== CANDIDATE_MB_TYPE_INTER
){
980 c
->sub_motion_search(s
, &mx
, &my
, dmin
, 0, 0, 0, 16);
981 set_p_mv_tables(s
, mx
, my
, 1);
986 if(mb_type
== CANDIDATE_MB_TYPE_INTER4V
){
987 h263_mv4_search(s
, mx
, my
, shift
);
989 set_p_mv_tables(s
, mx
, my
, 0);
991 if(mb_type
== CANDIDATE_MB_TYPE_INTER_I
){
992 interlaced_search(s
, 0, s
->p_field_mv_table
, s
->p_field_select_table
, mx
, my
, 1);
994 }else if(c
->avctx
->mb_decision
> FF_MB_DECISION_SIMPLE
){
995 int p_score
= FFMIN(vard
, varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*100);
996 int i_score
= varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*20;
997 c
->scene_change_score
+= ff_sqrt(p_score
) - ff_sqrt(i_score
);
999 if (vard
*2 + 200*256 > varc
)
1000 mb_type
|= CANDIDATE_MB_TYPE_INTRA
;
1001 if (varc
*2 + 200*256 > vard
|| s
->qscale
> 24){
1002 // if (varc*2 + 200*256 + 50*(s->lambda2>>FF_LAMBDA_SHIFT) > vard){
1003 mb_type
|= CANDIDATE_MB_TYPE_INTER
;
1004 c
->sub_motion_search(s
, &mx
, &my
, dmin
, 0, 0, 0, 16);
1005 if (s
->mpv_flags
& FF_MPV_FLAG_MV0
)
1007 mb_type
|= CANDIDATE_MB_TYPE_SKIPPED
; //FIXME check difference
1012 if((s
->flags
&CODEC_FLAG_4MV
)
1013 && !c
->skip
&& varc
>50<<8 && vard
>10<<8){
1014 if(h263_mv4_search(s
, mx
, my
, shift
) < INT_MAX
)
1015 mb_type
|=CANDIDATE_MB_TYPE_INTER4V
;
1017 set_p_mv_tables(s
, mx
, my
, 0);
1019 set_p_mv_tables(s
, mx
, my
, 1);
1020 if((s
->flags
&CODEC_FLAG_INTERLACED_ME
)
1021 && !c
->skip
){ //FIXME varc/d checks
1022 if(interlaced_search(s
, 0, s
->p_field_mv_table
, s
->p_field_select_table
, mx
, my
, 0) < INT_MAX
)
1023 mb_type
|= CANDIDATE_MB_TYPE_INTER_I
;
1027 mb_type
= CANDIDATE_MB_TYPE_INTER
;
1029 dmin
= c
->sub_motion_search(s
, &mx
, &my
, dmin
, 0, 0, 0, 16);
1030 if(c
->avctx
->me_sub_cmp
!= c
->avctx
->mb_cmp
&& !c
->skip
)
1031 dmin
= get_mb_score(s
, mx
, my
, 0, 0, 0, 16, 1);
1033 if((s
->flags
&CODEC_FLAG_4MV
)
1034 && !c
->skip
&& varc
>50<<8 && vard
>10<<8){
1035 int dmin4
= h263_mv4_search(s
, mx
, my
, shift
);
1037 mb_type
= CANDIDATE_MB_TYPE_INTER4V
;
1041 if((s
->flags
&CODEC_FLAG_INTERLACED_ME
)
1042 && !c
->skip
){ //FIXME varc/d checks
1043 int dmin_i
= interlaced_search(s
, 0, s
->p_field_mv_table
, s
->p_field_select_table
, mx
, my
, 0);
1045 mb_type
= CANDIDATE_MB_TYPE_INTER_I
;
1050 set_p_mv_tables(s
, mx
, my
, mb_type
!=CANDIDATE_MB_TYPE_INTER4V
);
1052 /* get intra luma score */
1053 if((c
->avctx
->mb_cmp
&0xFF)==FF_CMP_SSE
){
1054 intra_score
= varc
- 500;
1056 unsigned mean
= (sum
+128)>>8;
1059 for(i
=0; i
<16; i
++){
1060 *(uint32_t*)(&c
->scratchpad
[i
*s
->linesize
+ 0]) = mean
;
1061 *(uint32_t*)(&c
->scratchpad
[i
*s
->linesize
+ 4]) = mean
;
1062 *(uint32_t*)(&c
->scratchpad
[i
*s
->linesize
+ 8]) = mean
;
1063 *(uint32_t*)(&c
->scratchpad
[i
*s
->linesize
+12]) = mean
;
1066 intra_score
= s
->mecc
.mb_cmp
[0](s
, c
->scratchpad
, pix
, s
->linesize
, 16);
1068 intra_score
+= c
->mb_penalty_factor
*16;
1070 if(intra_score
< dmin
){
1071 mb_type
= CANDIDATE_MB_TYPE_INTRA
;
1072 s
->current_picture
.mb_type
[mb_y
*s
->mb_stride
+ mb_x
] = CANDIDATE_MB_TYPE_INTRA
; //FIXME cleanup
1074 s
->current_picture
.mb_type
[mb_y
*s
->mb_stride
+ mb_x
] = 0;
1077 int p_score
= FFMIN(vard
, varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*100);
1078 int i_score
= varc
-500+(s
->lambda2
>>FF_LAMBDA_SHIFT
)*20;
1079 c
->scene_change_score
+= ff_sqrt(p_score
) - ff_sqrt(i_score
);
1083 s
->mb_type
[mb_y
*s
->mb_stride
+ mb_x
]= mb_type
;
1086 int ff_pre_estimate_p_frame_motion(MpegEncContext
* s
,
1089 MotionEstContext
* const c
= &s
->me
;
1092 const int shift
= 1+s
->quarter_sample
;
1093 const int xy
= mb_x
+ mb_y
*s
->mb_stride
;
1094 init_ref(c
, s
->new_picture
.f
->data
, s
->last_picture
.f
->data
, NULL
, 16*mb_x
, 16*mb_y
, 0);
1096 av_assert0(s
->quarter_sample
==0 || s
->quarter_sample
==1);
1098 c
->pre_penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->me_pre_cmp
);
1099 c
->current_mv_penalty
= c
->mv_penalty
[s
->f_code
] + MAX_MV
;
1101 get_limits(s
, 16*mb_x
, 16*mb_y
);
1104 P_LEFT
[0] = s
->p_mv_table
[xy
+ 1][0];
1105 P_LEFT
[1] = s
->p_mv_table
[xy
+ 1][1];
1107 if(P_LEFT
[0] < (c
->xmin
<<shift
)) P_LEFT
[0] = (c
->xmin
<<shift
);
1109 /* special case for first line */
1110 if (s
->first_slice_line
) {
1111 c
->pred_x
= P_LEFT
[0];
1112 c
->pred_y
= P_LEFT
[1];
1113 P_TOP
[0]= P_TOPRIGHT
[0]= P_MEDIAN
[0]=
1114 P_TOP
[1]= P_TOPRIGHT
[1]= P_MEDIAN
[1]= 0; //FIXME
1116 P_TOP
[0] = s
->p_mv_table
[xy
+ s
->mb_stride
][0];
1117 P_TOP
[1] = s
->p_mv_table
[xy
+ s
->mb_stride
][1];
1118 P_TOPRIGHT
[0] = s
->p_mv_table
[xy
+ s
->mb_stride
- 1][0];
1119 P_TOPRIGHT
[1] = s
->p_mv_table
[xy
+ s
->mb_stride
- 1][1];
1120 if(P_TOP
[1] < (c
->ymin
<<shift
)) P_TOP
[1] = (c
->ymin
<<shift
);
1121 if(P_TOPRIGHT
[0] > (c
->xmax
<<shift
)) P_TOPRIGHT
[0]= (c
->xmax
<<shift
);
1122 if(P_TOPRIGHT
[1] < (c
->ymin
<<shift
)) P_TOPRIGHT
[1]= (c
->ymin
<<shift
);
1124 P_MEDIAN
[0]= mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
1125 P_MEDIAN
[1]= mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
1127 c
->pred_x
= P_MEDIAN
[0];
1128 c
->pred_y
= P_MEDIAN
[1];
1131 dmin
= ff_epzs_motion_search(s
, &mx
, &my
, P
, 0, 0, s
->p_mv_table
, (1<<16)>>shift
, 0, 16);
1133 s
->p_mv_table
[xy
][0] = mx
<<shift
;
1134 s
->p_mv_table
[xy
][1] = my
<<shift
;
1139 static int estimate_motion_b(MpegEncContext
*s
, int mb_x
, int mb_y
,
1140 int16_t (*mv_table
)[2], int ref_index
, int f_code
)
1142 MotionEstContext
* const c
= &s
->me
;
1145 const int shift
= 1+s
->quarter_sample
;
1146 const int mot_stride
= s
->mb_stride
;
1147 const int mot_xy
= mb_y
*mot_stride
+ mb_x
;
1148 uint8_t * const mv_penalty
= c
->mv_penalty
[f_code
] + MAX_MV
;
1151 c
->penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->me_cmp
);
1152 c
->sub_penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->me_sub_cmp
);
1153 c
->mb_penalty_factor
= get_penalty_factor(s
->lambda
, s
->lambda2
, c
->avctx
->mb_cmp
);
1154 c
->current_mv_penalty
= mv_penalty
;
1156 get_limits(s
, 16*mb_x
, 16*mb_y
);
1158 switch(s
->me_method
) {
1167 P_LEFT
[0] = mv_table
[mot_xy
- 1][0];
1168 P_LEFT
[1] = mv_table
[mot_xy
- 1][1];
1170 if (P_LEFT
[0] > (c
->xmax
<< shift
)) P_LEFT
[0] = (c
->xmax
<< shift
);
1172 /* special case for first line */
1173 if (!s
->first_slice_line
) {
1174 P_TOP
[0] = mv_table
[mot_xy
- mot_stride
][0];
1175 P_TOP
[1] = mv_table
[mot_xy
- mot_stride
][1];
1176 P_TOPRIGHT
[0] = mv_table
[mot_xy
- mot_stride
+ 1][0];
1177 P_TOPRIGHT
[1] = mv_table
[mot_xy
- mot_stride
+ 1][1];
1178 if (P_TOP
[1] > (c
->ymax
<< shift
)) P_TOP
[1] = (c
->ymax
<< shift
);
1179 if (P_TOPRIGHT
[0] < (c
->xmin
<< shift
)) P_TOPRIGHT
[0] = (c
->xmin
<< shift
);
1180 if (P_TOPRIGHT
[1] > (c
->ymax
<< shift
)) P_TOPRIGHT
[1] = (c
->ymax
<< shift
);
1182 P_MEDIAN
[0] = mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
1183 P_MEDIAN
[1] = mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
1185 c
->pred_x
= P_LEFT
[0];
1186 c
->pred_y
= P_LEFT
[1];
1188 if(mv_table
== s
->b_forw_mv_table
){
1189 mv_scale
= (s
->pb_time
<<16) / (s
->pp_time
<<shift
);
1191 mv_scale
= ((s
->pb_time
- s
->pp_time
)<<16) / (s
->pp_time
<<shift
);
1194 dmin
= ff_epzs_motion_search(s
, &mx
, &my
, P
, 0, ref_index
, s
->p_mv_table
, mv_scale
, 0, 16);
1199 dmin
= c
->sub_motion_search(s
, &mx
, &my
, dmin
, 0, ref_index
, 0, 16);
1201 if(c
->avctx
->me_sub_cmp
!= c
->avctx
->mb_cmp
&& !c
->skip
)
1202 dmin
= get_mb_score(s
, mx
, my
, 0, ref_index
, 0, 16, 1);
1204 // s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
1205 mv_table
[mot_xy
][0]= mx
;
1206 mv_table
[mot_xy
][1]= my
;
1211 static inline int check_bidir_mv(MpegEncContext
* s
,
1212 int motion_fx
, int motion_fy
,
1213 int motion_bx
, int motion_by
,
1214 int pred_fx
, int pred_fy
,
1215 int pred_bx
, int pred_by
,
1219 //FIXME better f_code prediction (max mv & distance)
1221 MotionEstContext
* const c
= &s
->me
;
1222 uint8_t * const mv_penalty_f
= c
->mv_penalty
[s
->f_code
] + MAX_MV
; // f_code of the prev frame
1223 uint8_t * const mv_penalty_b
= c
->mv_penalty
[s
->b_code
] + MAX_MV
; // f_code of the prev frame
1224 int stride
= c
->stride
;
1225 uint8_t *dest_y
= c
->scratchpad
;
1230 uint8_t **src_data
= c
->src
[0];
1231 uint8_t **ref_data
= c
->ref
[0];
1232 uint8_t **ref2_data
= c
->ref
[2];
1234 if(s
->quarter_sample
){
1235 dxy
= ((motion_fy
& 3) << 2) | (motion_fx
& 3);
1236 src_x
= motion_fx
>> 2;
1237 src_y
= motion_fy
>> 2;
1239 ptr
= ref_data
[0] + (src_y
* stride
) + src_x
;
1240 s
->qdsp
.put_qpel_pixels_tab
[0][dxy
](dest_y
, ptr
, stride
);
1242 dxy
= ((motion_by
& 3) << 2) | (motion_bx
& 3);
1243 src_x
= motion_bx
>> 2;
1244 src_y
= motion_by
>> 2;
1246 ptr
= ref2_data
[0] + (src_y
* stride
) + src_x
;
1247 s
->qdsp
.avg_qpel_pixels_tab
[size
][dxy
](dest_y
, ptr
, stride
);
1249 dxy
= ((motion_fy
& 1) << 1) | (motion_fx
& 1);
1250 src_x
= motion_fx
>> 1;
1251 src_y
= motion_fy
>> 1;
1253 ptr
= ref_data
[0] + (src_y
* stride
) + src_x
;
1254 s
->hdsp
.put_pixels_tab
[size
][dxy
](dest_y
, ptr
, stride
, h
);
1256 dxy
= ((motion_by
& 1) << 1) | (motion_bx
& 1);
1257 src_x
= motion_bx
>> 1;
1258 src_y
= motion_by
>> 1;
1260 ptr
= ref2_data
[0] + (src_y
* stride
) + src_x
;
1261 s
->hdsp
.avg_pixels_tab
[size
][dxy
](dest_y
, ptr
, stride
, h
);
1264 fbmin
= (mv_penalty_f
[motion_fx
-pred_fx
] + mv_penalty_f
[motion_fy
-pred_fy
])*c
->mb_penalty_factor
1265 +(mv_penalty_b
[motion_bx
-pred_bx
] + mv_penalty_b
[motion_by
-pred_by
])*c
->mb_penalty_factor
1266 + s
->mecc
.mb_cmp
[size
](s
, src_data
[0], dest_y
, stride
, h
); // FIXME new_pic
1268 if(c
->avctx
->mb_cmp
&FF_CMP_CHROMA
){
1275 /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/
1276 static inline int bidir_refine(MpegEncContext
* s
, int mb_x
, int mb_y
)
1278 MotionEstContext
* const c
= &s
->me
;
1279 const int mot_stride
= s
->mb_stride
;
1280 const int xy
= mb_y
*mot_stride
+ mb_x
;
1282 int pred_fx
= s
->b_bidir_forw_mv_table
[xy
-1][0];
1283 int pred_fy
= s
->b_bidir_forw_mv_table
[xy
-1][1];
1284 int pred_bx
= s
->b_bidir_back_mv_table
[xy
-1][0];
1285 int pred_by
= s
->b_bidir_back_mv_table
[xy
-1][1];
1286 int motion_fx
= s
->b_bidir_forw_mv_table
[xy
][0]= s
->b_forw_mv_table
[xy
][0];
1287 int motion_fy
= s
->b_bidir_forw_mv_table
[xy
][1]= s
->b_forw_mv_table
[xy
][1];
1288 int motion_bx
= s
->b_bidir_back_mv_table
[xy
][0]= s
->b_back_mv_table
[xy
][0];
1289 int motion_by
= s
->b_bidir_back_mv_table
[xy
][1]= s
->b_back_mv_table
[xy
][1];
1290 const int flags
= c
->sub_flags
;
1291 const int qpel
= flags
&FLAG_QPEL
;
1292 const int shift
= 1+qpel
;
1293 const int xmin
= c
->xmin
<<shift
;
1294 const int ymin
= c
->ymin
<<shift
;
1295 const int xmax
= c
->xmax
<<shift
;
1296 const int ymax
= c
->ymax
<<shift
;
1297 #define HASH(fx,fy,bx,by) ((fx)+17*(fy)+63*(bx)+117*(by))
1298 #define HASH8(fx,fy,bx,by) ((uint8_t)HASH(fx,fy,bx,by))
1299 int hashidx
= HASH(motion_fx
,motion_fy
, motion_bx
, motion_by
);
1300 uint8_t map
[256] = { 0 };
1302 map
[hashidx
&255] = 1;
1304 fbmin
= check_bidir_mv(s
, motion_fx
, motion_fy
,
1305 motion_bx
, motion_by
,
1310 if(s
->avctx
->bidir_refine
){
1312 static const uint8_t limittab
[5]={0,8,32,64,80};
1313 const int limit
= limittab
[s
->avctx
->bidir_refine
];
1314 static const int8_t vect
[][4]={
1315 { 0, 0, 0, 1}, { 0, 0, 0,-1}, { 0, 0, 1, 0}, { 0, 0,-1, 0}, { 0, 1, 0, 0}, { 0,-1, 0, 0}, { 1, 0, 0, 0}, {-1, 0, 0, 0},
1317 { 0, 0, 1, 1}, { 0, 0,-1,-1}, { 0, 1, 1, 0}, { 0,-1,-1, 0}, { 1, 1, 0, 0}, {-1,-1, 0, 0}, { 1, 0, 0, 1}, {-1, 0, 0,-1},
1318 { 0, 1, 0, 1}, { 0,-1, 0,-1}, { 1, 0, 1, 0}, {-1, 0,-1, 0},
1319 { 0, 0,-1, 1}, { 0, 0, 1,-1}, { 0,-1, 1, 0}, { 0, 1,-1, 0}, {-1, 1, 0, 0}, { 1,-1, 0, 0}, { 1, 0, 0,-1}, {-1, 0, 0, 1},
1320 { 0,-1, 0, 1}, { 0, 1, 0,-1}, {-1, 0, 1, 0}, { 1, 0,-1, 0},
1322 { 0, 1, 1, 1}, { 0,-1,-1,-1}, { 1, 1, 1, 0}, {-1,-1,-1, 0}, { 1, 1, 0, 1}, {-1,-1, 0,-1}, { 1, 0, 1, 1}, {-1, 0,-1,-1},
1323 { 0,-1, 1, 1}, { 0, 1,-1,-1}, {-1, 1, 1, 0}, { 1,-1,-1, 0}, { 1, 1, 0,-1}, {-1,-1, 0, 1}, { 1, 0,-1, 1}, {-1, 0, 1,-1},
1324 { 0, 1,-1, 1}, { 0,-1, 1,-1}, { 1,-1, 1, 0}, {-1, 1,-1, 0}, {-1, 1, 0, 1}, { 1,-1, 0,-1}, { 1, 0, 1,-1}, {-1, 0,-1, 1},
1325 { 0, 1, 1,-1}, { 0,-1,-1, 1}, { 1, 1,-1, 0}, {-1,-1, 1, 0}, { 1,-1, 0, 1}, {-1, 1, 0,-1}, {-1, 0, 1, 1}, { 1, 0,-1,-1},
1327 { 1, 1, 1, 1}, {-1,-1,-1,-1},
1328 { 1, 1, 1,-1}, {-1,-1,-1, 1}, { 1, 1,-1, 1}, {-1,-1, 1,-1}, { 1,-1, 1, 1}, {-1, 1,-1,-1}, {-1, 1, 1, 1}, { 1,-1,-1,-1},
1329 { 1, 1,-1,-1}, {-1,-1, 1, 1}, { 1,-1,-1, 1}, {-1, 1, 1,-1}, { 1,-1, 1,-1}, {-1, 1,-1, 1},
1331 static const uint8_t hash
[]={
1332 HASH8( 0, 0, 0, 1), HASH8( 0, 0, 0,-1), HASH8( 0, 0, 1, 0), HASH8( 0, 0,-1, 0), HASH8( 0, 1, 0, 0), HASH8( 0,-1, 0, 0), HASH8( 1, 0, 0, 0), HASH8(-1, 0, 0, 0),
1334 HASH8( 0, 0, 1, 1), HASH8( 0, 0,-1,-1), HASH8( 0, 1, 1, 0), HASH8( 0,-1,-1, 0), HASH8( 1, 1, 0, 0), HASH8(-1,-1, 0, 0), HASH8( 1, 0, 0, 1), HASH8(-1, 0, 0,-1),
1335 HASH8( 0, 1, 0, 1), HASH8( 0,-1, 0,-1), HASH8( 1, 0, 1, 0), HASH8(-1, 0,-1, 0),
1336 HASH8( 0, 0,-1, 1), HASH8( 0, 0, 1,-1), HASH8( 0,-1, 1, 0), HASH8( 0, 1,-1, 0), HASH8(-1, 1, 0, 0), HASH8( 1,-1, 0, 0), HASH8( 1, 0, 0,-1), HASH8(-1, 0, 0, 1),
1337 HASH8( 0,-1, 0, 1), HASH8( 0, 1, 0,-1), HASH8(-1, 0, 1, 0), HASH8( 1, 0,-1, 0),
1339 HASH8( 0, 1, 1, 1), HASH8( 0,-1,-1,-1), HASH8( 1, 1, 1, 0), HASH8(-1,-1,-1, 0), HASH8( 1, 1, 0, 1), HASH8(-1,-1, 0,-1), HASH8( 1, 0, 1, 1), HASH8(-1, 0,-1,-1),
1340 HASH8( 0,-1, 1, 1), HASH8( 0, 1,-1,-1), HASH8(-1, 1, 1, 0), HASH8( 1,-1,-1, 0), HASH8( 1, 1, 0,-1), HASH8(-1,-1, 0, 1), HASH8( 1, 0,-1, 1), HASH8(-1, 0, 1,-1),
1341 HASH8( 0, 1,-1, 1), HASH8( 0,-1, 1,-1), HASH8( 1,-1, 1, 0), HASH8(-1, 1,-1, 0), HASH8(-1, 1, 0, 1), HASH8( 1,-1, 0,-1), HASH8( 1, 0, 1,-1), HASH8(-1, 0,-1, 1),
1342 HASH8( 0, 1, 1,-1), HASH8( 0,-1,-1, 1), HASH8( 1, 1,-1, 0), HASH8(-1,-1, 1, 0), HASH8( 1,-1, 0, 1), HASH8(-1, 1, 0,-1), HASH8(-1, 0, 1, 1), HASH8( 1, 0,-1,-1),
1344 HASH8( 1, 1, 1, 1), HASH8(-1,-1,-1,-1),
1345 HASH8( 1, 1, 1,-1), HASH8(-1,-1,-1, 1), HASH8( 1, 1,-1, 1), HASH8(-1,-1, 1,-1), HASH8( 1,-1, 1, 1), HASH8(-1, 1,-1,-1), HASH8(-1, 1, 1, 1), HASH8( 1,-1,-1,-1),
1346 HASH8( 1, 1,-1,-1), HASH8(-1,-1, 1, 1), HASH8( 1,-1,-1, 1), HASH8(-1, 1, 1,-1), HASH8( 1,-1, 1,-1), HASH8(-1, 1,-1, 1),
1349 #define CHECK_BIDIR(fx,fy,bx,by)\
1350 if( !map[(hashidx+HASH(fx,fy,bx,by))&255]\
1351 &&(fx<=0 || motion_fx+fx<=xmax) && (fy<=0 || motion_fy+fy<=ymax) && (bx<=0 || motion_bx+bx<=xmax) && (by<=0 || motion_by+by<=ymax)\
1352 &&(fx>=0 || motion_fx+fx>=xmin) && (fy>=0 || motion_fy+fy>=ymin) && (bx>=0 || motion_bx+bx>=xmin) && (by>=0 || motion_by+by>=ymin)){\
1354 map[(hashidx+HASH(fx,fy,bx,by))&255] = 1;\
1355 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);\
1357 hashidx += HASH(fx,fy,bx,by);\
1366 #define CHECK_BIDIR2(a,b,c,d)\
1367 CHECK_BIDIR(a,b,c,d)\
1368 CHECK_BIDIR(-(a),-(b),-(c),-(d))
1375 CHECK_BIDIR2(0,0,0,1)
1376 CHECK_BIDIR2(0,0,1,0)
1377 CHECK_BIDIR2(0,1,0,0)
1378 CHECK_BIDIR2(1,0,0,0)
1380 for(i
=8; i
<limit
; i
++){
1381 int fx
= motion_fx
+vect
[i
][0];
1382 int fy
= motion_fy
+vect
[i
][1];
1383 int bx
= motion_bx
+vect
[i
][2];
1384 int by
= motion_by
+vect
[i
][3];
1386 int a
= (xmax
- FFMAX(fx
,bx
))|(FFMIN(fx
,bx
) - xmin
);
1387 int b
= (ymax
- FFMAX(fy
,by
))|(FFMIN(fy
,by
) - ymin
);
1389 map
[(hashidx
+hash
[i
])&255] = 1;
1391 if(!map
[(hashidx
+hash
[i
])&255]){
1393 map
[(hashidx
+hash
[i
])&255] = 1;
1394 score
= check_bidir_mv(s
, fx
, fy
, bx
, by
, pred_fx
, pred_fy
, pred_bx
, pred_by
, 0, 16);
1405 int a
= FFMIN(xmax
- FFMAX(fx
,bx
), FFMIN(fx
,bx
) - xmin
);
1406 int b
= FFMIN(ymax
- FFMAX(fy
,by
), FFMIN(fy
,by
) - ymin
);
1407 borderdist
= FFMIN(a
,b
);
1415 s
->b_bidir_forw_mv_table
[xy
][0]= motion_fx
;
1416 s
->b_bidir_forw_mv_table
[xy
][1]= motion_fy
;
1417 s
->b_bidir_back_mv_table
[xy
][0]= motion_bx
;
1418 s
->b_bidir_back_mv_table
[xy
][1]= motion_by
;
1423 static inline int direct_search(MpegEncContext
* s
, int mb_x
, int mb_y
)
1425 MotionEstContext
* const c
= &s
->me
;
1427 const int mot_stride
= s
->mb_stride
;
1428 const int mot_xy
= mb_y
*mot_stride
+ mb_x
;
1429 const int shift
= 1+s
->quarter_sample
;
1431 const int time_pp
= s
->pp_time
;
1432 const int time_pb
= s
->pb_time
;
1433 int mx
, my
, xmin
, xmax
, ymin
, ymax
;
1434 int16_t (*mv_table
)[2]= s
->b_direct_mv_table
;
1436 c
->current_mv_penalty
= c
->mv_penalty
[1] + MAX_MV
;
1437 ymin
= xmin
=(-32)>>shift
;
1438 ymax
= xmax
= 31>>shift
;
1440 if (IS_8X8(s
->next_picture
.mb_type
[mot_xy
])) {
1441 s
->mv_type
= MV_TYPE_8X8
;
1443 s
->mv_type
= MV_TYPE_16X16
;
1447 int index
= s
->block_index
[i
];
1450 c
->co_located_mv
[i
][0] = s
->next_picture
.motion_val
[0][index
][0];
1451 c
->co_located_mv
[i
][1] = s
->next_picture
.motion_val
[0][index
][1];
1452 c
->direct_basis_mv
[i
][0]= c
->co_located_mv
[i
][0]*time_pb
/time_pp
+ ((i
& 1)<<(shift
+3));
1453 c
->direct_basis_mv
[i
][1]= c
->co_located_mv
[i
][1]*time_pb
/time_pp
+ ((i
>>1)<<(shift
+3));
1454 // c->direct_basis_mv[1][i][0]= c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(shift+3);
1455 // c->direct_basis_mv[1][i][1]= c->co_located_mv[i][1]*(time_pb - time_pp)/time_pp + ((i>>1)<<(shift+3);
1457 max
= FFMAX(c
->direct_basis_mv
[i
][0], c
->direct_basis_mv
[i
][0] - c
->co_located_mv
[i
][0])>>shift
;
1458 min
= FFMIN(c
->direct_basis_mv
[i
][0], c
->direct_basis_mv
[i
][0] - c
->co_located_mv
[i
][0])>>shift
;
1459 max
+= 16*mb_x
+ 1; // +-1 is for the simpler rounding
1461 xmax
= FFMIN(xmax
, s
->width
- max
);
1462 xmin
= FFMAX(xmin
, - 16 - min
);
1464 max
= FFMAX(c
->direct_basis_mv
[i
][1], c
->direct_basis_mv
[i
][1] - c
->co_located_mv
[i
][1])>>shift
;
1465 min
= FFMIN(c
->direct_basis_mv
[i
][1], c
->direct_basis_mv
[i
][1] - c
->co_located_mv
[i
][1])>>shift
;
1466 max
+= 16*mb_y
+ 1; // +-1 is for the simpler rounding
1468 ymax
= FFMIN(ymax
, s
->height
- max
);
1469 ymin
= FFMAX(ymin
, - 16 - min
);
1471 if(s
->mv_type
== MV_TYPE_16X16
) break;
1474 av_assert2(xmax
<= 15 && ymax
<= 15 && xmin
>= -16 && ymin
>= -16);
1476 if(xmax
< 0 || xmin
>0 || ymax
< 0 || ymin
> 0){
1477 s
->b_direct_mv_table
[mot_xy
][0]= 0;
1478 s
->b_direct_mv_table
[mot_xy
][1]= 0;
1480 return 256*256*256*64;
1487 c
->flags
|= FLAG_DIRECT
;
1488 c
->sub_flags
|= FLAG_DIRECT
;
1492 P_LEFT
[0] = av_clip(mv_table
[mot_xy
- 1][0], xmin
<<shift
, xmax
<<shift
);
1493 P_LEFT
[1] = av_clip(mv_table
[mot_xy
- 1][1], ymin
<<shift
, ymax
<<shift
);
1495 /* special case for first line */
1496 if (!s
->first_slice_line
) { //FIXME maybe allow this over thread boundary as it is clipped
1497 P_TOP
[0] = av_clip(mv_table
[mot_xy
- mot_stride
][0], xmin
<<shift
, xmax
<<shift
);
1498 P_TOP
[1] = av_clip(mv_table
[mot_xy
- mot_stride
][1], ymin
<<shift
, ymax
<<shift
);
1499 P_TOPRIGHT
[0] = av_clip(mv_table
[mot_xy
- mot_stride
+ 1 ][0], xmin
<<shift
, xmax
<<shift
);
1500 P_TOPRIGHT
[1] = av_clip(mv_table
[mot_xy
- mot_stride
+ 1 ][1], ymin
<<shift
, ymax
<<shift
);
1502 P_MEDIAN
[0]= mid_pred(P_LEFT
[0], P_TOP
[0], P_TOPRIGHT
[0]);
1503 P_MEDIAN
[1]= mid_pred(P_LEFT
[1], P_TOP
[1], P_TOPRIGHT
[1]);
1506 dmin
= ff_epzs_motion_search(s
, &mx
, &my
, P
, 0, 0, mv_table
, 1<<(16-shift
), 0, 16);
1507 if(c
->sub_flags
&FLAG_QPEL
)
1508 dmin
= qpel_motion_search(s
, &mx
, &my
, dmin
, 0, 0, 0, 16);
1510 dmin
= hpel_motion_search(s
, &mx
, &my
, dmin
, 0, 0, 0, 16);
1512 if(c
->avctx
->me_sub_cmp
!= c
->avctx
->mb_cmp
&& !c
->skip
)
1513 dmin
= get_mb_score(s
, mx
, my
, 0, 0, 0, 16, 1);
1515 get_limits(s
, 16*mb_x
, 16*mb_y
); //restore c->?min/max, maybe not needed
1517 mv_table
[mot_xy
][0]= mx
;
1518 mv_table
[mot_xy
][1]= my
;
1519 c
->flags
&= ~FLAG_DIRECT
;
1520 c
->sub_flags
&= ~FLAG_DIRECT
;
1525 void ff_estimate_b_frame_motion(MpegEncContext
* s
,
1528 MotionEstContext
* const c
= &s
->me
;
1529 const int penalty_factor
= c
->mb_penalty_factor
;
1530 int fmin
, bmin
, dmin
, fbmin
, bimin
, fimin
;
1532 const int xy
= mb_y
*s
->mb_stride
+ mb_x
;
1533 init_ref(c
, s
->new_picture
.f
->data
, s
->last_picture
.f
->data
,
1534 s
->next_picture
.f
->data
, 16 * mb_x
, 16 * mb_y
, 2);
1536 get_limits(s
, 16*mb_x
, 16*mb_y
);
1540 if (s
->codec_id
== AV_CODEC_ID_MPEG4
&& s
->next_picture
.mbskip_table
[xy
]) {
1541 int score
= direct_search(s
, mb_x
, mb_y
); //FIXME just check 0,0
1543 score
= ((unsigned)(score
*score
+ 128*256))>>16;
1544 c
->mc_mb_var_sum_temp
+= score
;
1545 s
->current_picture
.mc_mb_var
[mb_y
*s
->mb_stride
+ mb_x
] = score
; //FIXME use SSE
1546 s
->mb_type
[mb_y
*s
->mb_stride
+ mb_x
]= CANDIDATE_MB_TYPE_DIRECT0
;
1551 if (s
->codec_id
== AV_CODEC_ID_MPEG4
)
1552 dmin
= direct_search(s
, mb_x
, mb_y
);
1555 //FIXME penalty stuff for non mpeg4
1557 fmin
= estimate_motion_b(s
, mb_x
, mb_y
, s
->b_forw_mv_table
, 0, s
->f_code
) +
1561 bmin
= estimate_motion_b(s
, mb_x
, mb_y
, s
->b_back_mv_table
, 2, s
->b_code
) +
1563 av_dlog(s
, " %d %d ", s
->b_forw_mv_table
[xy
][0], s
->b_forw_mv_table
[xy
][1]);
1566 fbmin
= bidir_refine(s
, mb_x
, mb_y
) + penalty_factor
;
1567 av_dlog(s
, "%d %d %d %d\n", dmin
, fmin
, bmin
, fbmin
);
1569 if(s
->flags
& CODEC_FLAG_INTERLACED_ME
){
1570 //FIXME mb type penalty
1572 c
->current_mv_penalty
= c
->mv_penalty
[s
->f_code
] + MAX_MV
;
1573 fimin
= interlaced_search(s
, 0,
1574 s
->b_field_mv_table
[0], s
->b_field_select_table
[0],
1575 s
->b_forw_mv_table
[xy
][0], s
->b_forw_mv_table
[xy
][1], 0);
1576 c
->current_mv_penalty
= c
->mv_penalty
[s
->b_code
] + MAX_MV
;
1577 bimin
= interlaced_search(s
, 2,
1578 s
->b_field_mv_table
[1], s
->b_field_select_table
[1],
1579 s
->b_back_mv_table
[xy
][0], s
->b_back_mv_table
[xy
][1], 0);
1581 fimin
= bimin
= INT_MAX
;
1585 type
= CANDIDATE_MB_TYPE_FORWARD
;
1589 type
= CANDIDATE_MB_TYPE_DIRECT
;
1593 type
= CANDIDATE_MB_TYPE_BACKWARD
;
1597 type
= CANDIDATE_MB_TYPE_BIDIR
;
1601 type
= CANDIDATE_MB_TYPE_FORWARD_I
;
1605 type
= CANDIDATE_MB_TYPE_BACKWARD_I
;
1608 score
= ((unsigned)(score
*score
+ 128*256))>>16;
1609 c
->mc_mb_var_sum_temp
+= score
;
1610 s
->current_picture
.mc_mb_var
[mb_y
*s
->mb_stride
+ mb_x
] = score
; //FIXME use SSE
1613 if(c
->avctx
->mb_decision
> FF_MB_DECISION_SIMPLE
){
1614 type
= CANDIDATE_MB_TYPE_FORWARD
| CANDIDATE_MB_TYPE_BACKWARD
| CANDIDATE_MB_TYPE_BIDIR
| CANDIDATE_MB_TYPE_DIRECT
;
1616 type
|= CANDIDATE_MB_TYPE_FORWARD_I
;
1618 type
|= CANDIDATE_MB_TYPE_BACKWARD_I
;
1619 if(fimin
< INT_MAX
&& bimin
< INT_MAX
){
1620 type
|= CANDIDATE_MB_TYPE_BIDIR_I
;
1622 //FIXME something smarter
1623 if(dmin
>256*256*16) type
&= ~CANDIDATE_MB_TYPE_DIRECT
; //do not try direct mode if it is invalid for this MB
1624 if (s
->codec_id
== AV_CODEC_ID_MPEG4
&& type
&CANDIDATE_MB_TYPE_DIRECT
&&
1625 s
->mpv_flags
& FF_MPV_FLAG_MV0
&& *(uint32_t*)s
->b_direct_mv_table
[xy
])
1626 type
|= CANDIDATE_MB_TYPE_DIRECT0
;
1629 s
->mb_type
[mb_y
*s
->mb_stride
+ mb_x
]= type
;
1632 /* find best f_code for ME which do unlimited searches */
1633 int ff_get_best_fcode(MpegEncContext
* s
, int16_t (*mv_table
)[2], int type
)
1635 if(s
->me_method
>=ME_EPZS
){
1637 int i
, y
, range
= s
->avctx
->me_range
? s
->avctx
->me_range
: (INT_MAX
/2);
1638 uint8_t * fcode_tab
= s
->fcode_tab
;
1640 int best_score
=-10000000;
1642 if(s
->msmpeg4_version
)
1643 range
= FFMIN(range
, 16);
1644 else if(s
->codec_id
== AV_CODEC_ID_MPEG2VIDEO
&& s
->avctx
->strict_std_compliance
>= FF_COMPLIANCE_NORMAL
)
1645 range
= FFMIN(range
, 256);
1647 for(i
=0; i
<8; i
++) score
[i
]= s
->mb_num
*(8-i
);
1649 for(y
=0; y
<s
->mb_height
; y
++){
1651 int xy
= y
*s
->mb_stride
;
1652 for(x
=0; x
<s
->mb_width
; x
++){
1653 if(s
->mb_type
[xy
] & type
){
1654 int mx
= mv_table
[xy
][0];
1655 int my
= mv_table
[xy
][1];
1656 int fcode
= FFMAX(fcode_tab
[mx
+ MAX_MV
],
1657 fcode_tab
[my
+ MAX_MV
]);
1660 if(mx
>= range
|| mx
< -range
||
1661 my
>= range
|| my
< -range
)
1664 for(j
=0; j
<fcode
&& j
<8; j
++){
1665 if(s
->pict_type
==AV_PICTURE_TYPE_B
|| s
->current_picture
.mc_mb_var
[xy
] < s
->current_picture
.mb_var
[xy
])
1674 if(score
[i
] > best_score
){
1675 best_score
= score
[i
];
1686 void ff_fix_long_p_mvs(MpegEncContext
* s
)
1688 MotionEstContext
* const c
= &s
->me
;
1689 const int f_code
= s
->f_code
;
1691 av_assert0(s
->pict_type
==AV_PICTURE_TYPE_P
);
1693 range
= (((s
->out_format
== FMT_MPEG1
|| s
->msmpeg4_version
) ? 8 : 16) << f_code
);
1695 av_assert0(range
<= 16 || !s
->msmpeg4_version
);
1696 av_assert0(range
<=256 || !(s
->codec_id
== AV_CODEC_ID_MPEG2VIDEO
&& s
->avctx
->strict_std_compliance
>= FF_COMPLIANCE_NORMAL
));
1698 if(c
->avctx
->me_range
&& range
> c
->avctx
->me_range
) range
= c
->avctx
->me_range
;
1700 if(s
->flags
&CODEC_FLAG_4MV
){
1701 const int wrap
= s
->b8_stride
;
1703 /* clip / convert to intra 8x8 type MVs */
1704 for(y
=0; y
<s
->mb_height
; y
++){
1706 int i
= y
*s
->mb_stride
;
1709 for(x
=0; x
<s
->mb_width
; x
++){
1710 if(s
->mb_type
[i
]&CANDIDATE_MB_TYPE_INTER4V
){
1712 for(block
=0; block
<4; block
++){
1713 int off
= (block
& 1) + (block
>>1)*wrap
;
1714 int mx
= s
->current_picture
.motion_val
[0][ xy
+ off
][0];
1715 int my
= s
->current_picture
.motion_val
[0][ xy
+ off
][1];
1717 if( mx
>=range
|| mx
<-range
1718 || my
>=range
|| my
<-range
){
1719 s
->mb_type
[i
] &= ~CANDIDATE_MB_TYPE_INTER4V
;
1720 s
->mb_type
[i
] |= CANDIDATE_MB_TYPE_INTRA
;
1721 s
->current_picture
.mb_type
[i
] = CANDIDATE_MB_TYPE_INTRA
;
1734 * @param truncate 1 for truncation, 0 for using intra
1736 void ff_fix_long_mvs(MpegEncContext
* s
, uint8_t *field_select_table
, int field_select
,
1737 int16_t (*mv_table
)[2], int f_code
, int type
, int truncate
)
1739 MotionEstContext
* const c
= &s
->me
;
1740 int y
, h_range
, v_range
;
1742 // RAL: 8 in MPEG-1, 16 in MPEG-4
1743 int range
= (((s
->out_format
== FMT_MPEG1
|| s
->msmpeg4_version
) ? 8 : 16) << f_code
);
1745 if(c
->avctx
->me_range
&& range
> c
->avctx
->me_range
) range
= c
->avctx
->me_range
;
1748 v_range
= field_select_table
? range
>>1 : range
;
1750 /* clip / convert to intra 16x16 type MVs */
1751 for(y
=0; y
<s
->mb_height
; y
++){
1753 int xy
= y
*s
->mb_stride
;
1754 for(x
=0; x
<s
->mb_width
; x
++){
1755 if (s
->mb_type
[xy
] & type
){ // RAL: "type" test added...
1756 if (!field_select_table
|| field_select_table
[xy
] == field_select
) {
1757 if( mv_table
[xy
][0] >=h_range
|| mv_table
[xy
][0] <-h_range
1758 || mv_table
[xy
][1] >=v_range
|| mv_table
[xy
][1] <-v_range
){
1761 if (mv_table
[xy
][0] > h_range
-1) mv_table
[xy
][0]= h_range
-1;
1762 else if(mv_table
[xy
][0] < -h_range
) mv_table
[xy
][0]= -h_range
;
1763 if (mv_table
[xy
][1] > v_range
-1) mv_table
[xy
][1]= v_range
-1;
1764 else if(mv_table
[xy
][1] < -v_range
) mv_table
[xy
][1]= -v_range
;
1766 s
->mb_type
[xy
] &= ~type
;
1767 s
->mb_type
[xy
] |= CANDIDATE_MB_TYPE_INTRA
;