?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r1009: Move the dependencies to newer package names
[cinelerra_cv/mob.git] / quicktime / encore50 / mot_util.c
blob6b08f268e05bce27f36bbab36189a82775a2cbfc
1
2 /**************************************************************************
3 * *
4 * This code is developed by Adam Li. This software is an *
5 * implementation of a part of one or more MPEG-4 Video tools as *
6 * specified in ISO/IEC 14496-2 standard. Those intending to use this *
7 * software module in hardware or software products are advised that its *
8 * use may infringe existing patents or copyrights, and any such use *
9 * would be at such party's own risk. The original developer of this *
10 * software module and his/her company, and subsequent editors and their *
11 * companies (including Project Mayo), will have no liability for use of *
12 * this software or modifications or derivatives thereof. *
13 * *
14 * Project Mayo gives users of the Codec a license to this software *
15 * module or modifications thereof for use in hardware or software *
16 * products claiming conformance to the MPEG-4 Video Standard as *
17 * described in the Open DivX license. *
18 * *
19 * The complete Open DivX license can be found at *
20 * http://www.projectmayo.com/opendivx/license.php . *
21 * *
22 **************************************************************************/
23
24 /**************************************************************************
25 *
26 * mot_util.c
27 *
28 * Copyright (C) 2001 Project Mayo
29 *
30 * Adam Li
31 *
32 * DivX Advance Research Center <darc@projectmayo.com>
33 *
34 **************************************************************************/
35
36 /* This file contains some utility functions to for motion estimation and */
37 /* compensation. */
38 /* Some codes of this project come from MoMuSys MPEG-4 implementation. */
39 /* Please see seperate acknowledgement file for a list of contributors. */
40
41 #include "mom_structs.h"
42 #include "vm_common_defs.h"
43
44 #include "mot_util.h"
45
46 /* ------------------------------------------------------------------------- */
47
48 /* Macro to compute the MB absolute error difference of the inside the shape */
49
50 //static Int P_diff;
51 #define DIFF1(v1,v2,idx) (P_diff = (v1[idx]-v2[idx]), ABS(P_diff))
52
53 /***********************************************************CommentBegin******
54 *
55 * -- InterpolateImage -- Interpolates a complete (SInt)image
56 *
57 * Purpose :
58 * Interpolates a complete (SInt) image for easier half pel prediction
59 *
60 ***********************************************************CommentEnd********/
61
62 Void
63 InterpolateImage(
64 Image *input_image, /* <-- image to interpolate (SInt) */
65 Image *output_image, /* --> interpolated image (SInt) */
66 Int rounding_control
67 )
68 {
69 SInt *ii, *oo;
70 UInt i, j;
71 UInt width, height;
72
73 width = input_image->x;
74 height = input_image->y;
75 ii = (SInt*)GetImageData(output_image);
76 oo = (SInt*)GetImageData(input_image);
77
78 /* main image */
79 for (j = 0; j < height-1; j++)
80 {
81 for (i = 0; i < width-1; i++)
82 {
83 *(ii + (i<<1)) = *(oo + i);
84 *(ii + (i<<1)+1) = (*(oo + i) + *(oo + i + 1) + 1- rounding_control)>>1;
85 *(ii + (i<<1)+(width<<1)) = (*(oo + i) + *(oo + i + width) + 1-
86 rounding_control)>>1;
87 *(ii + (i<<1)+1+(width<<1)) = (*(oo+i) + *(oo+i+1) +
88 *(oo+i+width) + *(oo+i+1+width) + 2-
89 rounding_control)>>2;
90 }
91 /* last pels on each line */
92 *(ii+ (width<<1) - 2) = *(oo + width - 1);
93 *(ii+ (width<<1) - 1) = *(oo + width - 1);
94 *(ii+ (width<<1)+ (width<<1)-2) = (*(oo+width-1)+*(oo+width+width-1)+1-
95 rounding_control)>>1;
96 *(ii+ (width<<1)+ (width<<1)-1) = (*(oo+width-1)+*(oo+width+width-1)+1-
97 rounding_control)>>1;
98 ii += (width<<2);
99 oo += width;
100 }
101
102 /* last lines */
103 for (i = 0; i < width-1; i++)
104 {
105 *(ii+ (i<<1)) = *(oo + i);
106 *(ii+ (i<<1)+1) = (*(oo + i) + *(oo + i + 1) + 1- rounding_control)>>1;
107 *(ii+ (width<<1)+ (i<<1)) = *(oo + i);
108 *(ii+ (width<<1)+ (i<<1)+1) = (*(oo + i) + *(oo + i + 1) + 1-
109 rounding_control)>>1;
110 }
111
112 /* bottom right corner pels */
113 *(ii + (width<<1) - 2) = *(oo + width -1);
114 *(ii + (width<<1) - 1) = *(oo + width -1);
115 *(ii + (width<<2) - 2) = *(oo + width -1);
116 *(ii + (width<<2) - 1) = *(oo + width -1);
117
118 return;
119 }
120
121
122 /***********************************************************CommentBegin******
123 *
124 * -- GetMotionImages --
125 *
126 * Purpose :
127 * Translate the MVs data from the resulting separated four
128 * (Float) Images (16x16/8x8, X,Y) of the motion estimation process
129 * into two Images, which contain the 16x16 and 8x8 MVs
130 * values acording to the modes (MBM_INTRA, MBM_INTER16,
131 * MBM_INTER8). It also
132 * makes a copy of imode16 (SInt-Image of modes).
133 *
134 * Return values :
135 * 1 on success, -1 on error
136 *
137 ***********************************************************CommentEnd********/
138
139 Int
140 GetMotionImages(
141 Image *imv16_w, /* <-- 16x16 horiz. MV Float-Image (MxN) (cuad.) */
142 Image *imv16_h, /* <-- 16x16 verti. MV Float-Image (MxN) (cuad.) */
143 Image *imv8_w, /* <-- 8x8 horizontal MV Float-Image (MxN) */
144 Image *imv8_h, /* <-- 8x8 vertical MV Float-Image (MxN) */
145 Image *imode16, /* <-- SInt-Image of modes (M/2xN/2) */
146 Image **mv_x, /* --> horizontal MV Float-Image (MxN) */
147 Image **mv_y, /* --> vertical MV Float-Image (MxN) */
148 Image **mode /* --> SInt-Image of modes (M/2xN/2) */
149 )
150 {
151
152 Int i, j;
153 Int width, height, base;
154 Float val_x, val_y;
155 Float *data_x, *data_y,
156 *mv16_w, *mv16_h,
157 *mv8_w, *mv8_h;
158 SInt *mode16, *data_mode;
159 SInt modo;
160
161 width = imode16->x; height = imode16->y;
162
163 (*mode)=AllocImage(width,height,SHORT_TYPE);
164 (*mv_x)=AllocImage(width*2,height*2,FLOAT_TYPE);
165 (*mv_y)=AllocImage(width*2,height*2,FLOAT_TYPE);
166 data_x = (Float*)GetImageData((*mv_x));
167 data_y = (Float*)GetImageData((*mv_y));
168 data_mode = (SInt*)GetImageData((*mode));
169 mode16=(SInt*)GetImageData(imode16);
170 mv16_w=(Float*)GetImageData(imv16_w);
171 mv16_h=(Float*)GetImageData(imv16_h);
172 mv8_w=(Float*)GetImageData(imv8_w);
173 mv8_h=(Float*)GetImageData(imv8_h);
174
175 for(j=0;j<height;j++)
176 {
177 for(i=0;i< width;i++)
178 {
179 modo=data_mode[j*width+i]=mode16[j*width+i];
180 if ( modo==MBM_INTRA) /*INTRA*/
181 {
182 base=2*j*2*width+2*i;
183 data_x[base]=0.0; data_x[base+1]=0.0;
184 data_y[base]=0.0; data_y[base+1]=0.0;
185 base+=width*2;
186 data_x[base]=0.0; data_x[base+1]=0.0;
187 data_y[base]=0.0; data_y[base+1]=0.0;
188 }
189 else if(modo==MBM_INTER16) /*INTER 16*/
190 {
191 base=2*j*2*width+2*i;
192 val_x=mv16_w[base];val_y=mv16_h[base];
193
194 data_x[base]=val_x; data_x[base+1]=val_x;
195 data_y[base]=val_y; data_y[base+1]=val_y;
196 base+=width*2;
197 data_x[base]=val_x; data_x[base+1]=val_x;
198 data_y[base]=val_y; data_y[base+1]=val_y;
199 }
200 else if (modo==MBM_INTER8) /*INTER4*8*/
201 {
202 base=2*j*2*width+2*i;
203
204 data_x[base] = mv8_w[base];
205 data_y[base] = mv8_h[base];
206 data_x[base+1] = mv8_w[base+1];
207 data_y[base+1] = mv8_h[base+1];
208 base+=width*2;
209 data_x[base] = mv8_w[base];
210 data_y[base] = mv8_h[base];
211 data_x[base+1] = mv8_w[base+1];
212 data_y[base+1] = mv8_h[base+1];
213 }
214 } /* end for*/
215 } /* end for*/
216
217 return(1);
218 }
219
220
221 /***********************************************************CommentBegin******
222 *
223 * -- ChooseMode -- chooses coding mode INTRA/INTER dependig on the SAD values
224 *
225 * Purpose :
226 * chooses coding mode INTRA/INTER dependig on the SAD values
227 *
228 * Return values :
229 * 1 for INTER, 0 for INTRA
230 *
231 ***********************************************************CommentEnd********/
232
233 Int
234 ChooseMode(
235 SInt *curr, /* <-- current Y values (not extended) */
236 Int x_pos, /* <-- upper-left MB corner hor. coor. */
237 Int y_pos, /* <-- upper-left MB corner ver. coor. */
238 Int min_SAD, /* <-- min SAD (from integer pel search) */
239 UInt width /* <-- current Y picture width */
240 )
241 {
242 Int i, j;
243 Int MB_mean = 0, A = 0;
244 Int y_off;
245
246 for (j = 0; j < MB_SIZE; j++)
247 {
248 y_off = (y_pos + j) * width;
249 for (i = 0; i < MB_SIZE; i++)
250 {
251 MB_mean += *(curr + x_pos + i + y_off);
252 }
253 }
254
255 MB_mean /= 256;
256
257 for (j = 0; j < MB_SIZE; j++)
258 {
259 y_off = (y_pos + j) * width;
260 for (i = 0; i < MB_SIZE; i++)
261 {
262 A += abs( *(curr + x_pos + i + y_off) - MB_mean );
263 }
264 }
265
266 if (A < (min_SAD - 2*256))
267 return 0;
268 else
269 return 1;
270 }
271
272
273 /***********************************************************CommentBegin******
274 *
275 * -- SAD_Macroblock -- obtains the SAD for a Macroblock
276 *
277 * Purpose :
278 * obtains the SAD for a Macroblock
279 *
280 * Return values :
281 * sad of the MB
282 *
283 ***********************************************************CommentEnd********/
284
285 Int
286 SAD_Macroblock(
287 SInt *ii, /* <-- Pointer to the upper-left pel of first MB */
288 SInt *act_block, /* <-- Id, second MB (width=16) */
289 UInt h_length, /* <-- Width of first area */
290 Int Min_FRAME /* <-- Minimum prediction error so far */
291 )
292 {
293 /* Int i;
294 Int sad = 0;
295 SInt *kk;
296 register Int P_diff;
297
298 kk = act_block;
299 i = 16;
300 while (i--)
301 {
302 sad += (DIFF1(ii,kk,0)+DIFF1(ii,kk,1)
303 +DIFF1(ii,kk,2)+DIFF1(ii,kk,3)
304 +DIFF1(ii,kk,4)+DIFF1(ii,kk,5)
305 +DIFF1(ii,kk,6)+DIFF1(ii,kk,7)
306 +DIFF1(ii,kk,8)+DIFF1(ii,kk,9)
307 +DIFF1(ii,kk,10)+DIFF1(ii,kk,11)
308 +DIFF1(ii,kk,12)+DIFF1(ii,kk,13)
309 +DIFF1(ii,kk,14)+DIFF1(ii,kk,15)
310 );
311
312 ii += h_length;
313 kk += 16;
314 if (sad > Min_FRAME)
315 return MV_MAX_ERROR;
316 }
317
318 return sad;
319 */
320 int i, j;
321 int sad = 0;
322 SInt *p1 = ii, *p2 = act_block;
323
324 i = 16;
325 while (i--) {
326 j = 16;
327 while (j --)
328 sad += abs((int)*(p1++) - (int)*(p2++));
329 if (sad > Min_FRAME)
330 return MV_MAX_ERROR;
331 p1 += h_length - 16;
332 }
333
334 return sad;
335 }
336
337
338 /***********************************************************CommentBegin******
339 *
340 * -- SAD_Block -- obtains the SAD for a Block
341 *
342 * Purpose :
343 * obtains the SAD for a Block
344 *
345 * Return values :
346 * sad of the Block
347 *
348 ***********************************************************CommentEnd********/
349
350 Int
351 SAD_Block(
352 SInt *ii, /* <-- First area */
353 SInt *act_block, /* <-- Id. second MB (width=16) */
354 UInt h_length, /* <-- Width of first area */
355 Int min_sofar /* <-- Minimum prediction error so far */
356 )
357 {
358 /* Int i;
359 Int sad = 0;
360 SInt *kk;
361 register Int P_diff;
362
363 kk = act_block;
364 i = 8;
365 while (i--)
366 {
367 sad += (DIFF1(ii,kk,0)+DIFF1(ii,kk,1)
368 +DIFF1(ii,kk,2)+DIFF1(ii,kk,3)
369 +DIFF1(ii,kk,4)+DIFF1(ii,kk,5)
370 +DIFF1(ii,kk,6)+DIFF1(ii,kk,7)
371 );
372
373 ii += h_length;
374 kk += 16;
375 if (sad > min_sofar)
376 return INT_MAX;
377 }
378
379 return sad;
380 */
381 int i, j;
382 int sad = 0;
383 SInt *p1 = ii, *p2 = act_block;
384
385 i = 8;
386 while (i--) {
387 j = 8;
388 while (j --)
389 sad += abs((int)*(p1++) - (int)*(p2++));
390 if (sad > min_sofar)
391 return INT_MAX;
392 p1 += h_length - 8;
393 p2 += 16 - 8;
394 }
395
396 return sad;
397 }
398
399
400
401 /***********************************************************CommentBegin******
402 *
403 * -- LoadArea -- fills array with a image-data
404 *
405 * Purpose :
406 * fills array with a image-data
407 *
408 * Return values :
409 * Pointer to the filled array
410 *
411 ***********************************************************CommentEnd********/
412
413 Void
414 LoadArea(
415 SInt *im, /* <-- pointer to image */
416 Int x, /* <-- horizontal pos */
417 Int y, /* <-- vertical pos */
418 Int x_size, /* <-- width of array */
419 Int y_size, /* <-- height of array */
420 Int lx, /* <-- width of the image data */
421 SInt *block /* <-> pointer to the array */
422 )
423 {
424 SInt *in;
425 SInt *out;
426 Int i = x_size;
427 Int j = y_size;
428
429 in = im + (y*lx) + x;
430 out = block;
431
432 while (j--)
433 {
434 while (i--)
435 *out++ = *in++;
436 i = x_size;
437 in += lx - x_size;
438 }
439
440 return;
441 }
442
443
444 /***********************************************************CommentBegin******
445 *
446 * -- SetArea -- fills a image-data with an array
447 *
448 * Purpose :
449 * fills a image-data with an array
450 *
451 ***********************************************************CommentEnd********/
452
453 Void
454 SetArea(
455 SInt *block, /* <-- pointer to array */
456 Int x, /* <-- horizontal pos in image */
457 Int y, /* <-- vertical pos in image */
458 Int x_size, /* <-- width of array */
459 Int y_size, /* <-- height of array */
460 Int lx, /* <-- width of the image data */
461 SInt *im /* --> pointer to image */
462 )
463 {
464 SInt *in;
465 SInt *out;
466 Int i = x_size;
467 Int j = y_size;
468
469 in = block;
470 out = im + (y*lx) + x;
471
472 while (j--)
473 {
474 while (i--)
475 *out++ = *in++;
476 i = x_size;
477 out += lx - x_size;
478 }
479 }
480
481
mob repository