[svn] / trunk / xvidcore / src / motion / motion.h Repository:
ViewVC logotype

Annotation of /trunk/xvidcore/src/motion/motion.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 652 - (view) (download)

1 : chl 430 /*****************************************************************************
2 : chl 326 *
3 :     * XVID MPEG-4 VIDEO CODEC
4 : chl 430 * - Motion Estimation header -
5 : chl 326 *
6 : chl 430 * Copyright(C) 2002 Christoph Lampert <gruel@web.de>
7 :     *
8 : edgomez 652 * This file is part of XviD, a free MPEG-4 video encoder/decoder
9 : chl 430 *
10 : edgomez 652 * XviD is free software; you can redistribute it and/or modify it
11 :     * under the terms of the GNU General Public License as published by
12 : chl 326 * the Free Software Foundation; either version 2 of the License, or
13 :     * (at your option) any later version.
14 :     *
15 :     * This program is distributed in the hope that it will be useful,
16 :     * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 :     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 :     * GNU General Public License for more details.
19 :     *
20 :     * You should have received a copy of the GNU General Public License
21 :     * along with this program; if not, write to the Free Software
22 :     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 :     *
24 : edgomez 652 * Under section 8 of the GNU General Public License, the copyright
25 :     * holders of XVID explicitly forbid distribution in the following
26 :     * countries:
27 : chl 326 *
28 : edgomez 652 * - Japan
29 :     * - United States of America
30 :     *
31 :     * Linking XviD statically or dynamically with other modules is making a
32 :     * combined work based on XviD. Thus, the terms and conditions of the
33 :     * GNU General Public License cover the whole combination.
34 :     *
35 :     * As a special exception, the copyright holders of XviD give you
36 :     * permission to link XviD with independent modules that communicate with
37 :     * XviD solely through the VFW1.1 and DShow interfaces, regardless of the
38 :     * license terms of these independent modules, and to copy and distribute
39 :     * the resulting combined work under terms of your choice, provided that
40 :     * every copy of the combined work is accompanied by a complete copy of
41 :     * the source code of XviD (the version of XviD used to produce the
42 :     * combined work), being distributed under the terms of the GNU General
43 :     * Public License plus this exception. An independent module is a module
44 :     * which is not derived from or based on XviD.
45 :     *
46 :     * Note that people who make modified versions of XviD are not obligated
47 :     * to grant this special exception for their modified versions; it is
48 :     * their choice whether to do so. The GNU General Public License gives
49 :     * permission to release a modified version without this exception; this
50 :     * exception also makes it possible to release a modified version which
51 :     * carries forward this exception.
52 :     *
53 :     * $Id: motion.h,v 1.17 2002-11-17 00:32:06 edgomez Exp $
54 :     *
55 : chl 326 ***************************************************************************/
56 :    
57 :     #ifndef _MOTION_H_
58 :     #define _MOTION_H_
59 :    
60 :     #include "../portab.h"
61 :     #include "../global.h"
62 :    
63 : chl 438 /* hard coded motion search parameters for motion_est */
64 : chl 326
65 :     // very large value
66 :     #define MV_MAX_ERROR (4096 * 256)
67 :    
68 :     // stop search if sdelta < THRESHOLD
69 :     #define MV16_THRESHOLD 192
70 :     #define MV8_THRESHOLD 56
71 :    
72 :     #define NEIGH_MOVE_THRESH 0
73 :     // how much a block's MV must differ from his neighbour
74 :     // to be search for INTER4V. The more, the faster...
75 :    
76 :     /* sad16(0,0) bias; mpeg4 spec suggests nb/2+1 */
77 :     /* nb = vop pixels * 2^(bpp-8) */
78 :     #define MV16_00_BIAS (128+1)
79 :     #define MV8_00_BIAS (0)
80 :    
81 :     /* INTER bias for INTER/INTRA decision; mpeg4 spec suggests 2*nb */
82 :     #define MV16_INTER_BIAS 512
83 :    
84 :     /* Parameters which control inter/inter4v decision */
85 :     #define IMV16X16 5
86 :    
87 :     /* vector map (vlc delta size) smoother parameters */
88 :     #define NEIGH_TEND_16X16 2
89 :     #define NEIGH_TEND_8X8 2
90 :    
91 :     // fast ((A)/2)*2
92 :     #define EVEN(A) (((A)<0?(A)+1:(A)) & ~1)
93 :    
94 :     #define MVzero(A) ( ((A).x)==(0) && ((A).y)==(0) )
95 :     #define MVequal(A,B) ( ((A).x)==((B).x) && ((A).y)==((B).y) )
96 :    
97 :     /* default methods of Search, will be changed to function variable */
98 :    
99 :     #ifndef SEARCH16
100 :     #define SEARCH16 PMVfastSearch16
101 :     //#define SEARCH16 FullSearch16
102 :     //#define SEARCH16 EPZSSearch16
103 :     #endif
104 :    
105 :     #ifndef SEARCH8
106 :     #define SEARCH8 PMVfastSearch8
107 :     //#define SEARCH8 EPZSSearch8
108 :     #endif
109 :    
110 :    
111 :     /*
112 :     * Calculate the min/max range (in halfpixels)
113 :     * relative to the _MACROBLOCK_ position
114 :     */
115 :    
116 :     static void __inline
117 :     get_range(int32_t * const min_dx,
118 :     int32_t * const max_dx,
119 :     int32_t * const min_dy,
120 :     int32_t * const max_dy,
121 :     const uint32_t x,
122 :     const uint32_t y,
123 :     const uint32_t block_sz, /* block dimension, 8 or 16 */
124 :    
125 :     const uint32_t width,
126 :     const uint32_t height,
127 :     const uint32_t fcode)
128 :     {
129 :    
130 :     const int search_range = 32 << (fcode - 1);
131 :     const int high = search_range - 1;
132 :     const int low = -search_range;
133 :    
134 :     /* convert full-pixel measurements to half pixel */
135 :     const int hp_width = 2 * width;
136 :     const int hp_height = 2 * height;
137 :     const int hp_edge = 2 * block_sz;
138 :    
139 :     /* we need _right end_ of block, not x-coordinate */
140 :     const int hp_x = 2 * (x) * block_sz;
141 :    
142 :     /* same for _bottom end_ */
143 :     const int hp_y = 2 * (y) * block_sz;
144 :    
145 :     *max_dx = MIN(high, hp_width - hp_x);
146 :     *max_dy = MIN(high, hp_height - hp_y);
147 :     *min_dx = MAX(low, -(hp_edge + hp_x));
148 :     *min_dy = MAX(low, -(hp_edge + hp_y));
149 :    
150 :     }
151 :    
152 :    
153 :     /*
154 :     * getref: calculate reference image pointer
155 :     * the decision to use interpolation h/v/hv or the normal image is
156 :     * based on dx & dy.
157 :     */
158 :    
159 :     static __inline const uint8_t *
160 :     get_ref(const uint8_t * const refn,
161 :     const uint8_t * const refh,
162 :     const uint8_t * const refv,
163 :     const uint8_t * const refhv,
164 :     const uint32_t x,
165 :     const uint32_t y,
166 :     const uint32_t block, /* block dimension, 8 or 16 */
167 :    
168 :     const int32_t dx,
169 :     const int32_t dy,
170 :     const uint32_t stride)
171 :     {
172 :    
173 :    
174 :     switch (((dx & 1) << 1) + (dy & 1)) { /* ((dx%2)?2:0)+((dy%2)?1:0) */
175 :     case 0:
176 :     return refn + (int) ((x * block + dx / 2) + (y * block + dy / 2) * stride);
177 :     case 1:
178 :     return refv + (int) ((x * block + dx / 2) + (y * block +
179 :     (dy - 1) / 2) * stride);
180 :     case 2:
181 :     return refh + (int) ((x * block + (dx - 1) / 2) + (y * block +
182 :     dy / 2) * stride);
183 :     default:
184 :     case 3:
185 :     return refhv + (int) ((x * block + (dx - 1) / 2) + (y * block +
186 :     (dy - 1) / 2) * stride);
187 :     }
188 :    
189 :     }
190 :    
191 :    
192 :     /* This is somehow a copy of get_ref, but with MV instead of X,Y */
193 :    
194 :     static __inline const uint8_t *
195 :     get_ref_mv(const uint8_t * const refn,
196 :     const uint8_t * const refh,
197 :     const uint8_t * const refv,
198 :     const uint8_t * const refhv,
199 :     const uint32_t x,
200 :     const uint32_t y,
201 :     const uint32_t block, /* block dimension, 8 or 16 */
202 :    
203 :     const VECTOR * mv, /* measured in half-pel! */
204 :    
205 :     const uint32_t stride)
206 :     {
207 :    
208 :     switch ((((mv->x) & 1) << 1) + ((mv->y) & 1)) {
209 :     case 0:
210 :     return refn + (int) ((x * block + (mv->x) / 2) + (y * block +
211 :     (mv->y) / 2) * stride);
212 :     case 1:
213 :     return refv + (int) ((x * block + (mv->x) / 2) + (y * block +
214 :     ((mv->y) - 1) / 2) * stride);
215 :     case 2:
216 :     return refh + (int) ((x * block + ((mv->x) - 1) / 2) + (y * block +
217 :     (mv->y) / 2) * stride);
218 :     default:
219 :     case 3:
220 :     return refhv + (int) ((x * block + ((mv->x) - 1) / 2) + (y * block +
221 :     ((mv->y) -
222 :     1) / 2) * stride);
223 :     }
224 :    
225 :     }
226 :    
227 :    
228 :     static __inline const uint8_t *
229 :     get_iref(const uint8_t * const ref,
230 :     const uint32_t x,
231 :     const uint32_t y,
232 :     const uint32_t block, /* block dimension, 8 or 16 */
233 :    
234 :     const int32_t dx,
235 :     const int32_t dy,
236 :     const uint32_t stride)
237 :     {
238 :     return ref + (int) ((x * block + dx / 2) + (y * block + dy / 2) * stride);
239 :     }
240 :    
241 :     static __inline const uint8_t *
242 :     get_iref_mv(const uint8_t * const ref,
243 :     const uint32_t x,
244 :     const uint32_t y,
245 :     const uint32_t block, /* block dimension, 8 or 16 */
246 :    
247 :     const VECTOR * mv, /* as usual measured in half-pel */
248 :    
249 :     const uint32_t stride)
250 :     {
251 :     return ref + (int) ((x * block + (mv->x) / 2) + (y * block + (mv->y) / 2) * stride);
252 :     }
253 :    
254 :    
255 :     /* prototypes for MainSearch functions, i.e. Diamondsearch, FullSearch or whatever */
256 :    
257 :     typedef int32_t(MainSearch16Func) (const uint8_t * const pRef,
258 :     const uint8_t * const pRefH,
259 :     const uint8_t * const pRefV,
260 :     const uint8_t * const pRefHV,
261 :     const uint8_t * const cur,
262 :     const int x,
263 :     const int y,
264 :     const int start_x,
265 :     const int start_y,
266 :     int iMinSAD,
267 :     VECTOR * const currMV,
268 :     const int center_x,
269 :     const int center_y,
270 :     const int32_t min_dx,
271 :     const int32_t max_dx,
272 :     const int32_t min_dy,
273 :     const int32_t max_dy,
274 :     const int32_t iEdgedWidth,
275 :     const int32_t iDiamondSize,
276 :     const int32_t iFcode,
277 :     const int32_t iQuant,
278 :     int iFound);
279 :    
280 :     typedef MainSearch16Func *MainSearch16FuncPtr;
281 :    
282 :    
283 :     typedef int32_t(MainSearch8Func) (const uint8_t * const pRef,
284 :     const uint8_t * const pRefH,
285 :     const uint8_t * const pRefV,
286 :     const uint8_t * const pRefHV,
287 :     const uint8_t * const cur,
288 :     const int x,
289 :     const int y,
290 :     const int start_x,
291 :     const int start_y,
292 :     int iMinSAD,
293 :     VECTOR * const currMV,
294 :     const int center_x,
295 :     const int center_y,
296 :     const int32_t min_dx,
297 :     const int32_t max_dx,
298 :     const int32_t min_dy,
299 :     const int32_t max_dy,
300 :     const int32_t iEdgedWidth,
301 :     const int32_t iDiamondSize,
302 :     const int32_t iFcode,
303 :     const int32_t iQuant,
304 :     int iFound);
305 :    
306 :     typedef MainSearch8Func *MainSearch8FuncPtr;
307 :    
308 :    
309 :     /* prototypes for MotionEstimation functions, i.e. PMVfast, EPZS or whatever */
310 :    
311 :     typedef int32_t(Search16Func) ( const uint8_t * const pRef,
312 :     const uint8_t * const pRefH,
313 :     const uint8_t * const pRefV,
314 :     const uint8_t * const pRefHV,
315 :     const IMAGE * const pCur,
316 :     const int x,
317 :     const int y,
318 :     const int start_x,
319 :     const int start_y,
320 :     const int center_x,
321 :     const int center_y,
322 :     const uint32_t MotionFlags,
323 :     const uint32_t iQuant,
324 :     const uint32_t iFcode,
325 :     const MBParam * const pParam,
326 :     const MACROBLOCK * const pMBs,
327 :     const MACROBLOCK * const prevMBs,
328 :     VECTOR * const currMV,
329 :     VECTOR * const currPMV);
330 :    
331 :     typedef Search16Func *Search16FuncPtr;
332 :    
333 :     typedef int32_t(Search8Func) ( const uint8_t * const pRef,
334 :     const uint8_t * const pRefH,
335 :     const uint8_t * const pRefV,
336 :     const uint8_t * const pRefHV,
337 :     const IMAGE * const pCur,
338 :     const int x,
339 :     const int y,
340 :     const int start_x,
341 :     const int start_y,
342 :     const int center_x,
343 :     const int center_y,
344 :     const uint32_t MotionFlags,
345 :     const uint32_t iQuant,
346 :     const uint32_t iFcode,
347 :     const MBParam * const pParam,
348 :     const MACROBLOCK * const pMBs,
349 :     const MACROBLOCK * const prevMBs,
350 :     VECTOR * const currMV,
351 :     VECTOR * const currPMV);
352 :    
353 :     typedef Search8Func *Search8FuncPtr;
354 :    
355 :     Search16Func PMVfastSearch16;
356 :     Search16Func EPZSSearch16;
357 :     Search16Func PMVfastIntSearch16;
358 :    
359 :     Search8Func PMVfastSearch8;
360 :     Search8Func EPZSSearch8;
361 :    
362 :    
363 :     bool
364 :     MotionEstimation(MBParam * const pParam,
365 :     FRAMEINFO * const current,
366 :     FRAMEINFO * const reference,
367 :     const IMAGE * const pRefH,
368 :     const IMAGE * const pRefV,
369 :     const IMAGE * const pRefHV,
370 :     const uint32_t iLimit);
371 :    
372 :     typedef int32_t(Halfpel8_RefineFunc) (const uint8_t * const pRef,
373 :     const uint8_t * const pRefH,
374 :     const uint8_t * const pRefV,
375 :     const uint8_t * const pRefHV,
376 :     const uint8_t * const cur,
377 :     const int x,
378 :     const int y,
379 :     VECTOR * const currMV,
380 :     int32_t iMinSAD,
381 :     const int center_x,
382 :     const int center_y,
383 :     const int32_t min_dx,
384 :     const int32_t max_dx,
385 :     const int32_t min_dy,
386 :     const int32_t max_dy,
387 :     const int32_t iFcode,
388 :     const int32_t iQuant,
389 :     const int32_t iEdgedWidth);
390 :    
391 :     typedef Halfpel8_RefineFunc *Halfpel8_RefineFuncPtr;
392 :     extern Halfpel8_RefineFuncPtr Halfpel8_Refine;
393 :     Halfpel8_RefineFunc Halfpel8_Refine_c;
394 :     Halfpel8_RefineFunc Halfpel8_Refine_ia64;
395 :    
396 :    
397 :     #endif /* _MOTION_H_ */

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