Annotation of /trunk/xvidcore/src/motion/motion_est.c

Revision 326 - (view) (download)

1 :	Isibaar	3	/**************************************************************************
2 :			*
3 :	chl	259	* XVID MPEG-4 VIDEO CODEC
4 :			* motion estimation
5 :			*
6 :			* This program is an implementation of a part of one or more MPEG-4
7 :			* Video tools as specified in ISO/IEC 14496-2 standard. Those intending
8 :			* to use this software module in hardware or software products are
9 :			* advised that its use may infringe existing patents or copyrights, and
10 :			* any such use would be at such party's own risk. The original
11 :			* developer of this software module and his/her company, and subsequent
12 :			* editors and their companies, will have no liability for use of this
13 :			* software or modifications or derivatives thereof.
14 :			*
15 :			* This program is free software; you can redistribute it and/or modify
16 :			* it under the terms of the GNU General Public License as published by
17 :			* the Free Software Foundation; either version 2 of the License, or
18 :			* (at your option) any later version.
19 :			*
20 :			* This program is distributed in the hope that it will be useful,
21 :			* but WITHOUT ANY WARRANTY; without even the implied warranty of
22 :			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 :			* GNU General Public License for more details.
24 :			*
25 :			* You should have received a copy of the GNU General Public License
26 :			* along with this program; if not, write to the Free Software
27 :			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 :			*
29 :			*************************************************************************/
30 :
31 :			/**************************************************************************
32 :			*
33 :	Isibaar	3	* Modifications:
34 :			*
35 :	suxen_drol	152	* 01.05.2002 updated MotionEstimationBVOP
36 :	suxen_drol	136	* 25.04.2002 partial prevMB conversion
37 :	chenm001	132	* 22.04.2002 remove some compile warning by chenm001 <chenm001@163.com>
38 :			* 14.04.2002 added MotionEstimationBVOP()
39 :	chl	96	* 02.04.2002 add EPZS(^2) as ME algorithm, use PMV_USESQUARES to choose between
40 :			* EPZS and EPZS^2
41 :	Isibaar	3	* 08.02.2002 split up PMVfast into three routines: PMVFast, PMVFast_MainLoop
42 :			* PMVFast_Refine to support multiple searches with different start points
43 :	edgomez	78	* 07.01.2002 uv-block-based interpolation
44 :	Isibaar	3	* 06.01.2002 INTER/INTRA-decision is now done before any SEARCH8 (speedup)
45 :	edgomez	78	* changed INTER_BIAS to 150 (as suggested by suxen_drol)
46 :			* removed halfpel refinement step in PMVfastSearch8 + quality=5
47 :			* added new quality mode = 6 which performs halfpel refinement
48 :			* filesize difference between quality 5 and 6 is smaller than 1%
49 :	Isibaar	3	* (Isibaar)
50 :			* 31.12.2001 PMVfastSearch16 and PMVfastSearch8 (gruel)
51 :	edgomez	78	* 30.12.2001 get_range/MotionSearchX simplified; blue/green bug fix
52 :			* 22.12.2001 commented best_point==99 check
53 :			* 19.12.2001 modified get_range (purple bug fix)
54 :	Isibaar	3	* 15.12.2001 moved pmv displacement from mbprediction
55 :			* 02.12.2001 motion estimation/compensation split (Isibaar)
56 :	edgomez	78	* 16.11.2001 rewrote/tweaked search algorithms; pross@cs.rmit.edu.au
57 :	Isibaar	3	* 10.11.2001 support for sad16/sad8 functions
58 :			* 28.08.2001 reactivated MODE_INTER4V for EXT_MODE
59 :			* 24.08.2001 removed MODE_INTER4V_Q, disabled MODE_INTER4V for EXT_MODE
60 :	edgomez	78	* 22.08.2001 added MODE_INTER4V_Q
61 :	Isibaar	3	* 20.08.2001 added pragma to get rid of internal compiler error with VC6
62 :			* idea by Cyril. Thanks.
63 :			*
64 :			* Michael Militzer <isibaar@videocoding.de>
65 :			*
66 :			**************************************************************************/
67 :
68 :			#include <assert.h>
69 :			#include <stdio.h>
70 :	chl	96	#include <stdlib.h>
71 :	Isibaar	3
72 :			#include "../encoder.h"
73 :			#include "../utils/mbfunctions.h"
74 :			#include "../prediction/mbprediction.h"
75 :			#include "../global.h"
76 :			#include "../utils/timer.h"
77 :	suxen_drol	118	#include "motion.h"
78 :	Isibaar	3	#include "sad.h"
79 :
80 :
81 :
82 :	edgomez	195	static int32_t lambda_vec16[32] = /* rounded values for lambda param for weight of motion bits as in modified H.26L */
83 :			{ 0, (int) (1.00235 + 0.5), (int) (1.15582 + 0.5), (int) (1.31976 + 0.5),
84 :			(int) (1.49591 + 0.5), (int) (1.68601 + 0.5),
85 :			(int) (1.89187 + 0.5), (int) (2.11542 + 0.5), (int) (2.35878 + 0.5),
86 :			(int) (2.62429 + 0.5), (int) (2.91455 + 0.5),
87 :			(int) (3.23253 + 0.5), (int) (3.58158 + 0.5), (int) (3.96555 + 0.5),
88 :			(int) (4.38887 + 0.5), (int) (4.85673 + 0.5),
89 :			(int) (5.37519 + 0.5), (int) (5.95144 + 0.5), (int) (6.59408 + 0.5),
90 :			(int) (7.31349 + 0.5), (int) (8.12242 + 0.5),
91 :			(int) (9.03669 + 0.5), (int) (10.0763 + 0.5), (int) (11.2669 + 0.5),
92 :			(int) (12.6426 + 0.5), (int) (14.2493 + 0.5),
93 :			(int) (16.1512 + 0.5), (int) (18.442 + 0.5), (int) (21.2656 + 0.5),
94 :			(int) (24.8580 + 0.5), (int) (29.6436 + 0.5),
95 :			(int) (36.4949 + 0.5)
96 :			};
97 :	chl	141
98 :	edgomez	195	static int32_t lambda_vec8 = lambda_vec16; / same table for INTER and INTER4V for now */
99 :	chl	141
100 :
101 :
102 :	Isibaar	3	// mv.length table
103 :			static const uint32_t mvtab[33] = {
104 :	edgomez	195	1, 2, 3, 4, 6, 7, 7, 7,
105 :			9, 9, 9, 10, 10, 10, 10, 10,
106 :			10, 10, 10, 10, 10, 10, 10, 10,
107 :			10, 11, 11, 11, 11, 11, 11, 12, 12
108 :	Isibaar	3	};
109 :
110 :
111 :	edgomez	195	static __inline uint32_t
112 :			mv_bits(int32_t component,
113 :			const uint32_t iFcode)
114 :	Isibaar	3	{
115 :	edgomez	195	if (component == 0)
116 :	Isibaar	3	return 1;
117 :
118 :	edgomez	195	if (component < 0)
119 :	Isibaar	3	component = -component;
120 :
121 :	edgomez	195	if (iFcode == 1) {
122 :	Isibaar	3	if (component > 32)
123 :	edgomez	195	component = 32;
124 :	Isibaar	3
125 :			return mvtab[component] + 1;
126 :	edgomez	195	}
127 :	Isibaar	3
128 :	edgomez	195	component += (1 << (iFcode - 1)) - 1;
129 :			component >>= (iFcode - 1);
130 :	Isibaar	3
131 :	edgomez	195	if (component > 32)
132 :	Isibaar	3	component = 32;
133 :
134 :	edgomez	195	return mvtab[component] + 1 + iFcode - 1;
135 :	Isibaar	3	}
136 :
137 :
138 :	edgomez	195	static __inline uint32_t
139 :			calc_delta_16(const int32_t dx,
140 :			const int32_t dy,
141 :			const uint32_t iFcode,
142 :			const uint32_t iQuant)
143 :	Isibaar	3	{
144 :	edgomez	195	return NEIGH_TEND_16X16 * lambda_vec16[iQuant] * (mv_bits(dx, iFcode) +
145 :			mv_bits(dy, iFcode));
146 :	Isibaar	3	}
147 :
148 :	edgomez	195	static __inline uint32_t
149 :			calc_delta_8(const int32_t dx,
150 :			const int32_t dy,
151 :			const uint32_t iFcode,
152 :			const uint32_t iQuant)
153 :	Isibaar	3	{
154 :	edgomez	195	return NEIGH_TEND_8X8 * lambda_vec8[iQuant] * (mv_bits(dx, iFcode) +
155 :			mv_bits(dy, iFcode));
156 :	Isibaar	3	}
157 :	chl	326
158 :	edgomez	195	bool
159 :			MotionEstimation(MBParam * const pParam,
160 :			FRAMEINFO * const current,
161 :			FRAMEINFO * const reference,
162 :			const IMAGE * const pRefH,
163 :			const IMAGE * const pRefV,
164 :			const IMAGE * const pRefHV,
165 :			const uint32_t iLimit)
166 :	Isibaar	3	{
167 :	edgomez	78	const uint32_t iWcount = pParam->mb_width;
168 :			const uint32_t iHcount = pParam->mb_height;
169 :	edgomez	195	MACROBLOCK *const pMBs = current->mbs;
170 :			MACROBLOCK *const prevMBs = reference->mbs;
171 :			const IMAGE *const pCurrent = &current->image;
172 :			const IMAGE *const pRef = &reference->image;
173 :	suxen_drol	136
174 :	chl	317	static const VECTOR zeroMV = { 0, 0 };
175 :	chl	326	VECTOR predMV;
176 :	chl	184
177 :	chl	172	int32_t x, y;
178 :			int32_t iIntra = 0;
179 :			VECTOR pmv;
180 :	suxen_drol	136
181 :	chl	184	if (sadInit)
182 :	edgomez	195	(*sadInit) ();
183 :
184 :	chl	259	for (y = 0; y < iHcount; y++) {
185 :			for (x = 0; x < iWcount; x ++) {
186 :
187 :	edgomez	195	MACROBLOCK const pMB = &pMBs[x + y iWcount];
188 :	Isibaar	3
189 :	chl	326	predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);
190 :
191 :	edgomez	195	pMB->sad16 =
192 :	chl	326	SEARCH16(pRef->y, pRefH->y, pRefV->y, pRefHV->y, pCurrent,
193 :			x, y, predMV.x, predMV.y, predMV.x, predMV.y,
194 :			current->motion_flags, current->quant,
195 :	edgomez	195	current->fcode, pParam, pMBs, prevMBs, &pMB->mv16,
196 :			&pMB->pmvs[0]);
197 :	chl	184
198 :	edgomez	195	if (0 < (pMB->sad16 - MV16_INTER_BIAS)) {
199 :	chl	172	int32_t deviation;
200 :	chl	184
201 :	edgomez	195	deviation =
202 :			dev16(pCurrent->y + x * 16 + y * 16 * pParam->edged_width,
203 :			pParam->edged_width);
204 :
205 :			if (deviation < (pMB->sad16 - MV16_INTER_BIAS)) {
206 :	chl	172	pMB->mode = MODE_INTRA;
207 :	edgomez	195	pMB->mv16 = pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] =
208 :			pMB->mvs[3] = zeroMV;
209 :			pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] =
210 :			pMB->sad8[3] = 0;
211 :
212 :	chl	172	iIntra++;
213 :			if (iIntra >= iLimit)
214 :	edgomez	195	return 1;
215 :
216 :	chl	172	continue;
217 :			}
218 :	edgomez	195	}
219 :
220 :	chl	184	pmv = pMB->pmvs[0];
221 :			if (current->global_flags & XVID_INTER4V)
222 :	edgomez	195	if ((!(current->global_flags & XVID_LUMIMASKING) \|\|
223 :			pMB->dquant == NO_CHANGE)) {
224 :			int32_t sad8 = IMV16X16 * current->quant;
225 :
226 :	chl	326	if (sad8 < pMB->sad16) {
227 :	edgomez	195	sad8 += pMB->sad8[0] =
228 :			SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,
229 :	chl	326	pCurrent, 2 * x, 2 * y,
230 :			pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,
231 :			current->motion_flags,
232 :	edgomez	195	current->quant, current->fcode, pParam,
233 :			pMBs, prevMBs, &pMB->mvs[0],
234 :			&pMB->pmvs[0]);
235 :	chl	326	}
236 :			if (sad8 < pMB->sad16) {
237 :	edgomez	195
238 :	chl	326	predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 1);
239 :	edgomez	195	sad8 += pMB->sad8[1] =
240 :			SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,
241 :	chl	326	pCurrent, 2 * x + 1, 2 * y,
242 :			pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,
243 :			current->motion_flags,
244 :	edgomez	195	current->quant, current->fcode, pParam,
245 :			pMBs, prevMBs, &pMB->mvs[1],
246 :			&pMB->pmvs[1]);
247 :	chl	326	}
248 :			if (sad8 < pMB->sad16) {
249 :			predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 2);
250 :	edgomez	195	sad8 += pMB->sad8[2] =
251 :			SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,
252 :	chl	326	pCurrent, 2 * x, 2 * y + 1,
253 :			pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,
254 :			current->motion_flags,
255 :	edgomez	195	current->quant, current->fcode, pParam,
256 :			pMBs, prevMBs, &pMB->mvs[2],
257 :			&pMB->pmvs[2]);
258 :	chl	326	}
259 :			if (sad8 < pMB->sad16) {
260 :			predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 3);
261 :	edgomez	195	sad8 += pMB->sad8[3] =
262 :			SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,
263 :			pCurrent, 2 * x + 1, 2 * y + 1,
264 :	chl	326	pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,
265 :			current->motion_flags,
266 :			current->quant, current->fcode, pParam,
267 :			pMBs, prevMBs,
268 :			&pMB->mvs[3],
269 :			&pMB->pmvs[3]);
270 :			}
271 :
272 :	chl	184	/* decide: MODE_INTER or MODE_INTER4V
273 :	edgomez	195	mpeg4: if (sad8 < pMB->sad16 - nb/2+1) use_inter4v
274 :			*/
275 :
276 :			if (sad8 < pMB->sad16) {
277 :	chl	175	pMB->mode = MODE_INTER4V;
278 :	edgomez	195	pMB->sad8[0] *= 4;
279 :	chl	175	pMB->sad8[1] *= 4;
280 :			pMB->sad8[2] *= 4;
281 :			pMB->sad8[3] *= 4;
282 :			continue;
283 :			}
284 :
285 :	edgomez	195	}
286 :
287 :			pMB->mode = MODE_INTER;
288 :			pMB->pmvs[0] = pmv; /* pMB->pmvs[1] = pMB->pmvs[2] = pMB->pmvs[3] are not needed for INTER */
289 :			pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->mv16;
290 :			pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] =
291 :			pMB->sad16;
292 :	chl	259	}
293 :			}
294 :	edgomez	195
295 :			return 0;
296 :	Isibaar	3	}
297 :
298 :	chl	326
299 :	Isibaar	3	#define CHECK_MV16_ZERO {\
300 :			if ( (0 <= max_dx) && (0 >= min_dx) \
301 :			&& (0 <= max_dy) && (0 >= min_dy) ) \
302 :			{ \
303 :			iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, 0, 0 , iEdgedWidth), iEdgedWidth, MV_MAX_ERROR); \
304 :	chl	326	iSAD += calc_delta_16(-center_x, -center_y, (uint8_t)iFcode, iQuant);\
305 :	Isibaar	3	if (iSAD < iMinSAD) \
306 :			{ iMinSAD=iSAD; currMV->x=0; currMV->y=0; } } \
307 :			}
308 :
309 :	chl	96	#define NOCHECK_MV16_CANDIDATE(X,Y) { \
310 :			iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \
311 :	chl	326	iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\
312 :	chl	96	if (iSAD < iMinSAD) \
313 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } \
314 :			}
315 :	Isibaar	3
316 :			#define CHECK_MV16_CANDIDATE(X,Y) { \
317 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
318 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
319 :			{ \
320 :			iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \
321 :	chl	326	iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\
322 :	Isibaar	3	if (iSAD < iMinSAD) \
323 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } } \
324 :			}
325 :
326 :			#define CHECK_MV16_CANDIDATE_DIR(X,Y,D) { \
327 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
328 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
329 :			{ \
330 :			iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \
331 :	chl	326	iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\
332 :	Isibaar	3	if (iSAD < iMinSAD) \
333 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); } } \
334 :			}
335 :
336 :			#define CHECK_MV16_CANDIDATE_FOUND(X,Y,D) { \
337 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
338 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
339 :			{ \
340 :			iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \
341 :	chl	326	iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\
342 :	Isibaar	3	if (iSAD < iMinSAD) \
343 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); iFound=0; } } \
344 :			}
345 :
346 :
347 :			#define CHECK_MV8_ZERO {\
348 :			iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, 0, 0 , iEdgedWidth), iEdgedWidth); \
349 :	chl	326	iSAD += calc_delta_8(-center_x, -center_y, (uint8_t)iFcode, iQuant);\
350 :	Isibaar	3	if (iSAD < iMinSAD) \
351 :			{ iMinSAD=iSAD; currMV->x=0; currMV->y=0; } \
352 :			}
353 :	edgomez	195
354 :	chl	96	#define NOCHECK_MV8_CANDIDATE(X,Y) \
355 :			{ \
356 :			iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \
357 :	chl	326	iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\
358 :	chl	96	if (iSAD < iMinSAD) \
359 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } \
360 :			}
361 :	Isibaar	3
362 :			#define CHECK_MV8_CANDIDATE(X,Y) { \
363 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
364 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
365 :			{ \
366 :			iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \
367 :	chl	326	iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\
368 :	Isibaar	3	if (iSAD < iMinSAD) \
369 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } } \
370 :			}
371 :
372 :			#define CHECK_MV8_CANDIDATE_DIR(X,Y,D) { \
373 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
374 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
375 :			{ \
376 :			iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \
377 :	chl	326	iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\
378 :	Isibaar	3	if (iSAD < iMinSAD) \
379 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); } } \
380 :			}
381 :
382 :			#define CHECK_MV8_CANDIDATE_FOUND(X,Y,D) { \
383 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
384 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
385 :			{ \
386 :			iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \
387 :	chl	326	iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\
388 :	Isibaar	3	if (iSAD < iMinSAD) \
389 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); iFound=0; } } \
390 :			}
391 :
392 :			/* too slow and not fully functional at the moment */
393 :			/*
394 :			int32_t ZeroSearch16(
395 :			const uint8_t * const pRef,
396 :			const uint8_t * const pRefH,
397 :			const uint8_t * const pRefV,
398 :			const uint8_t * const pRefHV,
399 :			const IMAGE * const pCur,
400 :			const int x, const int y,
401 :			const uint32_t MotionFlags,
402 :	suxen_drol	136	const uint32_t iQuant,
403 :			const uint32_t iFcode,
404 :	Isibaar	3	MBParam * const pParam,
405 :	suxen_drol	136	const MACROBLOCK * const pMBs,
406 :			const MACROBLOCK * const prevMBs,
407 :	Isibaar	3	VECTOR * const currMV,
408 :			VECTOR * const currPMV)
409 :			{
410 :			const int32_t iEdgedWidth = pParam->edged_width;
411 :			const uint8_t * cur = pCur->y + x16 + y16*iEdgedWidth;
412 :			int32_t iSAD;
413 :	suxen_drol	254	VECTOR pred;
414 :
415 :	Isibaar	3
416 :	suxen_drol	254	pred = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);
417 :	Isibaar	3
418 :			iSAD = sad16( cur,
419 :			get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, 0,0, iEdgedWidth),
420 :			iEdgedWidth, MV_MAX_ERROR);
421 :			if (iSAD <= iQuant * 96)
422 :			iSAD -= MV16_00_BIAS;
423 :
424 :			currMV->x = 0;
425 :			currMV->y = 0;
426 :	suxen_drol	254	currPMV->x = -pred.x;
427 :			currPMV->y = -pred.y;
428 :	Isibaar	3
429 :			return iSAD;
430 :
431 :			}
432 :			*/
433 :
434 :	edgomez	195	int32_t
435 :			Diamond16_MainSearch(const uint8_t * const pRef,
436 :			const uint8_t * const pRefH,
437 :			const uint8_t * const pRefV,
438 :			const uint8_t * const pRefHV,
439 :			const uint8_t * const cur,
440 :			const int x,
441 :			const int y,
442 :	chl	326	const int start_x,
443 :			const int start_y,
444 :			int iMinSAD,
445 :			VECTOR * const currMV,
446 :			const int center_x,
447 :			const int center_y,
448 :	edgomez	195	const int32_t min_dx,
449 :			const int32_t max_dx,
450 :			const int32_t min_dy,
451 :			const int32_t max_dy,
452 :			const int32_t iEdgedWidth,
453 :			const int32_t iDiamondSize,
454 :			const int32_t iFcode,
455 :			const int32_t iQuant,
456 :			int iFound)
457 :	Isibaar	3	{
458 :			/* Do a diamond search around given starting point, return SAD of best */
459 :
460 :	edgomez	195	int32_t iDirection = 0;
461 :	Isibaar	3	int32_t iSAD;
462 :			VECTOR backupMV;
463 :	edgomez	195
464 :	chl	326	backupMV.x = start_x;
465 :			backupMV.y = start_y;
466 :	edgomez	195
467 :	Isibaar	3	/* It's one search with full Diamond pattern, and only 3 of 4 for all following diamonds */
468 :
469 :	edgomez	195	CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);
470 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);
471 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);
472 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);
473 :	Isibaar	3
474 :			if (iDirection)
475 :	edgomez	195	while (!iFound) {
476 :			iFound = 1;
477 :			backupMV = *currMV;
478 :
479 :			if (iDirection != 2)
480 :			CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,
481 :			backupMV.y, 1);
482 :			if (iDirection != 1)
483 :			CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,
484 :			backupMV.y, 2);
485 :			if (iDirection != 4)
486 :			CHECK_MV16_CANDIDATE_FOUND(backupMV.x,
487 :			backupMV.y - iDiamondSize, 3);
488 :			if (iDirection != 3)
489 :			CHECK_MV16_CANDIDATE_FOUND(backupMV.x,
490 :			backupMV.y + iDiamondSize, 4);
491 :			} else {
492 :	chl	326	currMV->x = start_x;
493 :			currMV->y = start_y;
494 :	edgomez	78	}
495 :	Isibaar	3	return iMinSAD;
496 :			}
497 :
498 :	edgomez	195	int32_t
499 :			Square16_MainSearch(const uint8_t * const pRef,
500 :	chl	96	const uint8_t * const pRefH,
501 :			const uint8_t * const pRefV,
502 :			const uint8_t * const pRefHV,
503 :			const uint8_t * const cur,
504 :	edgomez	195	const int x,
505 :			const int y,
506 :	chl	326	const int start_x,
507 :			const int start_y,
508 :			int iMinSAD,
509 :			VECTOR * const currMV,
510 :			const int center_x,
511 :			const int center_y,
512 :	edgomez	195	const int32_t min_dx,
513 :			const int32_t max_dx,
514 :			const int32_t min_dy,
515 :			const int32_t max_dy,
516 :			const int32_t iEdgedWidth,
517 :			const int32_t iDiamondSize,
518 :	chl	96	const int32_t iFcode,
519 :			const int32_t iQuant,
520 :			int iFound)
521 :			{
522 :			/* Do a square search around given starting point, return SAD of best */
523 :
524 :	edgomez	195	int32_t iDirection = 0;
525 :	chl	96	int32_t iSAD;
526 :			VECTOR backupMV;
527 :	edgomez	195
528 :	chl	326	backupMV.x = start_x;
529 :			backupMV.y = start_y;
530 :	edgomez	195
531 :	chl	96	/* It's one search with full square pattern, and new parts for all following diamonds */
532 :
533 :			/* new direction are extra, so 1-4 is normal diamond
534 :			537
535 :			1*2
536 :			648
537 :			*/
538 :
539 :	edgomez	195	CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);
540 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);
541 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);
542 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);
543 :	chl	96
544 :	edgomez	195	CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
545 :			backupMV.y - iDiamondSize, 5);
546 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
547 :			backupMV.y + iDiamondSize, 6);
548 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
549 :			backupMV.y - iDiamondSize, 7);
550 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
551 :			backupMV.y + iDiamondSize, 8);
552 :	chl	96
553 :	edgomez	195
554 :	chl	96	if (iDirection)
555 :	edgomez	195	while (!iFound) {
556 :			iFound = 1;
557 :			backupMV = *currMV;
558 :	chl	96
559 :	edgomez	195	switch (iDirection) {
560 :			case 1:
561 :			CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,
562 :			backupMV.y, 1);
563 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
564 :			backupMV.y - iDiamondSize, 5);
565 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
566 :			backupMV.y - iDiamondSize, 7);
567 :			break;
568 :			case 2:
569 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y,
570 :			2);
571 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
572 :			backupMV.y + iDiamondSize, 6);
573 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
574 :			backupMV.y + iDiamondSize, 8);
575 :			break;
576 :
577 :			case 3:
578 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize,
579 :			4);
580 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
581 :			backupMV.y - iDiamondSize, 7);
582 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
583 :			backupMV.y + iDiamondSize, 8);
584 :			break;
585 :
586 :			case 4:
587 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize,
588 :			3);
589 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
590 :			backupMV.y - iDiamondSize, 5);
591 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
592 :			backupMV.y + iDiamondSize, 6);
593 :			break;
594 :
595 :			case 5:
596 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y,
597 :			1);
598 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize,
599 :			3);
600 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
601 :			backupMV.y - iDiamondSize, 5);
602 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
603 :			backupMV.y + iDiamondSize, 6);
604 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
605 :			backupMV.y - iDiamondSize, 7);
606 :			break;
607 :
608 :			case 6:
609 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y,
610 :			2);
611 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize,
612 :			3);
613 :
614 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
615 :			backupMV.y - iDiamondSize, 5);
616 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
617 :			backupMV.y + iDiamondSize, 6);
618 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
619 :			backupMV.y + iDiamondSize, 8);
620 :
621 :			break;
622 :
623 :			case 7:
624 :			CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,
625 :			backupMV.y, 1);
626 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize,
627 :			4);
628 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
629 :			backupMV.y - iDiamondSize, 5);
630 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
631 :			backupMV.y - iDiamondSize, 7);
632 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
633 :			backupMV.y + iDiamondSize, 8);
634 :			break;
635 :
636 :			case 8:
637 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y,
638 :			2);
639 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize,
640 :			4);
641 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
642 :			backupMV.y + iDiamondSize, 6);
643 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
644 :			backupMV.y - iDiamondSize, 7);
645 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
646 :			backupMV.y + iDiamondSize, 8);
647 :			break;
648 :	chl	96	default:
649 :	edgomez	195	CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y,
650 :			1);
651 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y,
652 :			2);
653 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize,
654 :			3);
655 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize,
656 :			4);
657 :
658 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
659 :			backupMV.y - iDiamondSize, 5);
660 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,
661 :			backupMV.y + iDiamondSize, 6);
662 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
663 :			backupMV.y - iDiamondSize, 7);
664 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,
665 :			backupMV.y + iDiamondSize, 8);
666 :			break;
667 :	chl	96	}
668 :	edgomez	195	} else {
669 :	chl	326	currMV->x = start_x;
670 :			currMV->y = start_y;
671 :	edgomez	195	}
672 :	chl	96	return iMinSAD;
673 :			}
674 :
675 :
676 :	edgomez	195	int32_t
677 :			Full16_MainSearch(const uint8_t * const pRef,
678 :			const uint8_t * const pRefH,
679 :			const uint8_t * const pRefV,
680 :			const uint8_t * const pRefHV,
681 :			const uint8_t * const cur,
682 :			const int x,
683 :			const int y,
684 :	chl	326	const int start_x,
685 :			const int start_y,
686 :			int iMinSAD,
687 :			VECTOR * const currMV,
688 :			const int center_x,
689 :			const int center_y,
690 :	edgomez	195	const int32_t min_dx,
691 :			const int32_t max_dx,
692 :			const int32_t min_dy,
693 :			const int32_t max_dy,
694 :			const int32_t iEdgedWidth,
695 :			const int32_t iDiamondSize,
696 :			const int32_t iFcode,
697 :			const int32_t iQuant,
698 :			int iFound)
699 :	chl	96	{
700 :			int32_t iSAD;
701 :	edgomez	195	int32_t dx, dy;
702 :	chl	96	VECTOR backupMV;
703 :	edgomez	195
704 :	chl	326	backupMV.x = start_x;
705 :			backupMV.y = start_y;
706 :	chl	96
707 :	edgomez	195	for (dx = min_dx; dx <= max_dx; dx += iDiamondSize)
708 :			for (dy = min_dy; dy <= max_dy; dy += iDiamondSize)
709 :			NOCHECK_MV16_CANDIDATE(dx, dy);
710 :
711 :	chl	96	return iMinSAD;
712 :			}
713 :
714 :	edgomez	195	int32_t
715 :			AdvDiamond16_MainSearch(const uint8_t * const pRef,
716 :			const uint8_t * const pRefH,
717 :			const uint8_t * const pRefV,
718 :			const uint8_t * const pRefHV,
719 :			const uint8_t * const cur,
720 :			const int x,
721 :			const int y,
722 :	chl	326	int start_x,
723 :			int start_y,
724 :			int iMinSAD,
725 :			VECTOR * const currMV,
726 :			const int center_x,
727 :			const int center_y,
728 :	edgomez	195	const int32_t min_dx,
729 :			const int32_t max_dx,
730 :			const int32_t min_dy,
731 :			const int32_t max_dy,
732 :			const int32_t iEdgedWidth,
733 :			const int32_t iDiamondSize,
734 :			const int32_t iFcode,
735 :			const int32_t iQuant,
736 :			int iDirection)
737 :	chl	181	{
738 :
739 :			int32_t iSAD;
740 :
741 :			/* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */
742 :
743 :	edgomez	195	if (iDirection) {
744 :	chl	326	CHECK_MV16_CANDIDATE(start_x - iDiamondSize, start_y);
745 :			CHECK_MV16_CANDIDATE(start_x + iDiamondSize, start_y);
746 :			CHECK_MV16_CANDIDATE(start_x, start_y - iDiamondSize);
747 :			CHECK_MV16_CANDIDATE(start_x, start_y + iDiamondSize);
748 :	edgomez	195	} else {
749 :			int bDirection = 1 + 2 + 4 + 8;
750 :
751 :			do {
752 :	chl	181	iDirection = 0;
753 :	edgomez	195	if (bDirection & 1) //we only want to check left if we came from the right (our last motion was to the left, up-left or down-left)
754 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);
755 :	chl	181
756 :	edgomez	195	if (bDirection & 2)
757 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);
758 :	chl	181
759 :	edgomez	195	if (bDirection & 4)
760 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);
761 :	chl	181
762 :	edgomez	195	if (bDirection & 8)
763 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);
764 :	chl	181
765 :			/* now we're doing diagonal checks near our candidate */
766 :
767 :	edgomez	195	if (iDirection) //checking if anything found
768 :	chl	181	{
769 :			bDirection = iDirection;
770 :			iDirection = 0;
771 :	chl	326	start_x = currMV->x;
772 :			start_y = currMV->y;
773 :	edgomez	195	if (bDirection & 3) //our candidate is left or right
774 :	chl	181	{
775 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);
776 :			CHECK_MV16_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);
777 :	edgomez	195	} else // what remains here is up or down
778 :	chl	181	{
779 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);
780 :			CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);
781 :	chl	181	}
782 :
783 :	edgomez	195	if (iDirection) {
784 :			bDirection += iDirection;
785 :	chl	326	start_x = currMV->x;
786 :			start_y = currMV->y;
787 :	chl	181	}
788 :	edgomez	195	} else //about to quit, eh? not so fast....
789 :	chl	181	{
790 :	edgomez	195	switch (bDirection) {
791 :	chl	181	case 2:
792 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
793 :			start_y - iDiamondSize, 2 + 4);
794 :			CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
795 :			start_y + iDiamondSize, 2 + 8);
796 :	chl	181	break;
797 :			case 1:
798 :	chl	326
799 :			CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
800 :			start_y - iDiamondSize, 1 + 4);
801 :			CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
802 :			start_y + iDiamondSize, 1 + 8);
803 :	chl	181	break;
804 :	edgomez	195	case 2 + 4:
805 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
806 :			start_y - iDiamondSize, 1 + 4);
807 :			CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
808 :			start_y - iDiamondSize, 2 + 4);
809 :			CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
810 :			start_y + iDiamondSize, 2 + 8);
811 :	chl	181	break;
812 :			case 4:
813 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
814 :			start_y - iDiamondSize, 2 + 4);
815 :			CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
816 :			start_y - iDiamondSize, 1 + 4);
817 :	chl	181	break;
818 :			case 8:
819 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
820 :			start_y + iDiamondSize, 2 + 8);
821 :			CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
822 :			start_y + iDiamondSize, 1 + 8);
823 :	chl	181	break;
824 :	edgomez	195	case 1 + 4:
825 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
826 :			start_y + iDiamondSize, 1 + 8);
827 :			CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
828 :			start_y - iDiamondSize, 1 + 4);
829 :			CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
830 :			start_y - iDiamondSize, 2 + 4);
831 :	chl	181	break;
832 :	edgomez	195	case 2 + 8:
833 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
834 :			start_y - iDiamondSize, 1 + 4);
835 :			CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
836 :			start_y + iDiamondSize, 1 + 8);
837 :			CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
838 :			start_y + iDiamondSize, 2 + 8);
839 :	chl	181	break;
840 :	edgomez	195	case 1 + 8:
841 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
842 :			start_y - iDiamondSize, 2 + 4);
843 :			CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
844 :			start_y + iDiamondSize, 2 + 8);
845 :			CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
846 :			start_y + iDiamondSize, 1 + 8);
847 :	chl	181	break;
848 :	edgomez	195	default: //1+2+4+8 == we didn't find anything at all
849 :	chl	326	CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
850 :			start_y - iDiamondSize, 1 + 4);
851 :			CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,
852 :			start_y + iDiamondSize, 1 + 8);
853 :			CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
854 :			start_y - iDiamondSize, 2 + 4);
855 :			CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,
856 :			start_y + iDiamondSize, 2 + 8);
857 :	chl	181	break;
858 :			}
859 :	edgomez	195	if (!iDirection)
860 :			break; //ok, the end. really
861 :			else {
862 :			bDirection = iDirection;
863 :	chl	326	start_x = currMV->x;
864 :			start_y = currMV->y;
865 :	chl	181	}
866 :			}
867 :			}
868 :	edgomez	195	while (1); //forever
869 :	chl	181	}
870 :			return iMinSAD;
871 :			}
872 :
873 :	chl	326
874 :			#define CHECK_MV16_F_INTERPOL(X,Y,BX,BY) { \
875 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
876 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
877 :			{ \
878 :			iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \
879 :			iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\
880 :			if (iSAD < iMinSAD) \
881 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } } \
882 :			}
883 :
884 :			#define CHECK_MV16_F_INTERPOL_DIR(X,Y,BX,BY,D) { \
885 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
886 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
887 :			{ \
888 :			iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \
889 :			iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\
890 :			if (iSAD < iMinSAD) \
891 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); } } \
892 :			}
893 :
894 :			#define CHECK_MV16_F_INTERPOL_FOUND(X,Y,BX,BY,D) { \
895 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
896 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
897 :			{ \
898 :			iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \
899 :			iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\
900 :			if (iSAD < iMinSAD) \
901 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); iFound=0; } } \
902 :			}
903 :
904 :
905 :			#define CHECK_MV16_B_INTERPOL(FX,FY,X,Y) { \
906 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
907 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
908 :			{ \
909 :			iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \
910 :			iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\
911 :			if (iSAD < iMinSAD) \
912 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } } \
913 :			}
914 :
915 :
916 :			#define CHECK_MV16_B_INTERPOL_DIR(FX,FY,X,Y,D) { \
917 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
918 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
919 :			{ \
920 :			iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \
921 :			iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\
922 :			if (iSAD < iMinSAD) \
923 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); } } \
924 :			}
925 :
926 :
927 :			#define CHECK_MV16_B_INTERPOL_FOUND(FX,FY,X,Y,D) { \
928 :			if ( ((X) <= max_dx) && ((X) >= min_dx) \
929 :			&& ((Y) <= max_dy) && ((Y) >= min_dy) ) \
930 :			{ \
931 :			iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \
932 :			iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\
933 :			if (iSAD < iMinSAD) \
934 :			{ iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); iFound=0; } } \
935 :			}
936 :
937 :
938 :			#if (0==1)
939 :	edgomez	195	int32_t
940 :	chl	326	Diamond16_InterpolMainSearch(
941 :			const uint8_t * const f_pRef,
942 :			const uint8_t * const f_pRefH,
943 :			const uint8_t * const f_pRefV,
944 :			const uint8_t * const f_pRefHV,
945 :			const uint8_t * const cur,
946 :
947 :			const uint8_t * const b_pRef,
948 :			const uint8_t * const b_pRefH,
949 :			const uint8_t * const b_pRefV,
950 :			const uint8_t * const b_pRefHV,
951 :
952 :			const int x,
953 :			const int y,
954 :
955 :			const int f_start_x,
956 :			const int f_start_y,
957 :			const int b_start_x,
958 :			const int b_start_y,
959 :
960 :			int iMinSAD,
961 :			VECTOR * const f_currMV,
962 :			VECTOR * const b_currMV,
963 :
964 :			const int f_center_x,
965 :			const int f_center_y,
966 :			const int b_center_x,
967 :			const int b_center_y,
968 :
969 :			const int32_t min_dx,
970 :			const int32_t max_dx,
971 :			const int32_t min_dy,
972 :			const int32_t max_dy,
973 :			const int32_t iEdgedWidth,
974 :			const int32_t iDiamondSize,
975 :
976 :			const int32_t f_iFcode,
977 :			const int32_t b_iFcode,
978 :
979 :			const int32_t iQuant,
980 :			int iFound)
981 :			{
982 :			/* Do a diamond search around given starting point, return SAD of best */
983 :
984 :			int32_t f_iDirection = 0;
985 :			int32_t b_iDirection = 0;
986 :			int32_t iSAD;
987 :
988 :			VECTOR f_backupMV;
989 :			VECTOR b_backupMV;
990 :
991 :			f_backupMV.x = start_x;
992 :			f_backupMV.y = start_y;
993 :			b_backupMV.x = start_x;
994 :			b_backupMV.y = start_y;
995 :
996 :			/* It's one search with full Diamond pattern, and only 3 of 4 for all following diamonds */
997 :
998 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);
999 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);
1000 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);
1001 :			CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);
1002 :
1003 :			if (iDirection)
1004 :			while (!iFound) {
1005 :			iFound = 1;
1006 :			backupMV = *currMV;
1007 :
1008 :			if (iDirection != 2)
1009 :			CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,
1010 :			backupMV.y, 1);
1011 :			if (iDirection != 1)
1012 :			CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,
1013 :			backupMV.y, 2);
1014 :			if (iDirection != 4)
1015 :			CHECK_MV16_CANDIDATE_FOUND(backupMV.x,
1016 :			backupMV.y - iDiamondSize, 3);
1017 :			if (iDirection != 3)
1018 :			CHECK_MV16_CANDIDATE_FOUND(backupMV.x,
1019 :			backupMV.y + iDiamondSize, 4);
1020 :			} else {
1021 :			currMV->x = start_x;
1022 :			currMV->y = start_y;
1023 :			}
1024 :			return iMinSAD;
1025 :			}
1026 :			#endif
1027 :
1028 :
1029 :			int32_t
1030 :	edgomez	195	AdvDiamond8_MainSearch(const uint8_t * const pRef,
1031 :			const uint8_t * const pRefH,
1032 :			const uint8_t * const pRefV,
1033 :			const uint8_t * const pRefHV,
1034 :			const uint8_t * const cur,
1035 :			const int x,
1036 :			const int y,
1037 :	chl	326	int start_x,
1038 :			int start_y,
1039 :			int iMinSAD,
1040 :	edgomez	195	VECTOR * const currMV,
1041 :	chl	326	const int center_x,
1042 :			const int center_y,
1043 :	edgomez	195	const int32_t min_dx,
1044 :			const int32_t max_dx,
1045 :			const int32_t min_dy,
1046 :			const int32_t max_dy,
1047 :			const int32_t iEdgedWidth,
1048 :			const int32_t iDiamondSize,
1049 :			const int32_t iFcode,
1050 :			const int32_t iQuant,
1051 :			int iDirection)
1052 :	chl	181	{
1053 :
1054 :			int32_t iSAD;
1055 :
1056 :			/* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */
1057 :
1058 :	edgomez	195	if (iDirection) {
1059 :	chl	326	CHECK_MV8_CANDIDATE(start_x - iDiamondSize, start_y);
1060 :			CHECK_MV8_CANDIDATE(start_x + iDiamondSize, start_y);
1061 :			CHECK_MV8_CANDIDATE(start_x, start_y - iDiamondSize);
1062 :			CHECK_MV8_CANDIDATE(start_x, start_y + iDiamondSize);
1063 :	edgomez	195	} else {
1064 :			int bDirection = 1 + 2 + 4 + 8;
1065 :
1066 :			do {
1067 :	chl	181	iDirection = 0;
1068 :	edgomez	195	if (bDirection & 1) //we only want to check left if we came from the right (our last motion was to the left, up-left or down-left)
1069 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);
1070 :	chl	181
1071 :	edgomez	195	if (bDirection & 2)
1072 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);
1073 :	chl	181
1074 :	edgomez	195	if (bDirection & 4)
1075 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);
1076 :	chl	181
1077 :	edgomez	195	if (bDirection & 8)
1078 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);
1079 :	chl	181
1080 :			/* now we're doing diagonal checks near our candidate */
1081 :
1082 :	edgomez	195	if (iDirection) //checking if anything found
1083 :	chl	181	{
1084 :			bDirection = iDirection;
1085 :			iDirection = 0;
1086 :	chl	326	start_x = currMV->x;
1087 :			start_y = currMV->y;
1088 :	edgomez	195	if (bDirection & 3) //our candidate is left or right
1089 :	chl	181	{
1090 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);
1091 :			CHECK_MV8_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);
1092 :	edgomez	195	} else // what remains here is up or down
1093 :	chl	181	{
1094 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);
1095 :			CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);
1096 :	chl	181	}
1097 :
1098 :	edgomez	195	if (iDirection) {
1099 :			bDirection += iDirection;
1100 :	chl	326	start_x = currMV->x;
1101 :			start_y = currMV->y;
1102 :	chl	181	}
1103 :	edgomez	195	} else //about to quit, eh? not so fast....
1104 :	chl	181	{
1105 :	edgomez	195	switch (bDirection) {
1106 :	chl	181	case 2:
1107 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1108 :			start_y - iDiamondSize, 2 + 4);
1109 :			CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1110 :			start_y + iDiamondSize, 2 + 8);
1111 :	chl	181	break;
1112 :			case 1:
1113 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1114 :			start_y - iDiamondSize, 1 + 4);
1115 :			CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1116 :			start_y + iDiamondSize, 1 + 8);
1117 :	chl	181	break;
1118 :	edgomez	195	case 2 + 4:
1119 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1120 :			start_y - iDiamondSize, 1 + 4);
1121 :			CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1122 :			start_y - iDiamondSize, 2 + 4);
1123 :			CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1124 :			start_y + iDiamondSize, 2 + 8);
1125 :	chl	181	break;
1126 :			case 4:
1127 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1128 :			start_y - iDiamondSize, 2 + 4);
1129 :			CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1130 :			start_y - iDiamondSize, 1 + 4);
1131 :	chl	181	break;
1132 :			case 8:
1133 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1134 :			start_y + iDiamondSize, 2 + 8);
1135 :			CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1136 :			start_y + iDiamondSize, 1 + 8);
1137 :	chl	181	break;
1138 :	edgomez	195	case 1 + 4:
1139 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1140 :			start_y + iDiamondSize, 1 + 8);
1141 :			CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1142 :			start_y - iDiamondSize, 1 + 4);
1143 :			CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1144 :			start_y - iDiamondSize, 2 + 4);
1145 :	chl	181	break;
1146 :	edgomez	195	case 2 + 8:
1147 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1148 :			start_y - iDiamondSize, 1 + 4);
1149 :			CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1150 :			start_y + iDiamondSize, 1 + 8);
1151 :			CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1152 :			start_y + iDiamondSize, 2 + 8);
1153 :	chl	181	break;
1154 :	edgomez	195	case 1 + 8:
1155 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1156 :			start_y - iDiamondSize, 2 + 4);
1157 :			CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1158 :			start_y + iDiamondSize, 2 + 8);
1159 :			CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1160 :			start_y + iDiamondSize, 1 + 8);
1161 :	chl	181	break;
1162 :	edgomez	195	default: //1+2+4+8 == we didn't find anything at all
1163 :	chl	326	CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1164 :			start_y - iDiamondSize, 1 + 4);
1165 :			CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,
1166 :			start_y + iDiamondSize, 1 + 8);
1167 :			CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1168 :			start_y - iDiamondSize, 2 + 4);
1169 :			CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,
1170 :			start_y + iDiamondSize, 2 + 8);
1171 :	chl	181	break;
1172 :			}
1173 :	edgomez	195	if (!(iDirection))
1174 :			break; //ok, the end. really
1175 :			else {
1176 :			bDirection = iDirection;
1177 :	chl	326	start_x = currMV->x;
1178 :			start_y = currMV->y;
1179 :	chl	181	}
1180 :			}
1181 :			}
1182 :	edgomez	195	while (1); //forever
1183 :	chl	181	}
1184 :			return iMinSAD;
1185 :			}
1186 :
1187 :
1188 :	edgomez	195	int32_t
1189 :			Full8_MainSearch(const uint8_t * const pRef,
1190 :			const uint8_t * const pRefH,
1191 :			const uint8_t * const pRefV,
1192 :			const uint8_t * const pRefHV,
1193 :			const uint8_t * const cur,
1194 :			const int x,
1195 :			const int y,
1196 :	chl	326	const int start_x,
1197 :			const int start_y,
1198 :			int iMinSAD,
1199 :			VECTOR * const currMV,
1200 :			const int center_x,
1201 :			const int center_y,
1202 :	edgomez	195	const int32_t min_dx,
1203 :			const int32_t max_dx,
1204 :			const int32_t min_dy,
1205 :			const int32_t max_dy,
1206 :			const int32_t iEdgedWidth,
1207 :			const int32_t iDiamondSize,
1208 :			const int32_t iFcode,
1209 :			const int32_t iQuant,
1210 :			int iFound)
1211 :	chl	96	{
1212 :			int32_t iSAD;
1213 :	edgomez	195	int32_t dx, dy;
1214 :	chl	96	VECTOR backupMV;
1215 :	edgomez	195
1216 :	chl	326	backupMV.x = start_x;
1217 :			backupMV.y = start_y;
1218 :	chl	96
1219 :	edgomez	195	for (dx = min_dx; dx <= max_dx; dx += iDiamondSize)
1220 :			for (dy = min_dy; dy <= max_dy; dy += iDiamondSize)
1221 :			NOCHECK_MV8_CANDIDATE(dx, dy);
1222 :
1223 :	chl	96	return iMinSAD;
1224 :			}
1225 :
1226 :	ia64p	300	Halfpel8_RefineFuncPtr Halfpel8_Refine;
1227 :	chl	96
1228 :	edgomez	195	int32_t
1229 :			Halfpel16_Refine(const uint8_t * const pRef,
1230 :			const uint8_t * const pRefH,
1231 :			const uint8_t * const pRefV,
1232 :			const uint8_t * const pRefHV,
1233 :			const uint8_t * const cur,
1234 :			const int x,
1235 :			const int y,
1236 :			VECTOR * const currMV,
1237 :			int32_t iMinSAD,
1238 :	chl	326	const int center_x,
1239 :			const int center_y,
1240 :	edgomez	195	const int32_t min_dx,
1241 :			const int32_t max_dx,
1242 :			const int32_t min_dy,
1243 :			const int32_t max_dy,
1244 :			const int32_t iFcode,
1245 :			const int32_t iQuant,
1246 :			const int32_t iEdgedWidth)
1247 :	Isibaar	3	{
1248 :			/* Do a half-pel refinement (or rather a "smallest possible amount" refinement) */
1249 :
1250 :			int32_t iSAD;
1251 :			VECTOR backupMV = *currMV;
1252 :	edgomez	195
1253 :			CHECK_MV16_CANDIDATE(backupMV.x - 1, backupMV.y - 1);
1254 :			CHECK_MV16_CANDIDATE(backupMV.x, backupMV.y - 1);
1255 :			CHECK_MV16_CANDIDATE(backupMV.x + 1, backupMV.y - 1);
1256 :			CHECK_MV16_CANDIDATE(backupMV.x - 1, backupMV.y);
1257 :			CHECK_MV16_CANDIDATE(backupMV.x + 1, backupMV.y);
1258 :			CHECK_MV16_CANDIDATE(backupMV.x - 1, backupMV.y + 1);
1259 :			CHECK_MV16_CANDIDATE(backupMV.x, backupMV.y + 1);
1260 :			CHECK_MV16_CANDIDATE(backupMV.x + 1, backupMV.y + 1);
1261 :
1262 :	Isibaar	3	return iMinSAD;
1263 :			}
1264 :
1265 :			#define PMV_HALFPEL16 (PMV_HALFPELDIAMOND16\|PMV_HALFPELREFINE16)
1266 :
1267 :	chl	96
1268 :	chl	326
1269 :	edgomez	195	int32_t
1270 :			PMVfastSearch16(const uint8_t * const pRef,
1271 :			const uint8_t * const pRefH,
1272 :			const uint8_t * const pRefV,
1273 :			const uint8_t * const pRefHV,
1274 :			const IMAGE * const pCur,
1275 :			const int x,
1276 :			const int y,
1277 :	chl	326	const int start_x,
1278 :			const int start_y,
1279 :			const int center_x,
1280 :			const int center_y,
1281 :	edgomez	195	const uint32_t MotionFlags,
1282 :			const uint32_t iQuant,
1283 :			const uint32_t iFcode,
1284 :			const MBParam * const pParam,
1285 :			const MACROBLOCK * const pMBs,
1286 :			const MACROBLOCK * const prevMBs,
1287 :			VECTOR * const currMV,
1288 :			VECTOR * const currPMV)
1289 :	Isibaar	3	{
1290 :	edgomez	195	const uint32_t iWcount = pParam->mb_width;
1291 :	Isibaar	3	const int32_t iWidth = pParam->width;
1292 :			const int32_t iHeight = pParam->height;
1293 :	edgomez	195	const int32_t iEdgedWidth = pParam->edged_width;
1294 :	Isibaar	3
1295 :	edgomez	195	const uint8_t cur = pCur->y + x 16 + y * 16 * iEdgedWidth;
1296 :	Isibaar	3
1297 :			int32_t iDiamondSize;
1298 :	edgomez	195
1299 :	Isibaar	3	int32_t min_dx;
1300 :			int32_t max_dx;
1301 :			int32_t min_dy;
1302 :			int32_t max_dy;
1303 :	edgomez	195
1304 :	Isibaar	3	int32_t iFound;
1305 :
1306 :			VECTOR newMV;
1307 :	edgomez	195	VECTOR backupMV; /* just for PMVFAST */
1308 :
1309 :	Isibaar	3	VECTOR pmv[4];
1310 :			int32_t psad[4];
1311 :	chl	181
1312 :			MainSearch16FuncPtr MainSearchPtr;
1313 :	Isibaar	3
1314 :	edgomez	195	const MACROBLOCK const prevMB = prevMBs + x + y iWcount;
1315 :	Isibaar	3
1316 :	chl	259	int32_t threshA, threshB;
1317 :	edgomez	195	int32_t bPredEq;
1318 :			int32_t iMinSAD, iSAD;
1319 :
1320 :	Isibaar	3	/* Get maximum range */
1321 :	edgomez	195	get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,
1322 :			iFcode);
1323 :	Isibaar	3
1324 :			/* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */
1325 :
1326 :	edgomez	195	if (!(MotionFlags & PMV_HALFPEL16)) {
1327 :			min_dx = EVEN(min_dx);
1328 :			max_dx = EVEN(max_dx);
1329 :			min_dy = EVEN(min_dy);
1330 :			max_dy = EVEN(max_dy);
1331 :			}
1332 :	Isibaar	3
1333 :	edgomez	195	/* because we might use something like IF (dx>max_dx) THEN dx=max_dx; */
1334 :	chl	285	//bPredEq = get_pmvdata(pMBs, x, y, iWcount, 0, pmv, psad);
1335 :			bPredEq = get_pmvdata2(pMBs, iWcount, 0, x, y, 0, pmv, psad);
1336 :	Isibaar	3
1337 :	edgomez	195	if ((x == 0) && (y == 0)) {
1338 :			threshA = 512;
1339 :	Isibaar	3	threshB = 1024;
1340 :	edgomez	195	} else {
1341 :	Isibaar	3	threshA = psad[0];
1342 :	edgomez	195	threshB = threshA + 256;
1343 :			if (threshA < 512)
1344 :			threshA = 512;
1345 :			if (threshA > 1024)
1346 :			threshA = 1024;
1347 :			if (threshB > 1792)
1348 :			threshB = 1792;
1349 :	Isibaar	3	}
1350 :
1351 :	edgomez	195	iFound = 0;
1352 :
1353 :	Isibaar	3	/* Step 4: Calculate SAD around the Median prediction.
1354 :	edgomez	78	MinSAD=SAD
1355 :			If Motion Vector equal to Previous frame motion vector
1356 :			and MinSAD<PrevFrmSAD goto Step 10.
1357 :			If SAD<=256 goto Step 10.
1358 :	edgomez	195	*/
1359 :	Isibaar	3
1360 :	chl	326	currMV->x = start_x;
1361 :			currMV->y = start_y;
1362 :
1363 :	edgomez	195	if (!(MotionFlags & PMV_HALFPEL16)) { /* This should NOT be necessary! */
1364 :	Isibaar	3	currMV->x = EVEN(currMV->x);
1365 :			currMV->y = EVEN(currMV->y);
1366 :			}
1367 :	edgomez	195
1368 :			if (currMV->x > max_dx) {
1369 :			currMV->x = max_dx;
1370 :	edgomez	78	}
1371 :	edgomez	195	if (currMV->x < min_dx) {
1372 :			currMV->x = min_dx;
1373 :	edgomez	78	}
1374 :	edgomez	195	if (currMV->y > max_dy) {
1375 :			currMV->y = max_dy;
1376 :	edgomez	78	}
1377 :	edgomez	195	if (currMV->y < min_dy) {
1378 :			currMV->y = min_dy;
1379 :	edgomez	78	}
1380 :	edgomez	195
1381 :			iMinSAD =
1382 :			sad16(cur,
1383 :			get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 16, currMV,
1384 :			iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);
1385 :			iMinSAD +=
1386 :	chl	326	calc_delta_16(currMV->x - center_x, currMV->y - center_y,
1387 :	edgomez	195	(uint8_t) iFcode, iQuant);
1388 :
1389 :			if ((iMinSAD < 256) \|\|
1390 :			((MVequal(*currMV, prevMB->mvs[0])) &&
1391 :	chl	289	((int32_t) iMinSAD < prevMB->sad16))) {
1392 :	edgomez	195	if (iMinSAD < 2 * iQuant) // high chances for SKIP-mode
1393 :			{
1394 :			if (!MVzero(*currMV)) {
1395 :	chl	169	iMinSAD += MV16_00_BIAS;
1396 :	edgomez	195	CHECK_MV16_ZERO; // (0,0) saves space for letterboxed pictures
1397 :	chl	169	iMinSAD -= MV16_00_BIAS;
1398 :			}
1399 :			}
1400 :
1401 :	edgomez	195	if (MotionFlags & PMV_QUICKSTOP16)
1402 :	chl	96	goto PMVfast16_Terminate_without_Refine;
1403 :			if (MotionFlags & PMV_EARLYSTOP16)
1404 :			goto PMVfast16_Terminate_with_Refine;
1405 :	edgomez	78	}
1406 :	Isibaar	3
1407 :	chl	169
1408 :			/* Step 2 (lazy eval): Calculate Distance= \|MedianMVX\| + \|MedianMVY\| where MedianMV is the motion
1409 :			vector of the median.
1410 :			If PredEq=1 and MVpredicted = Previous Frame MV, set Found=2
1411 :			*/
1412 :
1413 :	edgomez	195	if ((bPredEq) && (MVequal(pmv[0], prevMB->mvs[0])))
1414 :			iFound = 2;
1415 :	chl	169
1416 :			/* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.
1417 :			Otherwise select large Diamond Search.
1418 :			*/
1419 :
1420 :	edgomez	195	if ((!MVzero(pmv[0])) \|\| (threshB < 1536) \|\| (bPredEq))
1421 :			iDiamondSize = 1; // halfpel!
1422 :	chl	169	else
1423 :	edgomez	195	iDiamondSize = 2; // halfpel!
1424 :	chl	169
1425 :	edgomez	195	if (!(MotionFlags & PMV_HALFPELDIAMOND16))
1426 :			iDiamondSize *= 2;
1427 :	chl	169
1428 :	Isibaar	3	/*
1429 :	edgomez	78	Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.
1430 :			Also calculate (0,0) but do not subtract offset.
1431 :			Let MinSAD be the smallest SAD up to this point.
1432 :	chl	140	If MV is (0,0) subtract offset.
1433 :	Isibaar	3	*/
1434 :
1435 :			// (0,0) is always possible
1436 :
1437 :	chl	169	if (!MVzero(pmv[0]))
1438 :			CHECK_MV16_ZERO;
1439 :	Isibaar	3
1440 :			// previous frame MV is always possible
1441 :	chl	169
1442 :			if (!MVzero(prevMB->mvs[0]))
1443 :	edgomez	195	if (!MVequal(prevMB->mvs[0], pmv[0]))
1444 :			CHECK_MV16_CANDIDATE(prevMB->mvs[0].x, prevMB->mvs[0].y);
1445 :
1446 :	Isibaar	3	// left neighbour, if allowed
1447 :	chl	169
1448 :			if (!MVzero(pmv[1]))
1449 :	edgomez	195	if (!MVequal(pmv[1], prevMB->mvs[0]))
1450 :			if (!MVequal(pmv[1], pmv[0])) {
1451 :			if (!(MotionFlags & PMV_HALFPEL16)) {
1452 :			pmv[1].x = EVEN(pmv[1].x);
1453 :			pmv[1].y = EVEN(pmv[1].y);
1454 :			}
1455 :	chl	169
1456 :	edgomez	195	CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);
1457 :			}
1458 :	Isibaar	3	// top neighbour, if allowed
1459 :	chl	169	if (!MVzero(pmv[2]))
1460 :	edgomez	195	if (!MVequal(pmv[2], prevMB->mvs[0]))
1461 :			if (!MVequal(pmv[2], pmv[0]))
1462 :			if (!MVequal(pmv[2], pmv[1])) {
1463 :			if (!(MotionFlags & PMV_HALFPEL16)) {
1464 :			pmv[2].x = EVEN(pmv[2].x);
1465 :			pmv[2].y = EVEN(pmv[2].y);
1466 :			}
1467 :			CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);
1468 :
1469 :	Isibaar	3	// top right neighbour, if allowed
1470 :	edgomez	195	if (!MVzero(pmv[3]))
1471 :			if (!MVequal(pmv[3], prevMB->mvs[0]))
1472 :			if (!MVequal(pmv[3], pmv[0]))
1473 :			if (!MVequal(pmv[3], pmv[1]))
1474 :			if (!MVequal(pmv[3], pmv[2])) {
1475 :			if (!(MotionFlags & PMV_HALFPEL16)) {
1476 :			pmv[3].x = EVEN(pmv[3].x);
1477 :			pmv[3].y = EVEN(pmv[3].y);
1478 :			}
1479 :			CHECK_MV16_CANDIDATE(pmv[3].x,
1480 :			pmv[3].y);
1481 :			}
1482 :			}
1483 :
1484 :			if ((MVzero(*currMV)) &&
1485 :			(!MVzero(pmv[0])) /* && (iMinSAD <= iQuant * 96) */ )
1486 :	chl	140	iMinSAD -= MV16_00_BIAS;
1487 :	Isibaar	3
1488 :	edgomez	195
1489 :	Isibaar	3	/* Step 6: If MinSAD <= thresa goto Step 10.
1490 :			If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.
1491 :			*/
1492 :
1493 :	edgomez	195	if ((iMinSAD <= threshA) \|\|
1494 :			(MVequal(*currMV, prevMB->mvs[0]) &&
1495 :	chl	289	((int32_t) iMinSAD < prevMB->sad16))) {
1496 :	edgomez	195	if (MotionFlags & PMV_QUICKSTOP16)
1497 :	chl	96	goto PMVfast16_Terminate_without_Refine;
1498 :			if (MotionFlags & PMV_EARLYSTOP16)
1499 :			goto PMVfast16_Terminate_with_Refine;
1500 :	edgomez	78	}
1501 :	Isibaar	3
1502 :
1503 :			/********** (Diamond Search) ************/
1504 :			/*
1505 :	edgomez	78	Step 7: Perform Diamond search, with either the small or large diamond.
1506 :			If Found=2 only examine one Diamond pattern, and afterwards goto step 10
1507 :			Step 8: If small diamond, iterate small diamond search pattern until motion vector lies in the center of the diamond.
1508 :			If center then goto step 10.
1509 :			Step 9: If large diamond, iterate large diamond search pattern until motion vector lies in the center.
1510 :			Refine by using small diamond and goto step 10.
1511 :	Isibaar	3	*/
1512 :
1513 :	chl	181	if (MotionFlags & PMV_USESQUARES16)
1514 :			MainSearchPtr = Square16_MainSearch;
1515 :	edgomez	195	else if (MotionFlags & PMV_ADVANCEDDIAMOND16)
1516 :			MainSearchPtr = AdvDiamond16_MainSearch;
1517 :	chl	181	else
1518 :	edgomez	195	MainSearchPtr = Diamond16_MainSearch;
1519 :	chl	181
1520 :	edgomez	195	backupMV = currMV; / save best prediction, actually only for EXTSEARCH */
1521 :	Isibaar	3
1522 :	chl	259
1523 :	Isibaar	3	/* default: use best prediction as starting point for one call of PMVfast_MainSearch */
1524 :	edgomez	195	iSAD =
1525 :	chl	326	(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,
1526 :			currMV->x, currMV->y, iMinSAD, &newMV, center_x, center_y,
1527 :			min_dx, max_dx,
1528 :	edgomez	195	min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,
1529 :			iQuant, iFound);
1530 :
1531 :			if (iSAD < iMinSAD) {
1532 :	Isibaar	3	*currMV = newMV;
1533 :			iMinSAD = iSAD;
1534 :			}
1535 :
1536 :	edgomez	195	if (MotionFlags & PMV_EXTSEARCH16) {
1537 :	Isibaar	3	/* extended: search (up to) two more times: orignal prediction and (0,0) */
1538 :
1539 :	edgomez	195	if (!(MVequal(pmv[0], backupMV))) {
1540 :			iSAD =
1541 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,
1542 :	chl	326	center_x, center_y, iMinSAD, &newMV, center_x, center_y,
1543 :	edgomez	195	min_dx, max_dx, min_dy, max_dy, iEdgedWidth,
1544 :			iDiamondSize, iFcode, iQuant, iFound);
1545 :
1546 :			if (iSAD < iMinSAD) {
1547 :			*currMV = newMV;
1548 :			iMinSAD = iSAD;
1549 :			}
1550 :	Isibaar	3	}
1551 :
1552 :	edgomez	195	if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {
1553 :			iSAD =
1554 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,
1555 :	chl	326	iMinSAD, &newMV, center_x, center_y,
1556 :			min_dx, max_dx, min_dy, max_dy,
1557 :			iEdgedWidth, iDiamondSize, iFcode,
1558 :	edgomez	195	iQuant, iFound);
1559 :
1560 :			if (iSAD < iMinSAD) {
1561 :			*currMV = newMV;
1562 :			iMinSAD = iSAD;
1563 :			}
1564 :	Isibaar	3	}
1565 :			}
1566 :
1567 :			/*
1568 :	edgomez	78	Step 10: The motion vector is chosen according to the block corresponding to MinSAD.
1569 :	Isibaar	3	*/
1570 :
1571 :	edgomez	195	PMVfast16_Terminate_with_Refine:
1572 :			if (MotionFlags & PMV_HALFPELREFINE16) // perform final half-pel step
1573 :			iMinSAD =
1574 :			Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,
1575 :	chl	326	iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,
1576 :	edgomez	195	iFcode, iQuant, iEdgedWidth);
1577 :	Isibaar	3
1578 :	edgomez	195	PMVfast16_Terminate_without_Refine:
1579 :	chl	326	currPMV->x = currMV->x - center_x;
1580 :			currPMV->y = currMV->y - center_y;
1581 :	Isibaar	3	return iMinSAD;
1582 :			}
1583 :
1584 :
1585 :
1586 :
1587 :
1588 :
1589 :	edgomez	195	int32_t
1590 :			Diamond8_MainSearch(const uint8_t * const pRef,
1591 :			const uint8_t * const pRefH,
1592 :			const uint8_t * const pRefV,
1593 :			const uint8_t * const pRefHV,
1594 :			const uint8_t * const cur,
1595 :			const int x,
1596 :			const int y,
1597 :	chl	326	int32_t start_x,
1598 :			int32_t start_y,
1599 :	edgomez	195	int32_t iMinSAD,
1600 :			VECTOR * const currMV,
1601 :	chl	326	const int center_x,
1602 :			const int center_y,
1603 :	edgomez	195	const int32_t min_dx,
1604 :			const int32_t max_dx,
1605 :			const int32_t min_dy,
1606 :			const int32_t max_dy,
1607 :			const int32_t iEdgedWidth,
1608 :			const int32_t iDiamondSize,
1609 :			const int32_t iFcode,
1610 :			const int32_t iQuant,
1611 :			int iFound)
1612 :	Isibaar	3	{
1613 :			/* Do a diamond search around given starting point, return SAD of best */
1614 :
1615 :	edgomez	195	int32_t iDirection = 0;
1616 :	Isibaar	3	int32_t iSAD;
1617 :			VECTOR backupMV;
1618 :	edgomez	195
1619 :	chl	326	backupMV.x = start_x;
1620 :			backupMV.y = start_y;
1621 :	edgomez	195
1622 :	Isibaar	3	/* It's one search with full Diamond pattern, and only 3 of 4 for all following diamonds */
1623 :
1624 :	edgomez	195	CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);
1625 :			CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);
1626 :			CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);
1627 :			CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);
1628 :	Isibaar	3
1629 :			if (iDirection)
1630 :	edgomez	195	while (!iFound) {
1631 :			iFound = 1;
1632 :			backupMV = *currMV; // since iDirection!=0, this is well defined!
1633 :
1634 :			if (iDirection != 2)
1635 :			CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,
1636 :			backupMV.y, 1);
1637 :			if (iDirection != 1)
1638 :			CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,
1639 :			backupMV.y, 2);
1640 :			if (iDirection != 4)
1641 :			CHECK_MV8_CANDIDATE_FOUND(backupMV.x,
1642 :			backupMV.y - iDiamondSize, 3);
1643 :			if (iDirection != 3)
1644 :			CHECK_MV8_CANDIDATE_FOUND(backupMV.x,
1645 :			backupMV.y + iDiamondSize, 4);
1646 :			} else {
1647 :	chl	326	currMV->x = start_x;
1648 :			currMV->y = start_y;
1649 :	edgomez	78	}
1650 :	Isibaar	3	return iMinSAD;
1651 :			}
1652 :
1653 :	edgomez	195	int32_t
1654 :	ia64p	300	Halfpel8_Refine_c(const uint8_t * const pRef,
1655 :	edgomez	195	const uint8_t * const pRefH,
1656 :			const uint8_t * const pRefV,
1657 :			const uint8_t * const pRefHV,
1658 :			const uint8_t * const cur,
1659 :			const int x,
1660 :			const int y,
1661 :			VECTOR * const currMV,
1662 :			int32_t iMinSAD,
1663 :	chl	326	const int center_x,
1664 :			const int center_y,
1665 :	edgomez	195	const int32_t min_dx,
1666 :			const int32_t max_dx,
1667 :			const int32_t min_dy,
1668 :			const int32_t max_dy,
1669 :			const int32_t iFcode,
1670 :			const int32_t iQuant,
1671 :			const int32_t iEdgedWidth)
1672 :	Isibaar	3	{
1673 :			/* Do a half-pel refinement (or rather a "smallest possible amount" refinement) */
1674 :
1675 :			int32_t iSAD;
1676 :			VECTOR backupMV = *currMV;
1677 :	edgomez	195
1678 :			CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y - 1);
1679 :			CHECK_MV8_CANDIDATE(backupMV.x, backupMV.y - 1);
1680 :			CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y - 1);
1681 :			CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y);
1682 :			CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y);
1683 :			CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y + 1);
1684 :			CHECK_MV8_CANDIDATE(backupMV.x, backupMV.y + 1);
1685 :			CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y + 1);
1686 :
1687 :	Isibaar	3	return iMinSAD;
1688 :			}
1689 :
1690 :
1691 :			#define PMV_HALFPEL8 (PMV_HALFPELDIAMOND8\|PMV_HALFPELREFINE8)
1692 :
1693 :	edgomez	195	int32_t
1694 :			PMVfastSearch8(const uint8_t * const pRef,
1695 :			const uint8_t * const pRefH,
1696 :			const uint8_t * const pRefV,
1697 :			const uint8_t * const pRefHV,
1698 :			const IMAGE * const pCur,
1699 :			const int x,
1700 :			const int y,
1701 :			const int start_x,
1702 :			const int start_y,
1703 :	chl	326	const int center_x,
1704 :			const int center_y,
1705 :	edgomez	195	const uint32_t MotionFlags,
1706 :			const uint32_t iQuant,
1707 :			const uint32_t iFcode,
1708 :			const MBParam * const pParam,
1709 :			const MACROBLOCK * const pMBs,
1710 :			const MACROBLOCK * const prevMBs,
1711 :			VECTOR * const currMV,
1712 :			VECTOR * const currPMV)
1713 :	Isibaar	3	{
1714 :	edgomez	195	const uint32_t iWcount = pParam->mb_width;
1715 :	Isibaar	3	const int32_t iWidth = pParam->width;
1716 :			const int32_t iHeight = pParam->height;
1717 :	edgomez	195	const int32_t iEdgedWidth = pParam->edged_width;
1718 :	Isibaar	3
1719 :	edgomez	195	const uint8_t cur = pCur->y + x 8 + y * 8 * iEdgedWidth;
1720 :	Isibaar	3
1721 :			int32_t iDiamondSize;
1722 :
1723 :			int32_t min_dx;
1724 :			int32_t max_dx;
1725 :			int32_t min_dy;
1726 :			int32_t max_dy;
1727 :	edgomez	195
1728 :	Isibaar	3	VECTOR pmv[4];
1729 :			int32_t psad[4];
1730 :			VECTOR newMV;
1731 :			VECTOR backupMV;
1732 :	edgomez	170	VECTOR startMV;
1733 :	Isibaar	3
1734 :	edgomez	195	// const MACROBLOCK * const pMB = pMBs + (x>>1) + (y>>1) * iWcount;
1735 :			const MACROBLOCK const prevMB = prevMBs + (x >> 1) + (y >> 1) iWcount;
1736 :	Isibaar	3
1737 :	chl	259	int32_t threshA, threshB;
1738 :	edgomez	195	int32_t iFound, bPredEq;
1739 :			int32_t iMinSAD, iSAD;
1740 :	Isibaar	3
1741 :	edgomez	195	int32_t iSubBlock = (y & 1) + (y & 1) + (x & 1);
1742 :
1743 :	chl	181	MainSearch8FuncPtr MainSearchPtr;
1744 :
1745 :	edgomez	170	/* Init variables */
1746 :			startMV.x = start_x;
1747 :			startMV.y = start_y;
1748 :
1749 :			/* Get maximum range */
1750 :	edgomez	195	get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 8, iWidth, iHeight,
1751 :			iFcode);
1752 :	Isibaar	3
1753 :	edgomez	195	if (!(MotionFlags & PMV_HALFPELDIAMOND8)) {
1754 :			min_dx = EVEN(min_dx);
1755 :			max_dx = EVEN(max_dx);
1756 :			min_dy = EVEN(min_dy);
1757 :			max_dy = EVEN(max_dy);
1758 :			}
1759 :	Isibaar	3
1760 :	edgomez	195	/* because we might use IF (dx>max_dx) THEN dx=max_dx; */
1761 :	chl	285	//bPredEq = get_pmvdata(pMBs, (x >> 1), (y >> 1), iWcount, iSubBlock, pmv, psad);
1762 :			bPredEq = get_pmvdata2(pMBs, iWcount, 0, (x >> 1), (y >> 1), iSubBlock, pmv, psad);
1763 :	Isibaar	3
1764 :	edgomez	195	if ((x == 0) && (y == 0)) {
1765 :			threshA = 512 / 4;
1766 :			threshB = 1024 / 4;
1767 :
1768 :			} else {
1769 :	chl	326	threshA = psad[0] / 4; /* good estimate? */
1770 :	edgomez	195	threshB = threshA + 256 / 4;
1771 :			if (threshA < 512 / 4)
1772 :			threshA = 512 / 4;
1773 :			if (threshA > 1024 / 4)
1774 :			threshA = 1024 / 4;
1775 :			if (threshB > 1792 / 4)
1776 :			threshB = 1792 / 4;
1777 :	Isibaar	3	}
1778 :
1779 :	edgomez	195	iFound = 0;
1780 :
1781 :	Isibaar	3	/* Step 4: Calculate SAD around the Median prediction.
1782 :	edgomez	78	MinSAD=SAD
1783 :			If Motion Vector equal to Previous frame motion vector
1784 :			and MinSAD<PrevFrmSAD goto Step 10.
1785 :			If SAD<=256 goto Step 10.
1786 :	edgomez	195	*/
1787 :	Isibaar	3
1788 :
1789 :			// Prepare for main loop
1790 :
1791 :	edgomez	195	// if (MotionFlags & PMV_USESQUARES8)
1792 :			// MainSearchPtr = Square8_MainSearch;
1793 :			// else
1794 :	chl	181
1795 :			if (MotionFlags & PMV_ADVANCEDDIAMOND8)
1796 :			MainSearchPtr = AdvDiamond8_MainSearch;
1797 :			else
1798 :			MainSearchPtr = Diamond8_MainSearch;
1799 :
1800 :
1801 :	chl	169	*currMV = startMV;
1802 :	edgomez	195
1803 :			iMinSAD =
1804 :			sad8(cur,
1805 :			get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 8, currMV,
1806 :			iEdgedWidth), iEdgedWidth);
1807 :			iMinSAD +=
1808 :	chl	326	calc_delta_8(currMV->x - center_x, currMV->y - center_y,
1809 :	edgomez	195	(uint8_t) iFcode, iQuant);
1810 :
1811 :			if ((iMinSAD < 256 / 4) \|\| ((MVequal(*currMV, prevMB->mvs[iSubBlock]))
1812 :	chl	289	&& ((int32_t) iMinSAD <
1813 :	edgomez	195	prevMB->sad8[iSubBlock]))) {
1814 :			if (MotionFlags & PMV_QUICKSTOP16)
1815 :	chl	96	goto PMVfast8_Terminate_without_Refine;
1816 :			if (MotionFlags & PMV_EARLYSTOP16)
1817 :			goto PMVfast8_Terminate_with_Refine;
1818 :	edgomez	78	}
1819 :	Isibaar	3
1820 :	chl	169	/* Step 2 (lazy eval): Calculate Distance= \|MedianMVX\| + \|MedianMVY\| where MedianMV is the motion
1821 :			vector of the median.
1822 :			If PredEq=1 and MVpredicted = Previous Frame MV, set Found=2
1823 :			*/
1824 :	chl	96
1825 :	edgomez	195	if ((bPredEq) && (MVequal(pmv[0], prevMB->mvs[iSubBlock])))
1826 :			iFound = 2;
1827 :	chl	169
1828 :			/* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.
1829 :			Otherwise select large Diamond Search.
1830 :			*/
1831 :
1832 :	edgomez	195	if ((!MVzero(pmv[0])) \|\| (threshB < 1536 / 4) \|\| (bPredEq))
1833 :			iDiamondSize = 1; // 1 halfpel!
1834 :	chl	169	else
1835 :	edgomez	195	iDiamondSize = 2; // 2 halfpel = 1 full pixel!
1836 :	chl	169
1837 :	edgomez	195	if (!(MotionFlags & PMV_HALFPELDIAMOND8))
1838 :			iDiamondSize *= 2;
1839 :	chl	169
1840 :
1841 :	Isibaar	3	/*
1842 :	edgomez	78	Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.
1843 :			Also calculate (0,0) but do not subtract offset.
1844 :			Let MinSAD be the smallest SAD up to this point.
1845 :	chl	140	If MV is (0,0) subtract offset.
1846 :	Isibaar	3	*/
1847 :
1848 :	chl	169	// the median prediction might be even better than mv16
1849 :	Isibaar	3
1850 :	edgomez	195	if (!MVequal(pmv[0], startMV))
1851 :	chl	326	CHECK_MV8_CANDIDATE(center_x, center_y);
1852 :	chl	169
1853 :			// (0,0) if needed
1854 :			if (!MVzero(pmv[0]))
1855 :	edgomez	195	if (!MVzero(startMV))
1856 :			CHECK_MV8_ZERO;
1857 :	Isibaar	3
1858 :	chl	169	// previous frame MV if needed
1859 :			if (!MVzero(prevMB->mvs[iSubBlock]))
1860 :	edgomez	195	if (!MVequal(prevMB->mvs[iSubBlock], startMV))
1861 :			if (!MVequal(prevMB->mvs[iSubBlock], pmv[0]))
1862 :			CHECK_MV8_CANDIDATE(prevMB->mvs[iSubBlock].x,
1863 :			prevMB->mvs[iSubBlock].y);
1864 :	chl	169
1865 :	edgomez	195	if ((iMinSAD <= threshA) \|\|
1866 :			(MVequal(*currMV, prevMB->mvs[iSubBlock]) &&
1867 :	chl	289	((int32_t) iMinSAD < prevMB->sad8[iSubBlock]))) {
1868 :	edgomez	195	if (MotionFlags & PMV_QUICKSTOP16)
1869 :	chl	169	goto PMVfast8_Terminate_without_Refine;
1870 :			if (MotionFlags & PMV_EARLYSTOP16)
1871 :			goto PMVfast8_Terminate_with_Refine;
1872 :			}
1873 :
1874 :			// left neighbour, if allowed and needed
1875 :			if (!MVzero(pmv[1]))
1876 :	edgomez	195	if (!MVequal(pmv[1], startMV))
1877 :			if (!MVequal(pmv[1], prevMB->mvs[iSubBlock]))
1878 :			if (!MVequal(pmv[1], pmv[0])) {
1879 :			if (!(MotionFlags & PMV_HALFPEL8)) {
1880 :			pmv[1].x = EVEN(pmv[1].x);
1881 :			pmv[1].y = EVEN(pmv[1].y);
1882 :			}
1883 :			CHECK_MV8_CANDIDATE(pmv[1].x, pmv[1].y);
1884 :			}
1885 :	chl	169	// top neighbour, if allowed and needed
1886 :			if (!MVzero(pmv[2]))
1887 :	edgomez	195	if (!MVequal(pmv[2], startMV))
1888 :			if (!MVequal(pmv[2], prevMB->mvs[iSubBlock]))
1889 :			if (!MVequal(pmv[2], pmv[0]))
1890 :			if (!MVequal(pmv[2], pmv[1])) {
1891 :			if (!(MotionFlags & PMV_HALFPEL8)) {
1892 :			pmv[2].x = EVEN(pmv[2].x);
1893 :			pmv[2].y = EVEN(pmv[2].y);
1894 :			}
1895 :			CHECK_MV8_CANDIDATE(pmv[2].x, pmv[2].y);
1896 :
1897 :	chl	169	// top right neighbour, if allowed and needed
1898 :	edgomez	195	if (!MVzero(pmv[3]))
1899 :			if (!MVequal(pmv[3], startMV))
1900 :			if (!MVequal(pmv[3], prevMB->mvs[iSubBlock]))
1901 :			if (!MVequal(pmv[3], pmv[0]))
1902 :			if (!MVequal(pmv[3], pmv[1]))
1903 :			if (!MVequal(pmv[3], pmv[2])) {
1904 :			if (!
1905 :			(MotionFlags &
1906 :			PMV_HALFPEL8)) {
1907 :			pmv[3].x = EVEN(pmv[3].x);
1908 :			pmv[3].y = EVEN(pmv[3].y);
1909 :			}
1910 :			CHECK_MV8_CANDIDATE(pmv[3].x,
1911 :			pmv[3].y);
1912 :			}
1913 :			}
1914 :	Isibaar	3
1915 :	edgomez	195	if ((MVzero(*currMV)) &&
1916 :			(!MVzero(pmv[0])) /* && (iMinSAD <= iQuant * 96) */ )
1917 :	chl	140	iMinSAD -= MV8_00_BIAS;
1918 :
1919 :
1920 :	Isibaar	3	/* Step 6: If MinSAD <= thresa goto Step 10.
1921 :			If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.
1922 :			*/
1923 :
1924 :	edgomez	195	if ((iMinSAD <= threshA) \|\|
1925 :			(MVequal(*currMV, prevMB->mvs[iSubBlock]) &&
1926 :	chl	289	((int32_t) iMinSAD < prevMB->sad8[iSubBlock]))) {
1927 :	edgomez	195	if (MotionFlags & PMV_QUICKSTOP16)
1928 :	chl	96	goto PMVfast8_Terminate_without_Refine;
1929 :			if (MotionFlags & PMV_EARLYSTOP16)
1930 :			goto PMVfast8_Terminate_with_Refine;
1931 :	edgomez	78	}
1932 :	Isibaar	3
1933 :			/********** (Diamond Search) ************/
1934 :			/*
1935 :	edgomez	78	Step 7: Perform Diamond search, with either the small or large diamond.
1936 :			If Found=2 only examine one Diamond pattern, and afterwards goto step 10
1937 :			Step 8: If small diamond, iterate small diamond search pattern until motion vector lies in the center of the diamond.
1938 :			If center then goto step 10.
1939 :			Step 9: If large diamond, iterate large diamond search pattern until motion vector lies in the center.
1940 :			Refine by using small diamond and goto step 10.
1941 :	Isibaar	3	*/
1942 :
1943 :	edgomez	195	backupMV = currMV; / save best prediction, actually only for EXTSEARCH */
1944 :	Isibaar	3
1945 :			/* default: use best prediction as starting point for one call of PMVfast_MainSearch */
1946 :	edgomez	195	iSAD =
1947 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,
1948 :	chl	326	currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,
1949 :	edgomez	195	min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,
1950 :			iQuant, iFound);
1951 :
1952 :			if (iSAD < iMinSAD) {
1953 :	Isibaar	3	*currMV = newMV;
1954 :			iMinSAD = iSAD;
1955 :			}
1956 :
1957 :	edgomez	195	if (MotionFlags & PMV_EXTSEARCH8) {
1958 :	Isibaar	3	/* extended: search (up to) two more times: orignal prediction and (0,0) */
1959 :
1960 :	edgomez	195	if (!(MVequal(pmv[0], backupMV))) {
1961 :			iSAD =
1962 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,
1963 :	chl	326	pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,
1964 :	edgomez	195	min_dx, max_dx, min_dy, max_dy, iEdgedWidth,
1965 :			iDiamondSize, iFcode, iQuant, iFound);
1966 :
1967 :			if (iSAD < iMinSAD) {
1968 :			*currMV = newMV;
1969 :			iMinSAD = iSAD;
1970 :			}
1971 :	Isibaar	3	}
1972 :
1973 :	edgomez	195	if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {
1974 :			iSAD =
1975 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,
1976 :	chl	326	iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,
1977 :	edgomez	195	max_dy, iEdgedWidth, iDiamondSize, iFcode,
1978 :			iQuant, iFound);
1979 :
1980 :			if (iSAD < iMinSAD) {
1981 :			*currMV = newMV;
1982 :			iMinSAD = iSAD;
1983 :			}
1984 :	Isibaar	3	}
1985 :			}
1986 :
1987 :			/* Step 10: The motion vector is chosen according to the block corresponding to MinSAD.
1988 :	edgomez	78	By performing an optional local half-pixel search, we can refine this result even further.
1989 :	Isibaar	3	*/
1990 :
1991 :	edgomez	195	PMVfast8_Terminate_with_Refine:
1992 :			if (MotionFlags & PMV_HALFPELREFINE8) // perform final half-pel step
1993 :			iMinSAD =
1994 :			Halfpel8_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,
1995 :	chl	326	iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,
1996 :	edgomez	195	iFcode, iQuant, iEdgedWidth);
1997 :	Isibaar	3
1998 :	edgomez	195
1999 :			PMVfast8_Terminate_without_Refine:
2000 :	chl	326	currPMV->x = currMV->x - center_x;
2001 :			currPMV->y = currMV->y - center_y;
2002 :	edgomez	195
2003 :	Isibaar	3	return iMinSAD;
2004 :			}
2005 :	chl	96
2006 :	edgomez	195	int32_t
2007 :			EPZSSearch16(const uint8_t * const pRef,
2008 :			const uint8_t * const pRefH,
2009 :			const uint8_t * const pRefV,
2010 :			const uint8_t * const pRefHV,
2011 :			const IMAGE * const pCur,
2012 :			const int x,
2013 :			const int y,
2014 :	chl	326	const int start_x,
2015 :			const int start_y,
2016 :			const int center_x,
2017 :			const int center_y,
2018 :	edgomez	195	const uint32_t MotionFlags,
2019 :			const uint32_t iQuant,
2020 :			const uint32_t iFcode,
2021 :			const MBParam * const pParam,
2022 :			const MACROBLOCK * const pMBs,
2023 :			const MACROBLOCK * const prevMBs,
2024 :			VECTOR * const currMV,
2025 :			VECTOR * const currPMV)
2026 :	chl	96	{
2027 :	edgomez	195	const uint32_t iWcount = pParam->mb_width;
2028 :			const uint32_t iHcount = pParam->mb_height;
2029 :	chl	96
2030 :			const int32_t iWidth = pParam->width;
2031 :			const int32_t iHeight = pParam->height;
2032 :	edgomez	195	const int32_t iEdgedWidth = pParam->edged_width;
2033 :	chl	96
2034 :	edgomez	195	const uint8_t cur = pCur->y + x 16 + y * 16 * iEdgedWidth;
2035 :	chl	96
2036 :			int32_t min_dx;
2037 :			int32_t max_dx;
2038 :			int32_t min_dy;
2039 :			int32_t max_dy;
2040 :	edgomez	195
2041 :	chl	96	VECTOR newMV;
2042 :			VECTOR backupMV;
2043 :	edgomez	195
2044 :	chl	96	VECTOR pmv[4];
2045 :			int32_t psad[8];
2046 :
2047 :	edgomez	195	static MACROBLOCK *oldMBs = NULL;
2048 :
2049 :			// const MACROBLOCK * const pMB = pMBs + x + y * iWcount;
2050 :			const MACROBLOCK const prevMB = prevMBs + x + y iWcount;
2051 :			MACROBLOCK *oldMB = NULL;
2052 :
2053 :	chl	259	int32_t thresh2;
2054 :	edgomez	195	int32_t bPredEq;
2055 :			int32_t iMinSAD, iSAD = 9999;
2056 :	chl	96
2057 :	chl	181	MainSearch16FuncPtr MainSearchPtr;
2058 :	chl	96
2059 :	edgomez	195	if (oldMBs == NULL) {
2060 :			oldMBs = (MACROBLOCK ) calloc(iWcount iHcount, sizeof(MACROBLOCK));
2061 :			// fprintf(stderr,"allocated %d bytes for oldMBs\n",iWcountiHcountsizeof(MACROBLOCK));
2062 :	chl	96	}
2063 :			oldMB = oldMBs + x + y * iWcount;
2064 :
2065 :			/* Get maximum range */
2066 :	edgomez	195	get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,
2067 :			iFcode);
2068 :	chl	96
2069 :	edgomez	195	if (!(MotionFlags & PMV_HALFPEL16)) {
2070 :			min_dx = EVEN(min_dx);
2071 :			max_dx = EVEN(max_dx);
2072 :			min_dy = EVEN(min_dy);
2073 :			max_dy = EVEN(max_dy);
2074 :			}
2075 :			/* because we might use something like IF (dx>max_dx) THEN dx=max_dx; */
2076 :	chl	285	//bPredEq = get_pmvdata(pMBs, x, y, iWcount, 0, pmv, psad);
2077 :			bPredEq = get_pmvdata2(pMBs, iWcount, 0, x, y, 0, pmv, psad);
2078 :	chl	96
2079 :			/* Step 4: Calculate SAD around the Median prediction.
2080 :			MinSAD=SAD
2081 :			If Motion Vector equal to Previous frame motion vector
2082 :			and MinSAD<PrevFrmSAD goto Step 10.
2083 :			If SAD<=256 goto Step 10.
2084 :	edgomez	195	*/
2085 :	chl	96
2086 :			// Prepare for main loop
2087 :
2088 :	chl	326	currMV->x = start_x;
2089 :			currMV->y = start_y;
2090 :
2091 :	edgomez	195	if (!(MotionFlags & PMV_HALFPEL16)) {
2092 :	chl	96	currMV->x = EVEN(currMV->x);
2093 :			currMV->y = EVEN(currMV->y);
2094 :			}
2095 :
2096 :	edgomez	195	if (currMV->x > max_dx)
2097 :			currMV->x = max_dx;
2098 :			if (currMV->x < min_dx)
2099 :			currMV->x = min_dx;
2100 :			if (currMV->y > max_dy)
2101 :			currMV->y = max_dy;
2102 :			if (currMV->y < min_dy)
2103 :			currMV->y = min_dy;
2104 :
2105 :			/*************** This is predictor SET A: only median prediction ****************/
2106 :
2107 :			iMinSAD =
2108 :			sad16(cur,
2109 :			get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 16, currMV,
2110 :			iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);
2111 :			iMinSAD +=
2112 :	chl	326	calc_delta_16(currMV->x - center_x, currMV->y - center_y,
2113 :	edgomez	195	(uint8_t) iFcode, iQuant);
2114 :
2115 :	chl	96	// thresh1 is fixed to 256
2116 :	edgomez	195	if ((iMinSAD < 256) \|\|
2117 :			((MVequal(*currMV, prevMB->mvs[0])) &&
2118 :	chl	289	((int32_t) iMinSAD < prevMB->sad16))) {
2119 :	edgomez	195	if (MotionFlags & PMV_QUICKSTOP16)
2120 :			goto EPZS16_Terminate_without_Refine;
2121 :			if (MotionFlags & PMV_EARLYSTOP16)
2122 :			goto EPZS16_Terminate_with_Refine;
2123 :			}
2124 :	chl	96
2125 :	edgomez	195	/************ This is predictor SET B: (0,0), prev.frame MV, neighbours ************/
2126 :	chl	96
2127 :			// previous frame MV
2128 :	edgomez	195	CHECK_MV16_CANDIDATE(prevMB->mvs[0].x, prevMB->mvs[0].y);
2129 :	chl	96
2130 :			// set threshhold based on Min of Prediction and SAD of collocated block
2131 :			// CHECK_MV16 always uses iSAD for the SAD of last vector to check, so now iSAD is what we want
2132 :
2133 :	edgomez	195	if ((x == 0) && (y == 0)) {
2134 :			thresh2 = 512;
2135 :			} else {
2136 :	chl	96	/* T_k = 1.2 * MIN(SAD_top,SAD_left,SAD_topleft,SAD_coll) +128; [Tourapis, 2002] */
2137 :
2138 :	edgomez	195	thresh2 = MIN(psad[0], iSAD) * 6 / 5 + 128;
2139 :	chl	96	}
2140 :
2141 :			// MV=(0,0) is often a good choice
2142 :
2143 :			CHECK_MV16_ZERO;
2144 :
2145 :	edgomez	195
2146 :	chl	96	// left neighbour, if allowed
2147 :	edgomez	195	if (x != 0) {
2148 :			if (!(MotionFlags & PMV_HALFPEL16)) {
2149 :			pmv[1].x = EVEN(pmv[1].x);
2150 :	chl	96	pmv[1].y = EVEN(pmv[1].y);
2151 :			}
2152 :	edgomez	195	CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);
2153 :	chl	96	}
2154 :			// top neighbour, if allowed
2155 :	edgomez	195	if (y != 0) {
2156 :			if (!(MotionFlags & PMV_HALFPEL16)) {
2157 :			pmv[2].x = EVEN(pmv[2].x);
2158 :	chl	96	pmv[2].y = EVEN(pmv[2].y);
2159 :			}
2160 :	edgomez	195	CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);
2161 :
2162 :	chl	96	// top right neighbour, if allowed
2163 :	edgomez	195	if ((uint32_t) x != (iWcount - 1)) {
2164 :			if (!(MotionFlags & PMV_HALFPEL16)) {
2165 :			pmv[3].x = EVEN(pmv[3].x);
2166 :	chl	96	pmv[3].y = EVEN(pmv[3].y);
2167 :			}
2168 :	edgomez	195	CHECK_MV16_CANDIDATE(pmv[3].x, pmv[3].y);
2169 :	chl	96	}
2170 :			}
2171 :
2172 :			/* Terminate if MinSAD <= T_2
2173 :			Terminate if MV[t] == MV[t-1] and MinSAD[t] <= MinSAD[t-1]
2174 :			*/
2175 :
2176 :	edgomez	195	if ((iMinSAD <= thresh2)
2177 :			\|\| (MVequal(*currMV, prevMB->mvs[0]) &&
2178 :	chl	289	((int32_t) iMinSAD <= prevMB->sad16))) {
2179 :	edgomez	195	if (MotionFlags & PMV_QUICKSTOP16)
2180 :			goto EPZS16_Terminate_without_Refine;
2181 :			if (MotionFlags & PMV_EARLYSTOP16)
2182 :			goto EPZS16_Terminate_with_Refine;
2183 :			}
2184 :	chl	96
2185 :			/*** predictor SET C: acceleration MV (new!), neighbours in prev. frame(new!) **/
2186 :
2187 :	edgomez	195	backupMV = prevMB->mvs[0]; // collocated MV
2188 :			backupMV.x += (prevMB->mvs[0].x - oldMB->mvs[0].x); // acceleration X
2189 :			backupMV.y += (prevMB->mvs[0].y - oldMB->mvs[0].y); // acceleration Y
2190 :	chl	96
2191 :	edgomez	195	CHECK_MV16_CANDIDATE(backupMV.x, backupMV.y);
2192 :	chl	96
2193 :			// left neighbour
2194 :	edgomez	195	if (x != 0)
2195 :			CHECK_MV16_CANDIDATE((prevMB - 1)->mvs[0].x, (prevMB - 1)->mvs[0].y);
2196 :	chl	96
2197 :			// top neighbour
2198 :			if (y != 0)
2199 :	edgomez	195	CHECK_MV16_CANDIDATE((prevMB - iWcount)->mvs[0].x,
2200 :			(prevMB - iWcount)->mvs[0].y);
2201 :	chl	96
2202 :			// right neighbour, if allowed (this value is not written yet, so take it from pMB->mvs
2203 :
2204 :	edgomez	195	if ((uint32_t) x != iWcount - 1)
2205 :			CHECK_MV16_CANDIDATE((prevMB + 1)->mvs[0].x, (prevMB + 1)->mvs[0].y);
2206 :	chl	96
2207 :			// bottom neighbour, dito
2208 :	edgomez	195	if ((uint32_t) y != iHcount - 1)
2209 :			CHECK_MV16_CANDIDATE((prevMB + iWcount)->mvs[0].x,
2210 :			(prevMB + iWcount)->mvs[0].y);
2211 :	chl	96
2212 :			/* Terminate if MinSAD <= T_3 (here T_3 = T_2) */
2213 :	edgomez	195	if (iMinSAD <= thresh2) {
2214 :			if (MotionFlags & PMV_QUICKSTOP16)
2215 :			goto EPZS16_Terminate_without_Refine;
2216 :			if (MotionFlags & PMV_EARLYSTOP16)
2217 :			goto EPZS16_Terminate_with_Refine;
2218 :			}
2219 :	chl	96
2220 :			/********** (if Diamond Search) ************/
2221 :
2222 :	edgomez	195	backupMV = currMV; / save best prediction, actually only for EXTSEARCH */
2223 :	chl	96
2224 :	chl	261	if (MotionFlags & PMV_USESQUARES16)
2225 :	chl	184	MainSearchPtr = Square16_MainSearch;
2226 :			else
2227 :	chl	261	if (MotionFlags & PMV_ADVANCEDDIAMOND16)
2228 :	chl	184	MainSearchPtr = AdvDiamond16_MainSearch;
2229 :			else
2230 :			MainSearchPtr = Diamond16_MainSearch;
2231 :
2232 :	chl	96	/* default: use best prediction as starting point for one call of PMVfast_MainSearch */
2233 :
2234 :	edgomez	195	iSAD =
2235 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,
2236 :	chl	326	currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,
2237 :	edgomez	195	min_dy, max_dy, iEdgedWidth, 2, iFcode, iQuant, 0);
2238 :
2239 :			if (iSAD < iMinSAD) {
2240 :	chl	96	*currMV = newMV;
2241 :			iMinSAD = iSAD;
2242 :			}
2243 :
2244 :
2245 :	edgomez	195	if (MotionFlags & PMV_EXTSEARCH16) {
2246 :	chl	96	/* extended mode: search (up to) two more times: orignal prediction and (0,0) */
2247 :
2248 :	edgomez	195	if (!(MVequal(pmv[0], backupMV))) {
2249 :			iSAD =
2250 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,
2251 :	chl	326	pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,
2252 :	edgomez	195	min_dx, max_dx, min_dy, max_dy, iEdgedWidth,
2253 :			2, iFcode, iQuant, 0);
2254 :	chl	96	}
2255 :	edgomez	195
2256 :			if (iSAD < iMinSAD) {
2257 :	chl	96	*currMV = newMV;
2258 :			iMinSAD = iSAD;
2259 :			}
2260 :	edgomez	195
2261 :			if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {
2262 :			iSAD =
2263 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,
2264 :	chl	326	iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,
2265 :	edgomez	195	max_dy, iEdgedWidth, 2, iFcode, iQuant, 0);
2266 :
2267 :			if (iSAD < iMinSAD) {
2268 :	chl	96	*currMV = newMV;
2269 :			iMinSAD = iSAD;
2270 :			}
2271 :			}
2272 :			}
2273 :
2274 :			/************* Choose best MV found ************/
2275 :
2276 :	edgomez	195	EPZS16_Terminate_with_Refine:
2277 :			if (MotionFlags & PMV_HALFPELREFINE16) // perform final half-pel step
2278 :			iMinSAD =
2279 :			Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,
2280 :	chl	326	iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,
2281 :	edgomez	195	iFcode, iQuant, iEdgedWidth);
2282 :	chl	96
2283 :	edgomez	195	EPZS16_Terminate_without_Refine:
2284 :	chl	96
2285 :	chl	141	oldMB = prevMB;
2286 :	edgomez	195
2287 :	chl	326	currPMV->x = currMV->x - center_x;
2288 :			currPMV->y = currMV->y - center_y;
2289 :	chl	96	return iMinSAD;
2290 :			}
2291 :
2292 :
2293 :	edgomez	195	int32_t
2294 :			EPZSSearch8(const uint8_t * const pRef,
2295 :			const uint8_t * const pRefH,
2296 :			const uint8_t * const pRefV,
2297 :			const uint8_t * const pRefHV,
2298 :			const IMAGE * const pCur,
2299 :			const int x,
2300 :			const int y,
2301 :			const int start_x,
2302 :			const int start_y,
2303 :	chl	326	const int center_x,
2304 :			const int center_y,
2305 :	edgomez	195	const uint32_t MotionFlags,
2306 :			const uint32_t iQuant,
2307 :			const uint32_t iFcode,
2308 :			const MBParam * const pParam,
2309 :			const MACROBLOCK * const pMBs,
2310 :			const MACROBLOCK * const prevMBs,
2311 :			VECTOR * const currMV,
2312 :			VECTOR * const currPMV)
2313 :	chl	96	{
2314 :	chl	141	/* Please not that EPZS might not be a good choice for 8x8-block motion search ! */
2315 :
2316 :			const uint32_t iWcount = pParam->mb_width;
2317 :	chl	96	const int32_t iWidth = pParam->width;
2318 :			const int32_t iHeight = pParam->height;
2319 :	edgomez	195	const int32_t iEdgedWidth = pParam->edged_width;
2320 :	chl	96
2321 :	edgomez	195	const uint8_t cur = pCur->y + x 8 + y * 8 * iEdgedWidth;
2322 :	chl	96
2323 :	edgomez	195	int32_t iDiamondSize = 1;
2324 :
2325 :	chl	96	int32_t min_dx;
2326 :			int32_t max_dx;
2327 :			int32_t min_dy;
2328 :			int32_t max_dy;
2329 :	edgomez	195
2330 :	chl	96	VECTOR newMV;
2331 :			VECTOR backupMV;
2332 :	edgomez	195
2333 :	chl	96	VECTOR pmv[4];
2334 :			int32_t psad[8];
2335 :
2336 :	edgomez	195	const int32_t iSubBlock = ((y & 1) << 1) + (x & 1);
2337 :	chl	96
2338 :	edgomez	195	// const MACROBLOCK * const pMB = pMBs + (x>>1) + (y>>1) * iWcount;
2339 :			const MACROBLOCK const prevMB = prevMBs + (x >> 1) + (y >> 1) iWcount;
2340 :	chl	96
2341 :	edgomez	195	int32_t bPredEq;
2342 :			int32_t iMinSAD, iSAD = 9999;
2343 :
2344 :	chl	181	MainSearch8FuncPtr MainSearchPtr;
2345 :	chl	96
2346 :			/* Get maximum range */
2347 :	edgomez	195	get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 8, iWidth, iHeight,
2348 :			iFcode);
2349 :	chl	96
2350 :			/* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */
2351 :
2352 :	edgomez	195	if (!(MotionFlags & PMV_HALFPEL8)) {
2353 :			min_dx = EVEN(min_dx);
2354 :			max_dx = EVEN(max_dx);
2355 :			min_dy = EVEN(min_dy);
2356 :			max_dy = EVEN(max_dy);
2357 :			}
2358 :			/* because we might use something like IF (dx>max_dx) THEN dx=max_dx; */
2359 :	chl	326	//bPredEq = get_pmvdata(pMBs, x >> 1, y >> 1, iWcount, iSubBlock, pmv[0].x, pmv[0].y, psad);
2360 :	chl	285	bPredEq = get_pmvdata2(pMBs, iWcount, 0, x >> 1, y >> 1, iSubBlock, pmv, psad);
2361 :	chl	96
2362 :
2363 :			/* Step 4: Calculate SAD around the Median prediction.
2364 :			MinSAD=SAD
2365 :			If Motion Vector equal to Previous frame motion vector
2366 :			and MinSAD<PrevFrmSAD goto Step 10.
2367 :			If SAD<=256 goto Step 10.
2368 :			*/
2369 :
2370 :			// Prepare for main loop
2371 :
2372 :	edgomez	195
2373 :			if (!(MotionFlags & PMV_HALFPEL8)) {
2374 :	chl	96	currMV->x = EVEN(currMV->x);
2375 :			currMV->y = EVEN(currMV->y);
2376 :			}
2377 :
2378 :	edgomez	195	if (currMV->x > max_dx)
2379 :			currMV->x = max_dx;
2380 :			if (currMV->x < min_dx)
2381 :			currMV->x = min_dx;
2382 :			if (currMV->y > max_dy)
2383 :			currMV->y = max_dy;
2384 :			if (currMV->y < min_dy)
2385 :			currMV->y = min_dy;
2386 :	chl	96
2387 :	edgomez	195	/*************** This is predictor SET A: only median prediction ****************/
2388 :	chl	96
2389 :	edgomez	195
2390 :			iMinSAD =
2391 :			sad8(cur,
2392 :			get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 8, currMV,
2393 :			iEdgedWidth), iEdgedWidth);
2394 :			iMinSAD +=
2395 :	chl	326	calc_delta_8(currMV->x - center_x, currMV->y - center_y,
2396 :	edgomez	195	(uint8_t) iFcode, iQuant);
2397 :
2398 :
2399 :	chl	96	// thresh1 is fixed to 256
2400 :	edgomez	195	if (iMinSAD < 256 / 4) {
2401 :			if (MotionFlags & PMV_QUICKSTOP8)
2402 :			goto EPZS8_Terminate_without_Refine;
2403 :			if (MotionFlags & PMV_EARLYSTOP8)
2404 :			goto EPZS8_Terminate_with_Refine;
2405 :			}
2406 :	chl	96
2407 :	edgomez	195	/************ This is predictor SET B: (0,0), prev.frame MV, neighbours ************/
2408 :	chl	96
2409 :
2410 :			// MV=(0,0) is often a good choice
2411 :			CHECK_MV8_ZERO;
2412 :
2413 :	chl	141	// previous frame MV
2414 :	edgomez	195	CHECK_MV8_CANDIDATE(prevMB->mvs[iSubBlock].x, prevMB->mvs[iSubBlock].y);
2415 :
2416 :	chl	141	// left neighbour, if allowed
2417 :	edgomez	195	if (psad[1] != MV_MAX_ERROR) {
2418 :			if (!(MotionFlags & PMV_HALFPEL8)) {
2419 :			pmv[1].x = EVEN(pmv[1].x);
2420 :	chl	141	pmv[1].y = EVEN(pmv[1].y);
2421 :			}
2422 :	edgomez	195	CHECK_MV8_CANDIDATE(pmv[1].x, pmv[1].y);
2423 :	chl	141	}
2424 :			// top neighbour, if allowed
2425 :	edgomez	195	if (psad[2] != MV_MAX_ERROR) {
2426 :			if (!(MotionFlags & PMV_HALFPEL8)) {
2427 :			pmv[2].x = EVEN(pmv[2].x);
2428 :	chl	141	pmv[2].y = EVEN(pmv[2].y);
2429 :			}
2430 :	edgomez	195	CHECK_MV8_CANDIDATE(pmv[2].x, pmv[2].y);
2431 :
2432 :	chl	141	// top right neighbour, if allowed
2433 :	edgomez	195	if (psad[3] != MV_MAX_ERROR) {
2434 :			if (!(MotionFlags & PMV_HALFPEL8)) {
2435 :			pmv[3].x = EVEN(pmv[3].x);
2436 :	chl	141	pmv[3].y = EVEN(pmv[3].y);
2437 :			}
2438 :	edgomez	195	CHECK_MV8_CANDIDATE(pmv[3].x, pmv[3].y);
2439 :	chl	141	}
2440 :			}
2441 :
2442 :			/* // this bias is zero anyway, at the moment!
2443 :
2444 :			if ( (MVzero(currMV)) && (!MVzero(pmv[0])) ) // && (iMinSAD <= iQuant 96)
2445 :			iMinSAD -= MV8_00_BIAS;
2446 :
2447 :	edgomez	195	*/
2448 :	chl	141
2449 :	chl	96	/* Terminate if MinSAD <= T_2
2450 :			Terminate if MV[t] == MV[t-1] and MinSAD[t] <= MinSAD[t-1]
2451 :			*/
2452 :
2453 :	edgomez	195	if (iMinSAD < 512 / 4) { /* T_2 == 512/4 hardcoded */
2454 :			if (MotionFlags & PMV_QUICKSTOP8)
2455 :			goto EPZS8_Terminate_without_Refine;
2456 :			if (MotionFlags & PMV_EARLYSTOP8)
2457 :			goto EPZS8_Terminate_with_Refine;
2458 :			}
2459 :	chl	96
2460 :	chl	141	/********** (Diamond Search) ************/
2461 :	chl	96
2462 :	edgomez	195	backupMV = currMV; / save best prediction, actually only for EXTSEARCH */
2463 :	chl	96
2464 :			if (!(MotionFlags & PMV_HALFPELDIAMOND8))
2465 :			iDiamondSize *= 2;
2466 :	edgomez	195
2467 :	chl	141	/* default: use best prediction as starting point for one call of EPZS_MainSearch */
2468 :	chl	96
2469 :	chl	184	// there is no EPZS^2 for inter4v at the moment
2470 :	chl	141
2471 :	edgomez	195	// if (MotionFlags & PMV_USESQUARES8)
2472 :			// MainSearchPtr = Square8_MainSearch;
2473 :			// else
2474 :	chl	181
2475 :			if (MotionFlags & PMV_ADVANCEDDIAMOND8)
2476 :			MainSearchPtr = AdvDiamond8_MainSearch;
2477 :			else
2478 :			MainSearchPtr = Diamond8_MainSearch;
2479 :
2480 :	edgomez	195	iSAD =
2481 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,
2482 :	chl	326	currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,
2483 :	edgomez	195	min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,
2484 :			iQuant, 0);
2485 :	chl	96
2486 :	chl	141
2487 :	edgomez	195	if (iSAD < iMinSAD) {
2488 :	chl	96	*currMV = newMV;
2489 :			iMinSAD = iSAD;
2490 :			}
2491 :
2492 :	edgomez	195	if (MotionFlags & PMV_EXTSEARCH8) {
2493 :	chl	96	/* extended mode: search (up to) two more times: orignal prediction and (0,0) */
2494 :
2495 :	edgomez	195	if (!(MVequal(pmv[0], backupMV))) {
2496 :			iSAD =
2497 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,
2498 :	chl	326	pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,
2499 :	edgomez	195	min_dx, max_dx, min_dy, max_dy, iEdgedWidth,
2500 :			iDiamondSize, iFcode, iQuant, 0);
2501 :
2502 :			if (iSAD < iMinSAD) {
2503 :	chl	96	*currMV = newMV;
2504 :			iMinSAD = iSAD;
2505 :			}
2506 :			}
2507 :
2508 :	edgomez	195	if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {
2509 :			iSAD =
2510 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,
2511 :	chl	326	iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,
2512 :	edgomez	195	max_dy, iEdgedWidth, iDiamondSize, iFcode,
2513 :			iQuant, 0);
2514 :
2515 :			if (iSAD < iMinSAD) {
2516 :	chl	96	*currMV = newMV;
2517 :			iMinSAD = iSAD;
2518 :			}
2519 :			}
2520 :			}
2521 :
2522 :			/************* Choose best MV found ************/
2523 :
2524 :	edgomez	195	EPZS8_Terminate_with_Refine:
2525 :			if (MotionFlags & PMV_HALFPELREFINE8) // perform final half-pel step
2526 :			iMinSAD =
2527 :			Halfpel8_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,
2528 :	chl	326	iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,
2529 :	edgomez	195	iFcode, iQuant, iEdgedWidth);
2530 :	chl	96
2531 :	edgomez	195	EPZS8_Terminate_without_Refine:
2532 :	chl	96
2533 :	chl	326	currPMV->x = currMV->x - center_x;
2534 :			currPMV->y = currMV->y - center_y;
2535 :	chl	96	return iMinSAD;
2536 :			}
2537 :
2538 :	suxen_drol	118
2539 :
2540 :	chl	289	int32_t
2541 :			PMVfastIntSearch16(const uint8_t * const pRef,
2542 :			const uint8_t * const pRefH,
2543 :			const uint8_t * const pRefV,
2544 :			const uint8_t * const pRefHV,
2545 :			const IMAGE * const pCur,
2546 :			const int x,
2547 :			const int y,
2548 :	chl	326	const int start_x,
2549 :			const int start_y,
2550 :			const int center_x,
2551 :			const int center_y,
2552 :	chl	289	const uint32_t MotionFlags,
2553 :			const uint32_t iQuant,
2554 :			const uint32_t iFcode,
2555 :			const MBParam * const pParam,
2556 :			const MACROBLOCK * const pMBs,
2557 :			const MACROBLOCK * const prevMBs,
2558 :			VECTOR * const currMV,
2559 :			VECTOR * const currPMV)
2560 :			{
2561 :			const uint32_t iWcount = pParam->mb_width;
2562 :			const int32_t iWidth = pParam->width;
2563 :			const int32_t iHeight = pParam->height;
2564 :			const int32_t iEdgedWidth = pParam->edged_width;
2565 :	suxen_drol	118
2566 :	chl	289	const uint8_t cur = pCur->y + x 16 + y * 16 * iEdgedWidth;
2567 :			const VECTOR zeroMV = { 0, 0 };
2568 :	suxen_drol	118
2569 :	chl	289	int32_t iDiamondSize;
2570 :
2571 :			int32_t min_dx;
2572 :			int32_t max_dx;
2573 :			int32_t min_dy;
2574 :			int32_t max_dy;
2575 :
2576 :			int32_t iFound;
2577 :
2578 :			VECTOR newMV;
2579 :			VECTOR backupMV; /* just for PMVFAST */
2580 :
2581 :			VECTOR pmv[4];
2582 :			int32_t psad[4];
2583 :
2584 :			MainSearch16FuncPtr MainSearchPtr;
2585 :
2586 :			const MACROBLOCK const prevMB = prevMBs + x + y iWcount;
2587 :			MACROBLOCK const pMB = pMBs + x + y iWcount;
2588 :
2589 :			int32_t threshA, threshB;
2590 :			int32_t bPredEq;
2591 :			int32_t iMinSAD, iSAD;
2592 :	chl	326
2593 :	chl	289
2594 :			/* Get maximum range */
2595 :			get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,
2596 :			iFcode);
2597 :
2598 :			/* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */
2599 :
2600 :			if ((x == 0) && (y == 0)) {
2601 :			threshA = 512;
2602 :			threshB = 1024;
2603 :
2604 :			bPredEq = 0;
2605 :			psad[0] = psad[1] = psad[2] = psad[3] = 0;
2606 :			*currMV = pmv[0] = pmv[1] = pmv[2] = pmv[3] = zeroMV;
2607 :
2608 :			} else {
2609 :			threshA = psad[0];
2610 :			threshB = threshA + 256;
2611 :			if (threshA < 512)
2612 :			threshA = 512;
2613 :			if (threshA > 1024)
2614 :			threshA = 1024;
2615 :			if (threshB > 1792)
2616 :			threshB = 1792;
2617 :
2618 :			bPredEq = get_ipmvdata(pMBs, iWcount, 0, x, y, 0, pmv, psad);
2619 :			currMV = pmv[0]; / current best := prediction */
2620 :			}
2621 :
2622 :			iFound = 0;
2623 :
2624 :			/* Step 4: Calculate SAD around the Median prediction.
2625 :			MinSAD=SAD
2626 :			If Motion Vector equal to Previous frame motion vector
2627 :			and MinSAD<PrevFrmSAD goto Step 10.
2628 :			If SAD<=256 goto Step 10.
2629 :			*/
2630 :
2631 :			if (currMV->x > max_dx) {
2632 :			currMV->x = EVEN(max_dx);
2633 :			}
2634 :			if (currMV->x < min_dx) {
2635 :			currMV->x = EVEN(min_dx);
2636 :			}
2637 :			if (currMV->y > max_dy) {
2638 :			currMV->y = EVEN(max_dy);
2639 :			}
2640 :			if (currMV->y < min_dy) {
2641 :			currMV->y = EVEN(min_dy);
2642 :			}
2643 :
2644 :			iMinSAD =
2645 :			sad16(cur,
2646 :	chl	312	get_iref_mv(pRef, x, y, 16, currMV,
2647 :	chl	289	iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);
2648 :			iMinSAD +=
2649 :	chl	326	calc_delta_16(currMV->x - center_x, currMV->y - center_y,
2650 :	chl	289	(uint8_t) iFcode, iQuant);
2651 :
2652 :			if ((iMinSAD < 256) \|\|
2653 :			((MVequal(*currMV, prevMB->i_mvs[0])) &&
2654 :			((int32_t) iMinSAD < prevMB->i_sad16))) {
2655 :			if (iMinSAD < 2 * iQuant) // high chances for SKIP-mode
2656 :			{
2657 :			if (!MVzero(*currMV)) {
2658 :			iMinSAD += MV16_00_BIAS;
2659 :			CHECK_MV16_ZERO; // (0,0) saves space for letterboxed pictures
2660 :			iMinSAD -= MV16_00_BIAS;
2661 :			}
2662 :			}
2663 :
2664 :			if (MotionFlags & PMV_EARLYSTOP16)
2665 :			goto PMVfastInt16_Terminate_with_Refine;
2666 :			}
2667 :
2668 :
2669 :			/* Step 2 (lazy eval): Calculate Distance= \|MedianMVX\| + \|MedianMVY\| where MedianMV is the motion
2670 :			vector of the median.
2671 :			If PredEq=1 and MVpredicted = Previous Frame MV, set Found=2
2672 :			*/
2673 :
2674 :			if ((bPredEq) && (MVequal(pmv[0], prevMB->i_mvs[0])))
2675 :			iFound = 2;
2676 :
2677 :			/* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.
2678 :			Otherwise select large Diamond Search.
2679 :			*/
2680 :
2681 :			if ((!MVzero(pmv[0])) \|\| (threshB < 1536) \|\| (bPredEq))
2682 :			iDiamondSize = 2; // halfpel units!
2683 :			else
2684 :			iDiamondSize = 4; // halfpel units!
2685 :
2686 :			/*
2687 :			Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.
2688 :			Also calculate (0,0) but do not subtract offset.
2689 :			Let MinSAD be the smallest SAD up to this point.
2690 :			If MV is (0,0) subtract offset.
2691 :			*/
2692 :
2693 :			// (0,0) is often a good choice
2694 :
2695 :			if (!MVzero(pmv[0]))
2696 :			CHECK_MV16_ZERO;
2697 :
2698 :			// previous frame MV is always possible
2699 :
2700 :			if (!MVzero(prevMB->i_mvs[0]))
2701 :			if (!MVequal(prevMB->i_mvs[0], pmv[0]))
2702 :			CHECK_MV16_CANDIDATE(prevMB->i_mvs[0].x, prevMB->i_mvs[0].y);
2703 :
2704 :			// left neighbour, if allowed
2705 :
2706 :			if (!MVzero(pmv[1]))
2707 :			if (!MVequal(pmv[1], prevMB->i_mvs[0]))
2708 :			if (!MVequal(pmv[1], pmv[0]))
2709 :			CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);
2710 :
2711 :			// top neighbour, if allowed
2712 :			if (!MVzero(pmv[2]))
2713 :			if (!MVequal(pmv[2], prevMB->i_mvs[0]))
2714 :			if (!MVequal(pmv[2], pmv[0]))
2715 :			if (!MVequal(pmv[2], pmv[1]))
2716 :			CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);
2717 :
2718 :			// top right neighbour, if allowed
2719 :			if (!MVzero(pmv[3]))
2720 :			if (!MVequal(pmv[3], prevMB->i_mvs[0]))
2721 :			if (!MVequal(pmv[3], pmv[0]))
2722 :			if (!MVequal(pmv[3], pmv[1]))
2723 :			if (!MVequal(pmv[3], pmv[2]))
2724 :			CHECK_MV16_CANDIDATE(pmv[3].x,
2725 :			pmv[3].y);
2726 :
2727 :			if ((MVzero(*currMV)) &&
2728 :			(!MVzero(pmv[0])) /* && (iMinSAD <= iQuant * 96) */ )
2729 :			iMinSAD -= MV16_00_BIAS;
2730 :
2731 :
2732 :			/* Step 6: If MinSAD <= thresa goto Step 10.
2733 :			If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.
2734 :			*/
2735 :
2736 :			if ((iMinSAD <= threshA) \|\|
2737 :			(MVequal(*currMV, prevMB->i_mvs[0]) &&
2738 :			((int32_t) iMinSAD < prevMB->i_sad16))) {
2739 :
2740 :			if (MotionFlags & PMV_EARLYSTOP16)
2741 :			goto PMVfastInt16_Terminate_with_Refine;
2742 :			}
2743 :
2744 :
2745 :			/********** (Diamond Search) ************/
2746 :			/*
2747 :			Step 7: Perform Diamond search, with either the small or large diamond.
2748 :			If Found=2 only examine one Diamond pattern, and afterwards goto step 10
2749 :			Step 8: If small diamond, iterate small diamond search pattern until motion vector lies in the center of the diamond.
2750 :			If center then goto step 10.
2751 :			Step 9: If large diamond, iterate large diamond search pattern until motion vector lies in the center.
2752 :			Refine by using small diamond and goto step 10.
2753 :			*/
2754 :
2755 :			if (MotionFlags & PMV_USESQUARES16)
2756 :			MainSearchPtr = Square16_MainSearch;
2757 :			else if (MotionFlags & PMV_ADVANCEDDIAMOND16)
2758 :			MainSearchPtr = AdvDiamond16_MainSearch;
2759 :			else
2760 :			MainSearchPtr = Diamond16_MainSearch;
2761 :
2762 :			backupMV = currMV; / save best prediction, actually only for EXTSEARCH */
2763 :
2764 :
2765 :			/* default: use best prediction as starting point for one call of PMVfast_MainSearch */
2766 :			iSAD =
2767 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,
2768 :	chl	326	currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,
2769 :	chl	289	min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,
2770 :			iQuant, iFound);
2771 :
2772 :			if (iSAD < iMinSAD) {
2773 :			*currMV = newMV;
2774 :			iMinSAD = iSAD;
2775 :			}
2776 :
2777 :			if (MotionFlags & PMV_EXTSEARCH16) {
2778 :			/* extended: search (up to) two more times: orignal prediction and (0,0) */
2779 :
2780 :			if (!(MVequal(pmv[0], backupMV))) {
2781 :			iSAD =
2782 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,
2783 :	chl	326	pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,
2784 :	chl	289	min_dx, max_dx, min_dy, max_dy, iEdgedWidth,
2785 :			iDiamondSize, iFcode, iQuant, iFound);
2786 :
2787 :			if (iSAD < iMinSAD) {
2788 :			*currMV = newMV;
2789 :			iMinSAD = iSAD;
2790 :			}
2791 :			}
2792 :
2793 :			if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {
2794 :			iSAD =
2795 :			(*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,
2796 :	chl	326	iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,
2797 :	chl	289	max_dy, iEdgedWidth, iDiamondSize, iFcode,
2798 :			iQuant, iFound);
2799 :
2800 :			if (iSAD < iMinSAD) {
2801 :			*currMV = newMV;
2802 :			iMinSAD = iSAD;
2803 :			}
2804 :			}
2805 :			}
2806 :
2807 :			/*
2808 :			Step 10: The motion vector is chosen according to the block corresponding to MinSAD.
2809 :			*/
2810 :
2811 :			PMVfastInt16_Terminate_with_Refine:
2812 :
2813 :			pMB->i_mvs[0] = pMB->i_mvs[1] = pMB->i_mvs[2] = pMB->i_mvs[3] = pMB->i_mv16 = *currMV;
2814 :			pMB->i_sad8[0] = pMB->i_sad8[1] = pMB->i_sad8[2] = pMB->i_sad8[3] = pMB->i_sad16 = iMinSAD;
2815 :
2816 :			if (MotionFlags & PMV_HALFPELREFINE16) // perform final half-pel step
2817 :			iMinSAD =
2818 :			Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,
2819 :	chl	326	iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,
2820 :	chl	289	iFcode, iQuant, iEdgedWidth);
2821 :
2822 :			pmv[0] = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0); // get _REAL_ prediction (halfpel possible)
2823 :
2824 :			PMVfastInt16_Terminate_without_Refine:
2825 :	chl	326	currPMV->x = currMV->x - center_x;
2826 :			currPMV->y = currMV->y - center_y;
2827 :	chl	289	return iMinSAD;
2828 :			}
2829 :
2830 :
2831 :
2832 :	suxen_drol	118	/* ***********************************************************
2833 :			bvop motion estimation
2834 :			// TODO: need to incorporate prediction here (eg. sad += calc_delta_16)
2835 :			***************************************************************/
2836 :
2837 :	suxen_drol	152
2838 :	chl	326	#define DIRECT_PENALTY 0
2839 :			#define DIRECT_UPPERLIMIT 256 // never use direct mode if SAD is larger than this
2840 :
2841 :	edgomez	195	void
2842 :			MotionEstimationBVOP(MBParam * const pParam,
2843 :			FRAMEINFO * const frame,
2844 :	chl	317	const int32_t time_bp,
2845 :			const int32_t time_pp,
2846 :	edgomez	195	// forward (past) reference
2847 :			const MACROBLOCK * const f_mbs,
2848 :			const IMAGE * const f_ref,
2849 :			const IMAGE * const f_refH,
2850 :			const IMAGE * const f_refV,
2851 :			const IMAGE * const f_refHV,
2852 :			// backward (future) reference
2853 :			const MACROBLOCK * const b_mbs,
2854 :			const IMAGE * const b_ref,
2855 :			const IMAGE * const b_refH,
2856 :			const IMAGE * const b_refV,
2857 :			const IMAGE * const b_refHV)
2858 :	suxen_drol	118	{
2859 :	chl	312	const int mb_width = pParam->mb_width;
2860 :			const int mb_height = pParam->mb_height;
2861 :			const int edged_width = pParam->edged_width;
2862 :	suxen_drol	118
2863 :	chl	317	int i, j, k;
2864 :	edgomez	195
2865 :	chl	317	static const VECTOR zeroMV={0,0};
2866 :	chl	312
2867 :			int f_sad16; /* forward (as usual) search */
2868 :			int b_sad16; /* backward (only in b-frames) search */
2869 :			int i_sad16; /* interpolated (both direction, b-frames only) */
2870 :			int d_sad16; /* direct mode (assume linear motion) */
2871 :	chl	326	int dnv_sad16; /* direct mode (assume linear motion) without correction vector */
2872 :	suxen_drol	118
2873 :	chl	312	int best_sad;
2874 :
2875 :	chl	326	VECTOR f_predMV, b_predMV; /* there is no direct prediction */
2876 :	suxen_drol	118	VECTOR pmv_dontcare;
2877 :
2878 :	chl	312	int f_count=0;
2879 :			int b_count=0;
2880 :			int i_count=0;
2881 :			int d_count=0;
2882 :			int dnv_count=0;
2883 :			int s_count=0;
2884 :	chl	317	const int64_t TRB = (int32_t)time_pp - (int32_t)time_bp;
2885 :	chl	326	const int64_t TRD = (int32_t)time_pp;
2886 :	chl	317
2887 :	chl	318	// fprintf(stderr,"TRB = %lld TRD = %lld time_bp =%d time_pp =%d\n\n",TRB,TRD,time_bp,time_pp);
2888 :	suxen_drol	118	// note: i==horizontal, j==vertical
2889 :	edgomez	195	for (j = 0; j < mb_height; j++) {
2890 :	chl	326
2891 :			f_predMV = zeroMV; /* prediction is reset at left boundary */
2892 :			b_predMV = zeroMV;
2893 :
2894 :	edgomez	195	for (i = 0; i < mb_width; i++) {
2895 :			MACROBLOCK mb = &frame->mbs[i + j mb_width];
2896 :			const MACROBLOCK f_mb = &f_mbs[i + j mb_width];
2897 :			const MACROBLOCK b_mb = &b_mbs[i + j mb_width];
2898 :	suxen_drol	118
2899 :	chl	317	VECTOR directMV;
2900 :			VECTOR deltaMV=zeroMV;
2901 :
2902 :	chl	312	/* special case, if collocated block is SKIPed: encoding is forward(0,0) */
2903 :
2904 :	edgomez	195	if (b_mb->mode == MODE_INTER && b_mb->cbp == 0 &&
2905 :	chl	312	b_mb->mvs[0].x == 0 && b_mb->mvs[0].y == 0) {
2906 :	suxen_drol	152	mb->mode = MODE_NOT_CODED;
2907 :	suxen_drol	118	mb->mvs[0].x = 0;
2908 :			mb->mvs[0].y = 0;
2909 :			mb->b_mvs[0].x = 0;
2910 :			mb->b_mvs[0].y = 0;
2911 :			continue;
2912 :			}
2913 :
2914 :	chl	326	dnv_sad16 = DIRECT_PENALTY;
2915 :	suxen_drol	234
2916 :	chl	326	if (b_mb->mode == MODE_INTER4V)
2917 :			{
2918 :	chl	317
2919 :	chl	326	/* same method of scaling as in decoder.c, so we copy from there */
2920 :			for (k = 0; k < 4; k++) {
2921 :
2922 :			directMV = b_mb->mvs[k];
2923 :
2924 :			mb->mvs[k].x = (int32_t) ((TRB * directMV.x) / TRD + deltaMV.x);
2925 :			mb->b_mvs[k].x = (int32_t) ((deltaMV.x == 0)
2926 :			? ((TRB - TRD) * directMV.x) / TRD
2927 :			: mb->mvs[k].x - directMV.x);
2928 :			mb->mvs[k].y = (int32_t) ((TRB * directMV.y) / TRD + deltaMV.y);
2929 :			mb->b_mvs[k].y = (int32_t) ((deltaMV.y == 0)
2930 :			? ((TRB - TRD) * directMV.y) / TRD
2931 :			: mb->mvs[k].y - directMV.y);
2932 :
2933 :			dnv_sad16 +=
2934 :			sad8bi(frame->image.y + 2(i+(k&1))8 + 2(j+(k>>1))8*edged_width,
2935 :	chl	312	get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,
2936 :	chl	326	2(i+(k&1)), 2(j+(k>>1)), 8, &mb->mvs[k], edged_width),
2937 :			get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,
2938 :			2(i+(k&1)), 2(j+(k>>1)), 8, &mb->b_mvs[k], edged_width),
2939 :			edged_width);
2940 :			}
2941 :			}
2942 :			else
2943 :			{
2944 :			directMV = b_mb->mvs[0];
2945 :
2946 :			mb->mvs[0].x = (int32_t) ((TRB * directMV.x) / TRD + deltaMV.x);
2947 :			mb->b_mvs[0].x = (int32_t) ((deltaMV.x == 0)
2948 :			? ((TRB - TRD) * directMV.x) / TRD
2949 :			: mb->mvs[0].x - directMV.x);
2950 :			mb->mvs[0].y = (int32_t) ((TRB * directMV.y) / TRD + deltaMV.y);
2951 :			mb->b_mvs[0].y = (int32_t) ((deltaMV.y == 0)
2952 :			? ((TRB - TRD) * directMV.y) / TRD
2953 :			: mb->mvs[0].y - directMV.y);
2954 :
2955 :			dnv_sad16 = DIRECT_PENALTY +
2956 :			sad16bi(frame->image.y + i * 16 + j * 16 * edged_width,
2957 :			get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,
2958 :	chl	312	i, j, 16, &mb->mvs[0], edged_width),
2959 :			get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,
2960 :			i, j, 16, &mb->b_mvs[0], edged_width),
2961 :			edged_width);
2962 :	chl	326
2963 :
2964 :			}
2965 :
2966 :	suxen_drol	118	// forward search
2967 :	chl	312	f_sad16 = SEARCH16(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,
2968 :	chl	326	&frame->image, i, j,
2969 :			mb->mvs[0].x, mb->mvs[0].y, /* start point f_directMV */
2970 :			f_predMV.x, f_predMV.y, /* center is f-prediction */
2971 :			frame->motion_flags & (~(PMV_EARLYSTOP16\|PMV_QUICKSTOP16)),
2972 :	chl	312	frame->quant, frame->fcode, pParam,
2973 :	chl	326	f_mbs, f_mbs,
2974 :			&mb->mvs[0], &pmv_dontcare);
2975 :	suxen_drol	118
2976 :	chl	312
2977 :	suxen_drol	118	// backward search
2978 :	suxen_drol	234	b_sad16 = SEARCH16(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,
2979 :	chl	326	&frame->image, i, j,
2980 :			mb->b_mvs[0].x, mb->b_mvs[0].y, /* start point b_directMV */
2981 :			b_predMV.x, b_predMV.y, /* center is b-prediction */
2982 :			frame->motion_flags & (~(PMV_EARLYSTOP16\|PMV_QUICKSTOP16)),
2983 :	suxen_drol	234	frame->quant, frame->bcode, pParam,
2984 :	chl	326	b_mbs, b_mbs,
2985 :			&mb->b_mvs[0], &pmv_dontcare);
2986 :
2987 :	edgomez	195	i_sad16 =
2988 :	chl	312	sad16bi(frame->image.y + i * 16 + j * 16 * edged_width,
2989 :			get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,
2990 :			i, j, 16, &mb->mvs[0], edged_width),
2991 :	chl	326	get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,
2992 :			i, j, 16, &mb->b_mvs[0], edged_width),
2993 :	edgomez	195	edged_width);
2994 :	chl	326	i_sad16 += calc_delta_16(mb->mvs[0].x-f_predMV.x, mb->mvs[0].y-f_predMV.y,
2995 :			frame->fcode, frame->quant);
2996 :			i_sad16 += calc_delta_16(mb->b_mvs[0].y-b_predMV.y, mb->b_mvs[0].y-b_predMV.y,
2997 :			frame->bcode, frame->quant);
2998 :	suxen_drol	118
2999 :			// TODO: direct search
3000 :	chl	326	// predictor + delta vector in range [-32,32] (fcode=1)
3001 :
3002 :	chl	312	// i_sad16 = 65535;
3003 :	chl	326	// f_sad16 = 65535;
3004 :	chl	312	// b_sad16 = 65535;
3005 :
3006 :	edgomez	195	if (f_sad16 < b_sad16) {
3007 :	suxen_drol	118	best_sad = f_sad16;
3008 :	suxen_drol	152	mb->mode = MODE_FORWARD;
3009 :	edgomez	195	} else {
3010 :	suxen_drol	118	best_sad = b_sad16;
3011 :	suxen_drol	152	mb->mode = MODE_BACKWARD;
3012 :	suxen_drol	118	}
3013 :	edgomez	195
3014 :			if (i_sad16 < best_sad) {
3015 :	suxen_drol	118	best_sad = i_sad16;
3016 :	suxen_drol	152	mb->mode = MODE_INTERPOLATE;
3017 :	suxen_drol	118	}
3018 :
3019 :	chl	326	if (dnv_sad16 < best_sad) {
3020 :
3021 :			if (dnv_sad16 > DIRECT_UPPERLIMIT)
3022 :			{
3023 :			/* if SAD value is too large, try same vector with MODE_INTERPOLATE
3024 :			instead (interpolate has residue encoding, direct mode without MV
3025 :			doesn't)
3026 :
3027 :			This has to be replaced later by "real" direct mode, including delta
3028 :			vector and (if needed) residue encoding
3029 :
3030 :			*/
3031 :
3032 :			directMV = b_mb->mvs[0];
3033 :
3034 :			mb->mvs[0].x = (int32_t) ((TRB * directMV.x) / TRD + deltaMV.x);
3035 :			mb->b_mvs[0].x = (int32_t) ((deltaMV.x == 0)
3036 :			? ((TRB - TRD) * directMV.x) / TRD
3037 :			: mb->mvs[0].x - directMV.x);
3038 :			mb->mvs[0].y = (int32_t) ((TRB * directMV.y) / TRD + deltaMV.y);
3039 :			mb->b_mvs[0].y = (int32_t) ((deltaMV.y == 0)
3040 :			? ((TRB - TRD) * directMV.y) / TRD
3041 :			: mb->mvs[0].y - directMV.y);
3042 :
3043 :			dnv_sad16 =
3044 :			sad16bi(frame->image.y + i * 16 + j * 16 * edged_width,
3045 :			get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,
3046 :			i, j, 16, &mb->mvs[0], edged_width),
3047 :			get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,
3048 :			i, j, 16, &mb->b_mvs[0], edged_width),
3049 :			edged_width);
3050 :			dnv_sad16 += calc_delta_16(mb->mvs[0].x-f_predMV.x, mb->mvs[0].y-f_predMV.y,
3051 :			frame->fcode, frame->quant);
3052 :			dnv_sad16 += calc_delta_16(mb->b_mvs[0].y-b_predMV.y, mb->b_mvs[0].y-b_predMV.y,
3053 :			frame->bcode, frame->quant);
3054 :
3055 :			if (dnv_sad16 < best_sad)
3056 :			{
3057 :			best_sad = dnv_sad16;
3058 :			mb->mode = MODE_INTERPOLATE;
3059 :
3060 :			/* fprintf(stderr,"f_sad16 = %d, b_sad16 = %d, i_sad16 = %d, dnv_sad16 = %d\n",
3061 :			f_sad16,b_sad16,i_sad16,dnv_sad16);
3062 :			*/ }
3063 :			}
3064 :			else
3065 :			{
3066 :			best_sad = dnv_sad16;
3067 :			mb->mode = MODE_DIRECT_NONE_MV;
3068 :			}
3069 :	suxen_drol	118	}
3070 :
3071 :	chl	312	switch (mb->mode)
3072 :			{
3073 :			case MODE_FORWARD:
3074 :	chl	326	f_count++;
3075 :			f_predMV = mb->mvs[0];
3076 :			break;
3077 :	chl	312	case MODE_BACKWARD:
3078 :	chl	326	b_count++;
3079 :			b_predMV = mb->b_mvs[0];
3080 :
3081 :			break;
3082 :	chl	312	case MODE_INTERPOLATE:
3083 :	chl	326	i_count++;
3084 :			f_predMV = mb->mvs[0];
3085 :			b_predMV = mb->b_mvs[0];
3086 :			break;
3087 :	chl	312	case MODE_DIRECT:
3088 :			d_count++; break;
3089 :			case MODE_DIRECT_NONE_MV:
3090 :			dnv_count++; break;
3091 :			default:
3092 :			s_count++; break;
3093 :			}
3094 :
3095 :	suxen_drol	118	}
3096 :			}
3097 :	chl	312
3098 :			#ifdef _DEBUG_BFRAME_STAT
3099 :			fprintf(stderr,"B-Stat: F: %04d B: %04d I: %04d D0: %04d D: %04d S: %04d\n",
3100 :			f_count,b_count,i_count,dnv_count,d_count,s_count);
3101 :			#endif
3102 :
3103 :	suxen_drol	118	}

No admin address has been configured	ViewVC Help
Powered by ViewVC 1.0.4