[svn] / branches / dev-api-4 / xvidcore / src / motion / motion_comp.c Repository:
ViewVC logotype

Annotation of /branches/dev-api-4/xvidcore/src/motion/motion_comp.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 935 - (view) (download)

1 : edgomez 851 // 30.10.2002 corrected qpel chroma rounding
2 :     // 04.10.2002 added qpel support to MBMotionCompensation
3 :     // 01.05.2002 updated MBMotionCompensationBVOP
4 :     // 14.04.2002 bframe compensation
5 : suxen_drol 118
6 : edgomez 851 #include <stdio.h>
7 :    
8 : Isibaar 3 #include "../encoder.h"
9 :     #include "../utils/mbfunctions.h"
10 :     #include "../image/interpolate8x8.h"
11 : edgomez 851 #include "../image/reduced.h"
12 : Isibaar 3 #include "../utils/timer.h"
13 : suxen_drol 118 #include "motion.h"
14 : Isibaar 3
15 : edgomez 851 #ifndef ABS
16 : Isibaar 3 #define ABS(X) (((X)>0)?(X):-(X))
17 : edgomez 851 #endif
18 :     #ifndef SIGN
19 : Isibaar 3 #define SIGN(X) (((X)>0)?1:-1)
20 : edgomez 851 #endif
21 : Isibaar 3
22 : edgomez 851 #ifndef RSHIFT
23 :     #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
24 :     #endif
25 :    
26 :     /* assume b>0 */
27 :     #ifndef RDIV
28 :     #define RDIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
29 :     #endif
30 :    
31 :    
32 : syskin 935 /* This is borrowed from decoder.c */
33 : edgomez 851 static __inline int gmc_sanitize(int value, int quarterpel, int fcode)
34 :     {
35 :     int length = 1 << (fcode+4);
36 :    
37 :     // if (quarterpel) value *= 2;
38 :    
39 : syskin 935 if (value < -length)
40 : edgomez 851 return -length;
41 : syskin 935 else if (value >= length)
42 : edgomez 851 return length-1;
43 :     else return value;
44 :     }
45 :    
46 :     /* And this is borrowed from bitstream.c until we find a common solution */
47 :    
48 :     static uint32_t __inline
49 :     log2bin(uint32_t value)
50 :     {
51 :     /* Changed by Chenm001 */
52 :     #if !defined(_MSC_VER)
53 :     int n = 0;
54 :    
55 :     while (value) {
56 :     value >>= 1;
57 :     n++;
58 :     }
59 :     return n;
60 :     #else
61 :     __asm {
62 : syskin 935 bsr eax, value
63 : edgomez 851 inc eax
64 :     }
65 :     #endif
66 :     }
67 :    
68 :    
69 : edgomez 195 static __inline void
70 : edgomez 851 compensate16x16_interpolate(int16_t * const dct_codes,
71 :     uint8_t * const cur,
72 :     const uint8_t * const ref,
73 :     const uint8_t * const refh,
74 :     const uint8_t * const refv,
75 :     const uint8_t * const refhv,
76 :     uint8_t * const tmp,
77 :     uint32_t x,
78 :     uint32_t y,
79 :     const int32_t dx,
80 :     const int32_t dy,
81 :     const int32_t stride,
82 :     const int quarterpel,
83 :     const int reduced_resolution,
84 :     const int32_t rounding)
85 : Isibaar 3 {
86 : edgomez 851 const uint8_t * ptr;
87 : Isibaar 3
88 : edgomez 851 if (!reduced_resolution) {
89 : Isibaar 3
90 : edgomez 851 if(quarterpel) {
91 :     if ((dx&3) | (dy&3)) {
92 :     interpolate16x16_quarterpel(tmp - y * stride - x,
93 :     (uint8_t *) ref, tmp + 32,
94 :     tmp + 64, tmp + 96, x, y, dx, dy, stride, rounding);
95 :     ptr = tmp;
96 :     } else ptr = ref + (y + dy/4)*stride + x + dx/4; // fullpixel position
97 : Isibaar 3
98 : edgomez 851 } else ptr = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
99 :    
100 : edgomez 195 transfer_8to16sub(dct_codes, cur + y * stride + x,
101 : syskin 935 ptr, stride);
102 : edgomez 851 transfer_8to16sub(dct_codes+64, cur + y * stride + x + 8,
103 : syskin 935 ptr + 8, stride);
104 : edgomez 851 transfer_8to16sub(dct_codes+128, cur + y * stride + x + 8*stride,
105 : syskin 935 ptr + 8*stride, stride);
106 : edgomez 851 transfer_8to16sub(dct_codes+192, cur + y * stride + x + 8*stride+8,
107 : syskin 935 ptr + 8*stride + 8, stride);
108 : Isibaar 3
109 : edgomez 851 } else { //reduced_resolution
110 : syskin 935
111 : edgomez 851 x *= 2; y *= 2;
112 :    
113 :     ptr = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
114 : syskin 935
115 : edgomez 851 filter_18x18_to_8x8(dct_codes, cur+y*stride + x, stride);
116 :     filter_diff_18x18_to_8x8(dct_codes, ptr, stride);
117 :    
118 :     filter_18x18_to_8x8(dct_codes+64, cur+y*stride + x + 16, stride);
119 :     filter_diff_18x18_to_8x8(dct_codes+64, ptr + 16, stride);
120 :    
121 :     filter_18x18_to_8x8(dct_codes+128, cur+(y+16)*stride + x, stride);
122 :     filter_diff_18x18_to_8x8(dct_codes+128, ptr + 16*stride, stride);
123 :    
124 :     filter_18x18_to_8x8(dct_codes+192, cur+(y+16)*stride + x + 16, stride);
125 :     filter_diff_18x18_to_8x8(dct_codes+192, ptr + 16*stride + 16, stride);
126 :    
127 :     transfer32x32_copy(cur + y*stride + x, ptr, stride);
128 : edgomez 195 }
129 : Isibaar 3 }
130 :    
131 : edgomez 851 static __inline void
132 :     compensate8x8_interpolate( int16_t * const dct_codes,
133 :     uint8_t * const cur,
134 :     const uint8_t * const ref,
135 :     const uint8_t * const refh,
136 :     const uint8_t * const refv,
137 :     const uint8_t * const refhv,
138 :     uint8_t * const tmp,
139 :     uint32_t x,
140 :     uint32_t y,
141 :     const int32_t dx,
142 :     const int32_t dy,
143 :     const int32_t stride,
144 :     const int32_t quarterpel,
145 :     const int reduced_resolution,
146 :     const int32_t rounding)
147 :     {
148 :     const uint8_t * ptr;
149 : Isibaar 3
150 : edgomez 851 if (!reduced_resolution) {
151 : Isibaar 3
152 : edgomez 851 if(quarterpel) {
153 :     if ((dx&3) | (dy&3)) {
154 :     interpolate8x8_quarterpel(tmp - y*stride - x,
155 :     (uint8_t *) ref, tmp + 32,
156 :     tmp + 64, tmp + 96, x, y, dx, dy, stride, rounding);
157 :     ptr = tmp;
158 :     } else ptr = ref + (y + dy/4)*stride + x + dx/4; // fullpixel position
159 :     } else ptr = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
160 :    
161 :     transfer_8to16sub(dct_codes, cur + y * stride + x, ptr, stride);
162 :    
163 :     } else { //reduced_resolution
164 :    
165 :     x *= 2; y *= 2;
166 :    
167 :     ptr = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
168 :    
169 :     filter_18x18_to_8x8(dct_codes, cur+y*stride + x, stride);
170 :     filter_diff_18x18_to_8x8(dct_codes, ptr, stride);
171 : syskin 935
172 : edgomez 851 transfer16x16_copy(cur + y*stride + x, ptr, stride);
173 :     }
174 :     }
175 :    
176 :     /* XXX: slow, inelegant... */
177 :     static void
178 :     interpolate18x18_switch(uint8_t * const cur,
179 :     const uint8_t * const refn,
180 :     const uint32_t x,
181 :     const uint32_t y,
182 :     const int32_t dx,
183 :     const int dy,
184 :     const int32_t stride,
185 :     const int32_t rounding)
186 :     {
187 :     interpolate8x8_switch(cur, refn, x-1, y-1, dx, dy, stride, rounding);
188 :     interpolate8x8_switch(cur, refn, x+7, y-1, dx, dy, stride, rounding);
189 :     interpolate8x8_switch(cur, refn, x+9, y-1, dx, dy, stride, rounding);
190 :    
191 :     interpolate8x8_switch(cur, refn, x-1, y+7, dx, dy, stride, rounding);
192 :     interpolate8x8_switch(cur, refn, x+7, y+7, dx, dy, stride, rounding);
193 :     interpolate8x8_switch(cur, refn, x+9, y+7, dx, dy, stride, rounding);
194 :    
195 :     interpolate8x8_switch(cur, refn, x-1, y+9, dx, dy, stride, rounding);
196 :     interpolate8x8_switch(cur, refn, x+7, y+9, dx, dy, stride, rounding);
197 :     interpolate8x8_switch(cur, refn, x+9, y+9, dx, dy, stride, rounding);
198 :     }
199 :    
200 :     static void
201 :     CompensateChroma( int dx, int dy,
202 :     const int i, const int j,
203 :     IMAGE * const Cur,
204 :     const IMAGE * const Ref,
205 :     uint8_t * const temp,
206 :     int16_t * const coeff,
207 :     const int32_t stride,
208 :     const int rounding,
209 :     const int rrv)
210 :     { /* uv-block-based compensation */
211 :    
212 :     if (!rrv) {
213 :     transfer_8to16sub(coeff, Cur->u + 8 * j * stride + 8 * i,
214 : syskin 935 interpolate8x8_switch2(temp, Ref->u, 8 * i, 8 * j,
215 : edgomez 851 dx, dy, stride, rounding),
216 :     stride);
217 :     transfer_8to16sub(coeff + 64, Cur->v + 8 * j * stride + 8 * i,
218 : syskin 935 interpolate8x8_switch2(temp, Ref->v, 8 * i, 8 * j,
219 : edgomez 851 dx, dy, stride, rounding),
220 :     stride);
221 :     } else {
222 :     uint8_t * current, * reference;
223 :    
224 :     current = Cur->u + 16*j*stride + 16*i;
225 :     reference = temp - 16*j*stride - 16*i;
226 :     interpolate18x18_switch(reference, Ref->u, 16*i, 16*j, dx, dy, stride, rounding);
227 :     filter_18x18_to_8x8(coeff, current, stride);
228 :     filter_diff_18x18_to_8x8(coeff, temp, stride);
229 :     transfer16x16_copy(current, temp, stride);
230 :    
231 :     current = Cur->v + 16*j*stride + 16*i;
232 :     interpolate18x18_switch(reference, Ref->v, 16*i, 16*j, dx, dy, stride, rounding);
233 :     filter_18x18_to_8x8(coeff + 64, current, stride);
234 :     filter_diff_18x18_to_8x8(coeff + 64, temp, stride);
235 :     transfer16x16_copy(current, temp, stride);
236 :     }
237 :     }
238 :    
239 : edgomez 195 void
240 :     MBMotionCompensation(MACROBLOCK * const mb,
241 : syskin 935 const uint32_t i,
242 :     const uint32_t j,
243 :     const IMAGE * const ref,
244 :     const IMAGE * const refh,
245 :     const IMAGE * const refv,
246 :     const IMAGE * const refhv,
247 :     const IMAGE * const refGMC,
248 :     IMAGE * const cur,
249 :     int16_t * dct_codes,
250 :     const uint32_t width,
251 :     const uint32_t height,
252 :     const uint32_t edged_width,
253 :     const int32_t quarterpel,
254 :     const int reduced_resolution,
255 :     const int32_t rounding)
256 : Isibaar 3 {
257 : edgomez 851 int32_t dx;
258 :     int32_t dy;
259 : Isibaar 3
260 : edgomez 851 uint8_t * const tmp = refv->u;
261 : Isibaar 3
262 : edgomez 851 if ( (!reduced_resolution) && (mb->mode == MODE_NOT_CODED) ) { /* quick copy for early SKIP */
263 :     /* early SKIP is only activated in P-VOPs, not in S-VOPs, so mcsel can never be 1 */
264 : Isibaar 3
265 : edgomez 851 transfer16x16_copy(cur->y + 16 * (i + j * edged_width),
266 : syskin 935 ref->y + 16 * (i + j * edged_width),
267 :     edged_width);
268 :    
269 : edgomez 851 transfer8x8_copy(cur->u + 8 * (i + j * edged_width/2),
270 :     ref->u + 8 * (i + j * edged_width/2),
271 :     edged_width / 2);
272 :     transfer8x8_copy(cur->v + 8 * (i + j * edged_width/2),
273 :     ref->v + 8 * (i + j * edged_width/2),
274 :     edged_width / 2);
275 :     return;
276 :     }
277 : Isibaar 3
278 : syskin 935 if ((mb->mode == MODE_NOT_CODED || mb->mode == MODE_INTER
279 : edgomez 851 || mb->mode == MODE_INTER_Q)) {
280 : chl 437
281 : edgomez 851 /* reduced resolution + GMC: not possible */
282 : Isibaar 3
283 : edgomez 851 if (mb->mcsel) {
284 : syskin 935
285 : edgomez 851 /* call normal routine once, easier than "if (mcsel)"ing all the time */
286 : syskin 935
287 : edgomez 851 transfer_8to16sub(&dct_codes[0*64], cur->y + 16*j*edged_width + 16*i,
288 : syskin 935 refGMC->y + 16*j*edged_width + 16*i, edged_width);
289 : edgomez 851 transfer_8to16sub(&dct_codes[1*64], cur->y + 16*j*edged_width + 16*i+8,
290 : syskin 935 refGMC->y + 16*j*edged_width + 16*i+8, edged_width);
291 : edgomez 851 transfer_8to16sub(&dct_codes[2*64], cur->y + (16*j+8)*edged_width + 16*i,
292 : syskin 935 refGMC->y + (16*j+8)*edged_width + 16*i, edged_width);
293 : edgomez 851 transfer_8to16sub(&dct_codes[3*64], cur->y + (16*j+8)*edged_width + 16*i+8,
294 : syskin 935 refGMC->y + (16*j+8)*edged_width + 16*i+8, edged_width);
295 : chl 437
296 : edgomez 851 /* lumi is needed earlier for mode decision, but chroma should be done block-based, but it isn't, yet. */
297 :    
298 :     transfer_8to16sub(&dct_codes[4 * 64], cur->u + 8 *j*edged_width/2 + 8*i,
299 :     refGMC->u + 8 *j*edged_width/2 + 8*i, edged_width/2);
300 :    
301 :     transfer_8to16sub(&dct_codes[5 * 64], cur->v + 8*j* edged_width/2 + 8*i,
302 :     refGMC->v + 8*j* edged_width/2 + 8*i, edged_width/2);
303 :    
304 :     return;
305 :     }
306 :    
307 :     /* ordinary compensation */
308 : syskin 935
309 : edgomez 851 dx = (quarterpel ? mb->qmvs[0].x : mb->mvs[0].x);
310 :     dy = (quarterpel ? mb->qmvs[0].y : mb->mvs[0].y);
311 :    
312 :     if (reduced_resolution) {
313 :     dx = RRV_MV_SCALEUP(dx);
314 :     dy = RRV_MV_SCALEUP(dy);
315 :     }
316 :    
317 :     compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,
318 :     refv->y, refhv->y, tmp, 16 * i, 16 * j, dx, dy,
319 :     edged_width, quarterpel, reduced_resolution, rounding);
320 :    
321 : syskin 935 if (quarterpel) { dx /= 2; dy /= 2; }
322 :    
323 : edgomez 851 dx = (dx >> 1) + roundtab_79[dx & 0x3];
324 :     dy = (dy >> 1) + roundtab_79[dy & 0x3];
325 :    
326 :     } else { // mode == MODE_INTER4V
327 :     int k, sumx = 0, sumy = 0;
328 :     const VECTOR * const mvs = (quarterpel ? mb->qmvs : mb->mvs);
329 :    
330 :     for (k = 0; k < 4; k++) {
331 :     dx = mvs[k].x;
332 :     dy = mvs[k].y;
333 : syskin 935 sumx += quarterpel ? dx/2 : dx;
334 :     sumy += quarterpel ? dy/2 : dy;
335 : edgomez 851
336 :     if (reduced_resolution){
337 :     dx = RRV_MV_SCALEUP(dx);
338 :     dy = RRV_MV_SCALEUP(dy);
339 :     }
340 :    
341 :     compensate8x8_interpolate(&dct_codes[k * 64], cur->y, ref->y, refh->y,
342 :     refv->y, refhv->y, tmp, 16 * i + 8*(k&1), 16 * j + 8*(k>>1), dx,
343 :     dy, edged_width, quarterpel, reduced_resolution, rounding);
344 :     }
345 :     dx = (sumx >> 3) + roundtab_76[sumx & 0xf];
346 :     dy = (sumy >> 3) + roundtab_76[sumy & 0xf];
347 :     }
348 :    
349 :     CompensateChroma(dx, dy, i, j, cur, ref, tmp,
350 :     &dct_codes[4 * 64], edged_width / 2, rounding, reduced_resolution);
351 :     }
352 :    
353 :    
354 :     void
355 :     MBMotionCompensationBVOP(MBParam * pParam,
356 :     MACROBLOCK * const mb,
357 :     const uint32_t i,
358 :     const uint32_t j,
359 :     IMAGE * const cur,
360 :     const IMAGE * const f_ref,
361 :     const IMAGE * const f_refh,
362 :     const IMAGE * const f_refv,
363 :     const IMAGE * const f_refhv,
364 :     const IMAGE * const b_ref,
365 :     const IMAGE * const b_refh,
366 :     const IMAGE * const b_refv,
367 :     const IMAGE * const b_refhv,
368 :     int16_t * dct_codes)
369 :     {
370 :     const uint32_t edged_width = pParam->edged_width;
371 :     int32_t dx, dy, b_dx, b_dy, sumx, sumy, b_sumx, b_sumy;
372 :     int k;
373 : suxen_drol 890 const int quarterpel = pParam->vol_flags & XVID_QUARTERPEL;
374 : edgomez 851 const uint8_t * ptr1, * ptr2;
375 :     uint8_t * const tmp = f_refv->u;
376 :     const VECTOR * const fmvs = (quarterpel ? mb->qmvs : mb->mvs);
377 :     const VECTOR * const bmvs = (quarterpel ? mb->b_qmvs : mb->b_mvs);
378 :    
379 :     switch (mb->mode) {
380 :     case MODE_FORWARD:
381 :     dx = fmvs->x; dy = fmvs->y;
382 :    
383 :     compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, f_ref->y, f_refh->y,
384 :     f_refv->y, f_refhv->y, tmp, 16 * i, 16 * j, dx,
385 :     dy, edged_width, quarterpel, 0, 0);
386 :    
387 :     if (quarterpel) { dx /= 2; dy /= 2; }
388 :    
389 :     CompensateChroma( (dx >> 1) + roundtab_79[dx & 0x3],
390 :     (dy >> 1) + roundtab_79[dy & 0x3],
391 :     i, j, cur, f_ref, tmp,
392 :     &dct_codes[4 * 64], edged_width / 2, 0, 0);
393 :    
394 :     return;
395 :    
396 :     case MODE_BACKWARD:
397 :     b_dx = bmvs->x; b_dy = bmvs->y;
398 :    
399 : syskin 935 compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, b_ref->y, b_refh->y,
400 : edgomez 851 b_refv->y, b_refhv->y, tmp, 16 * i, 16 * j, b_dx,
401 : syskin 935 b_dy, edged_width, quarterpel, 0, 0);
402 : edgomez 851
403 :     if (quarterpel) { b_dx /= 2; b_dy /= 2; }
404 :    
405 :     CompensateChroma( (b_dx >> 1) + roundtab_79[b_dx & 0x3],
406 :     (b_dy >> 1) + roundtab_79[b_dy & 0x3],
407 :     i, j, cur, b_ref, tmp,
408 :     &dct_codes[4 * 64], edged_width / 2, 0, 0);
409 :    
410 :     return;
411 :    
412 :     case MODE_INTERPOLATE: /* _could_ use DIRECT, but would be overkill (no 4MV there) */
413 :     case MODE_DIRECT_NO4V:
414 :     dx = fmvs->x; dy = fmvs->y;
415 :     b_dx = bmvs->x; b_dy = bmvs->y;
416 :    
417 :     if (quarterpel) {
418 : syskin 935
419 : edgomez 851 if ((dx&3) | (dy&3)) {
420 :     interpolate16x16_quarterpel(tmp - i * 16 - j * 16 * edged_width,
421 :     (uint8_t *) f_ref->y, tmp + 32,
422 :     tmp + 64, tmp + 96, 16*i, 16*j, dx, dy, edged_width, 0);
423 :     ptr1 = tmp;
424 :     } else ptr1 = f_ref->y + (16*j + dy/4)*edged_width + 16*i + dx/4; // fullpixel position
425 :    
426 :     if ((b_dx&3) | (b_dy&3)) {
427 :     interpolate16x16_quarterpel(tmp - i * 16 - j * 16 * edged_width + 16,
428 :     (uint8_t *) b_ref->y, tmp + 32,
429 :     tmp + 64, tmp + 96, 16*i, 16*j, b_dx, b_dy, edged_width, 0);
430 :     ptr2 = tmp + 16;
431 :     } else ptr2 = b_ref->y + (16*j + b_dy/4)*edged_width + 16*i + b_dx/4; // fullpixel position
432 :    
433 :     b_dx /= 2;
434 :     b_dy /= 2;
435 :     dx /= 2;
436 :     dy /= 2;
437 :    
438 :     } else {
439 :     ptr1 = get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,
440 :     i, j, 16, dx, dy, edged_width);
441 :    
442 :     ptr2 = get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,
443 :     i, j, 16, b_dx, b_dy, edged_width);
444 :     }
445 :     for (k = 0; k < 4; k++)
446 :     transfer_8to16sub2(&dct_codes[k * 64],
447 :     cur->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
448 :     ptr1 + (k&1)*8 + (k>>1)*8*edged_width,
449 :     ptr2 + (k&1)*8 + (k>>1)*8*edged_width, edged_width);
450 :    
451 :    
452 :     dx = (dx >> 1) + roundtab_79[dx & 0x3];
453 :     dy = (dy >> 1) + roundtab_79[dy & 0x3];
454 :    
455 :     b_dx = (b_dx >> 1) + roundtab_79[b_dx & 0x3];
456 :     b_dy = (b_dy >> 1) + roundtab_79[b_dy & 0x3];
457 :    
458 :     break;
459 : syskin 935
460 :     default: // MODE_DIRECT (or MODE_DIRECT_NONE_MV in case of bframes decoding)
461 : edgomez 851 sumx = sumy = b_sumx = b_sumy = 0;
462 :    
463 :     for (k = 0; k < 4; k++) {
464 : syskin 935
465 : edgomez 851 dx = fmvs[k].x; dy = fmvs[k].y;
466 :     b_dx = bmvs[k].x; b_dy = bmvs[k].y;
467 :    
468 :     if (quarterpel) {
469 :     sumx += dx/2; sumy += dy/2;
470 :     b_sumx += b_dx/2; b_sumy += b_dy/2;
471 :    
472 :     if ((dx&3) | (dy&3)) {
473 :     interpolate8x8_quarterpel(tmp - (i * 16+(k&1)*8) - (j * 16+((k>>1)*8)) * edged_width,
474 : syskin 935 (uint8_t *) f_ref->y,
475 :     tmp + 32, tmp + 64, tmp + 96,
476 : edgomez 851 16*i + (k&1)*8, 16*j + (k>>1)*8, dx, dy, edged_width, 0);
477 :     ptr1 = tmp;
478 :     } else ptr1 = f_ref->y + (16*j + (k>>1)*8 + dy/4)*edged_width + 16*i + (k&1)*8 + dx/4;
479 :    
480 :     if ((b_dx&3) | (b_dy&3)) {
481 :     interpolate8x8_quarterpel(tmp - (i * 16+(k&1)*8) - (j * 16+((k>>1)*8)) * edged_width + 16,
482 :     (uint8_t *) b_ref->y,
483 : syskin 935 tmp + 16, tmp + 32, tmp + 48,
484 : edgomez 851 16*i + (k&1)*8, 16*j + (k>>1)*8, b_dx, b_dy, edged_width, 0);
485 :     ptr2 = tmp + 16;
486 :     } else ptr2 = b_ref->y + (16*j + (k>>1)*8 + b_dy/4)*edged_width + 16*i + (k&1)*8 + b_dx/4;
487 :     } else {
488 :     sumx += dx; sumy += dy;
489 :     b_sumx += b_dx; b_sumy += b_dy;
490 :    
491 : syskin 935 ptr1 = get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,
492 : edgomez 851 2*i + (k&1), 2*j + (k>>1), 8, dx, dy, edged_width);
493 : syskin 935 ptr2 = get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,
494 : edgomez 851 2*i + (k&1), 2*j + (k>>1), 8, b_dx, b_dy, edged_width);
495 :     }
496 :     transfer_8to16sub2(&dct_codes[k * 64],
497 :     cur->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
498 :     ptr1, ptr2, edged_width);
499 : syskin 935
500 : edgomez 851 }
501 :    
502 :     dx = (sumx >> 3) + roundtab_76[sumx & 0xf];
503 :     dy = (sumy >> 3) + roundtab_76[sumy & 0xf];
504 :     b_dx = (b_sumx >> 3) + roundtab_76[b_sumx & 0xf];
505 :     b_dy = (b_sumy >> 3) + roundtab_76[b_sumy & 0xf];
506 :    
507 :     break;
508 :     }
509 :    
510 :     // uv block-based chroma interpolation for direct and interpolate modes
511 :     transfer_8to16sub2(&dct_codes[4 * 64],
512 :     cur->u + (j * 8) * edged_width / 2 + (i * 8),
513 :     interpolate8x8_switch2(tmp, b_ref->u, 8 * i, 8 * j,
514 :     b_dx, b_dy, edged_width / 2, 0),
515 :     interpolate8x8_switch2(tmp + 8, f_ref->u, 8 * i, 8 * j,
516 :     dx, dy, edged_width / 2, 0),
517 :     edged_width / 2);
518 :    
519 :     transfer_8to16sub2(&dct_codes[5 * 64],
520 :     cur->v + (j * 8) * edged_width / 2 + (i * 8),
521 :     interpolate8x8_switch2(tmp, b_ref->v, 8 * i, 8 * j,
522 :     b_dx, b_dy, edged_width / 2, 0),
523 :     interpolate8x8_switch2(tmp + 8, f_ref->v, 8 * i, 8 * j,
524 :     dx, dy, edged_width / 2, 0),
525 :     edged_width / 2);
526 :     }
527 :    
528 :    
529 :    
530 :     void generate_GMCparameters( const int num_wp, const int res,
531 : syskin 935 const WARPPOINTS *const warp,
532 :     const int width, const int height,
533 :     GMC_DATA *const gmc)
534 : edgomez 851 {
535 : syskin 935 const int du0 = warp->duv[0].x;
536 :     const int dv0 = warp->duv[0].y;
537 :     const int du1 = warp->duv[1].x;
538 :     const int dv1 = warp->duv[1].y;
539 :     const int du2 = warp->duv[2].x;
540 :     const int dv2 = warp->duv[2].y;
541 : edgomez 851
542 : syskin 935 gmc->W = width;
543 :     gmc->H = height;
544 : edgomez 851
545 : syskin 935 gmc->rho = 4 - log2bin(res-1); // = {3,2,1,0} for res={2,4,8,16}
546 : edgomez 851
547 : syskin 935 gmc->alpha = log2bin(gmc->W-1);
548 :     gmc->Ws = (1 << gmc->alpha);
549 : edgomez 851
550 : syskin 935 gmc->dxF = 16*gmc->Ws + RDIV( 8*gmc->Ws*du1, gmc->W );
551 :     gmc->dxG = RDIV( 8*gmc->Ws*dv1, gmc->W );
552 :     gmc->Fo = (res*du0 + 1) << (gmc->alpha+gmc->rho-1);
553 :     gmc->Go = (res*dv0 + 1) << (gmc->alpha+gmc->rho-1);
554 : edgomez 851
555 : syskin 935 if (num_wp==2) {
556 :     gmc->dyF = -gmc->dxG;
557 :     gmc->dyG = gmc->dxF;
558 :     } else if (num_wp==3) {
559 :     gmc->beta = log2bin(gmc->H-1);
560 :     gmc->Hs = (1 << gmc->beta);
561 :     gmc->dyF = RDIV( 8*gmc->Hs*du2, gmc->H );
562 :     gmc->dyG = 16*gmc->Hs + RDIV( 8*gmc->Hs*dv2, gmc->H );
563 :     if (gmc->beta > gmc->alpha) {
564 :     gmc->dxF <<= (gmc->beta - gmc->alpha);
565 :     gmc->dxG <<= (gmc->beta - gmc->alpha);
566 :     gmc->alpha = gmc->beta;
567 :     gmc->Ws = 1<< gmc->beta;
568 :     } else {
569 :     gmc->dyF <<= gmc->alpha - gmc->beta;
570 :     gmc->dyG <<= gmc->alpha - gmc->beta;
571 :     }
572 :     }
573 : edgomez 851
574 : syskin 935 gmc->cFo = gmc->dxF + gmc->dyF + (1 << (gmc->alpha+gmc->rho+1));
575 :     gmc->cFo += 16*gmc->Ws*(du0-1);
576 :    
577 :     gmc->cGo = gmc->dxG + gmc->dyG + (1 << (gmc->alpha+gmc->rho+1));
578 :     gmc->cGo += 16*gmc->Ws*(dv0-1);
579 : edgomez 851 }
580 :    
581 : syskin 935 void
582 :     generate_GMCimage( const GMC_DATA *const gmc_data, // [input] precalculated data
583 :     const IMAGE *const pRef, // [input]
584 :     const int mb_width,
585 : edgomez 851 const int mb_height,
586 :     const int stride,
587 : syskin 935 const int stride2,
588 :     const int fcode, // [input] some parameters...
589 :     const int32_t quarterpel, // [input] for rounding avgMV
590 :     const int reduced_resolution, // [input] ignored
591 : edgomez 851 const int32_t rounding, // [input] for rounding image data
592 : syskin 935 MACROBLOCK *const pMBs, // [output] average motion vectors
593 :     IMAGE *const pGMC) // [output] full warped image
594 : edgomez 851 {
595 :    
596 :     unsigned int mj,mi;
597 :     VECTOR avgMV;
598 : Isibaar 3
599 : syskin 935 for (mj = 0; mj < (unsigned int)mb_height; mj++)
600 :     for (mi = 0; mi < (unsigned int)mb_width; mi++) {
601 :    
602 :     avgMV = generate_GMCimageMB(gmc_data, pRef, mi, mj,
603 :     stride, stride2, quarterpel, rounding, pGMC);
604 :    
605 :     pMBs[mj*mb_width+mi].amv.x = gmc_sanitize(avgMV.x, quarterpel, fcode);
606 :     pMBs[mj*mb_width+mi].amv.y = gmc_sanitize(avgMV.y, quarterpel, fcode);
607 :     pMBs[mj*mb_width+mi].mcsel = 0; /* until mode decision */
608 : edgomez 851 }
609 :     }
610 : Isibaar 3
611 :    
612 :    
613 : edgomez 851 #define MLT(i) (((16-(i))<<16) + (i))
614 :     static const uint32_t MTab[16] = {
615 :     MLT( 0), MLT( 1), MLT( 2), MLT( 3), MLT( 4), MLT( 5), MLT( 6), MLT(7),
616 :     MLT( 8), MLT( 9), MLT(10), MLT(11), MLT(12), MLT(13), MLT(14), MLT(15)
617 :     };
618 :     #undef MLT
619 : Isibaar 3
620 : edgomez 851 VECTOR generate_GMCimageMB( const GMC_DATA *const gmc_data,
621 : syskin 935 const IMAGE *const pRef,
622 :     const int mi, const int mj,
623 :     const int stride,
624 :     const int stride2,
625 :     const int quarterpel,
626 :     const int rounding,
627 :     IMAGE *const pGMC)
628 : edgomez 851 {
629 : syskin 935 const int W = gmc_data->W;
630 :     const int H = gmc_data->H;
631 : edgomez 851
632 : syskin 935 const int rho = gmc_data->rho;
633 :     const int alpha = gmc_data->alpha;
634 : edgomez 851
635 : syskin 935 const int rounder = ( 128 - (rounding<<(rho+rho)) ) << 16;
636 : edgomez 851
637 : syskin 935 const int dxF = gmc_data->dxF;
638 :     const int dyF = gmc_data->dyF;
639 :     const int dxG = gmc_data->dxG;
640 :     const int dyG = gmc_data->dyG;
641 : edgomez 851
642 : syskin 935 uint8_t *dstY, *dstU, *dstV;
643 : edgomez 851
644 : syskin 935 int I,J;
645 :     VECTOR avgMV = {0,0};
646 : edgomez 851
647 : syskin 935 int32_t Fj, Gj;
648 : edgomez 851
649 : syskin 935 dstY = &pGMC->y[(mj*16)*stride+mi*16] + 16;
650 : edgomez 851
651 : syskin 935 Fj = gmc_data->Fo + dyF*mj*16 + dxF*mi*16;
652 :     Gj = gmc_data->Go + dyG*mj*16 + dxG*mi*16;
653 :    
654 :     for (J = 16; J > 0; --J) {
655 :     int32_t Fi, Gi;
656 : edgomez 851
657 : syskin 935 Fi = Fj; Fj += dyF;
658 :     Gi = Gj; Gj += dyG;
659 :     for (I = -16; I < 0; ++I) {
660 :     int32_t F, G;
661 :     uint32_t ri, rj;
662 : edgomez 851
663 : syskin 935 F = ( Fi >> (alpha+rho) ) << rho; Fi += dxF;
664 :     G = ( Gi >> (alpha+rho) ) << rho; Gi += dxG;
665 : edgomez 851
666 : syskin 935 avgMV.x += F;
667 :     avgMV.y += G;
668 : edgomez 851
669 : syskin 935 ri = MTab[F&15];
670 :     rj = MTab[G&15];
671 : edgomez 851
672 : syskin 935 F >>= 4;
673 :     G >>= 4;
674 : edgomez 851
675 : syskin 935 if (F < -1) F = -1;
676 :     else if (F > W) F = W;
677 :     if (G< -1) G=-1;
678 :     else if (G>H) G=H;
679 : edgomez 851
680 : syskin 935 { // MMX-like bilinear...
681 :     const int offset = G*stride + F;
682 :     uint32_t f0, f1;
683 :     f0 = pRef->y[ offset +0 ];
684 :     f0 |= pRef->y[ offset +1 ] << 16;
685 :     f1 = pRef->y[ offset+stride +0 ];
686 :     f1 |= pRef->y[ offset+stride +1 ] << 16;
687 :     f0 = (ri*f0)>>16;
688 :     f1 = (ri*f1) & 0x0fff0000;
689 :     f0 |= f1;
690 :     f0 = ( rj*f0 + rounder ) >> 24;
691 : edgomez 851
692 : syskin 935 dstY[I] = (uint8_t)f0;
693 :     }
694 :     }
695 :    
696 :     dstY += stride;
697 :     }
698 : edgomez 851
699 : syskin 935 dstU = &pGMC->u[(mj*8)*stride2+mi*8] + 8;
700 :     dstV = &pGMC->v[(mj*8)*stride2+mi*8] + 8;
701 : edgomez 851
702 : syskin 935 Fj = gmc_data->cFo + dyF*4 *mj*8 + dxF*4 *mi*8;
703 :     Gj = gmc_data->cGo + dyG*4 *mj*8 + dxG*4 *mi*8;
704 :    
705 :     for (J = 8; J > 0; --J) {
706 :     int32_t Fi, Gi;
707 :     Fi = Fj; Fj += 4*dyF;
708 :     Gi = Gj; Gj += 4*dyG;
709 : edgomez 851
710 : syskin 935 for (I = -8; I < 0; ++I) {
711 :     int32_t F, G;
712 :     uint32_t ri, rj;
713 : edgomez 851
714 : syskin 935 F = ( Fi >> (alpha+rho+2) ) << rho; Fi += 4*dxF;
715 :     G = ( Gi >> (alpha+rho+2) ) << rho; Gi += 4*dxG;
716 : edgomez 851
717 : syskin 935 ri = MTab[F&15];
718 :     rj = MTab[G&15];
719 : edgomez 851
720 : syskin 935 F >>= 4;
721 :     G >>= 4;
722 : edgomez 851
723 : syskin 935 if (F < -1) F=-1;
724 :     else if (F >= W/2) F = W/2;
725 :     if (G < -1) G = -1;
726 :     else if (G >= H/2) G = H/2;
727 : edgomez 851
728 : syskin 935 {
729 :     const int offset = G*stride2 + F;
730 :     uint32_t f0, f1;
731 : edgomez 851
732 : syskin 935 f0 = pRef->u[ offset +0 ];
733 :     f0 |= pRef->u[ offset +1 ] << 16;
734 :     f1 = pRef->u[ offset+stride2 +0 ];
735 :     f1 |= pRef->u[ offset+stride2 +1 ] << 16;
736 :     f0 = (ri*f0)>>16;
737 :     f1 = (ri*f1) & 0x0fff0000;
738 :     f0 |= f1;
739 :     f0 = ( rj*f0 + rounder ) >> 24;
740 : edgomez 851
741 : syskin 935 dstU[I] = (uint8_t)f0;
742 : edgomez 851
743 :    
744 : syskin 935 f0 = pRef->v[ offset +0 ];
745 :     f0 |= pRef->v[ offset +1 ] << 16;
746 :     f1 = pRef->v[ offset+stride2 +0 ];
747 :     f1 |= pRef->v[ offset+stride2 +1 ] << 16;
748 :     f0 = (ri*f0)>>16;
749 :     f1 = (ri*f1) & 0x0fff0000;
750 :     f0 |= f1;
751 :     f0 = ( rj*f0 + rounder ) >> 24;
752 : edgomez 851
753 : syskin 935 dstV[I] = (uint8_t)f0;
754 :     }
755 :     }
756 :     dstU += stride2;
757 :     dstV += stride2;
758 :     }
759 : edgomez 851
760 :    
761 : syskin 935 avgMV.x -= 16*((256*mi+120)<<4); // 120 = 15*16/2
762 :     avgMV.y -= 16*((256*mj+120)<<4);
763 :    
764 :     avgMV.x = RSHIFT( avgMV.x, (4+7-quarterpel) );
765 :     avgMV.y = RSHIFT( avgMV.y, (4+7-quarterpel) );
766 :    
767 :     return avgMV;
768 : edgomez 851 }
769 : syskin 935
770 :    
771 :    
772 : edgomez 851 #ifdef OLD_GRUEL_GMC
773 : syskin 935 void
774 : edgomez 851 generate_GMCparameters( const int num_wp, // [input]: number of warppoints
775 : syskin 935 const int res, // [input]: resolution
776 :     const WARPPOINTS *const warp, // [input]: warp points
777 : edgomez 851 const int width, const int height,
778 : syskin 935 GMC_DATA *const gmc) // [output] precalculated parameters
779 : edgomez 851 {
780 :    
781 : syskin 935 /* We follow mainly two sources: The original standard, which is ugly, and the
782 :     thesis from Andreas Dehnhardt, which is much nicer.
783 : edgomez 851
784 : syskin 935 Notation is: indices are written next to the variable,
785 :     primes in the standard are denoted by a suffix 'p'.
786 :     types are "c"=constant, "i"=input parameter, "f"=calculated, then fixed,
787 :     "o"=output data, " "=other, "u" = unused, "p"=calc for every pixel
788 :    
789 :     type | variable name | ISO name (TeX-style) | value or range | usage
790 : edgomez 851 -------------------------------------------------------------------------------------
791 :     c | H | H | [16 , ?] | image width (w/o edges)
792 :     c | W | W | [16 , ?] | image height (w/o edges)
793 :    
794 :     c | i0 | i_0 | 0 | ref. point #1, X
795 :     c | j0 | j_0 | 0 | ref. point #1, Y
796 :     c | i1 | i_1 | W | ref. point #2, X
797 :     c | j1 | j_1 | 0 | ref. point #2, Y
798 :     cu | i2 | i_2 | 0 | ref. point #3, X
799 : syskin 935 cu | i2 | j_2 | H | ref. point #3, Y
800 : edgomez 851
801 :     i | du0 | du[0] | [-16863,16863] | warp vector #1, Y
802 :     i | dv0 | dv[0] | [-16863,16863] | warp vector #1, Y
803 :     i | du1 | du[1] | [-16863,16863] | warp vector #2, Y
804 :     i | dv1 | dv[1] | [-16863,16863] | warp vector #2, Y
805 : syskin 935 iu | du2 | du[2] | [-16863,16863] | warp vector #3, Y
806 : edgomez 851 iu | dv2 | dv[2] | [-16863,16863] | warp vector #3, Y
807 :    
808 : syskin 935 i | s | s | {2,4,8,16} | interpol. resolution
809 :     f | sigma | - | log2(s) | X / s == X >> sigma
810 :     f | r | r | =16/s | complementary res.
811 :     f | rho | \rho | log2(r) | X / r == X >> rho
812 :    
813 :     f | i0s | i'_0 | |
814 :     f | j0s | j'_0 | |
815 :     f | i1s | i'_1 | |
816 :     f | j1s | j'_1 | |
817 :     f | i2s | i'_2 | |
818 :     f | j2s | j'_2 | |
819 :    
820 :     f | alpha | \alpha | | 2^{alpha-1} < W <= 2^alpha
821 :     f | beta | \beta | | 2^{beta-1} < H <= 2^beta
822 :    
823 :     f | Ws | W' | W = 2^{alpha} | scaled width
824 :     f | Hs | H' | W = 2^{beta} | scaled height
825 :    
826 :     f | i1ss | i''_1 | "virtual sprite stuff"
827 :     f | j1ss | j''_1 | "virtual sprite stuff"
828 :     f | i2ss | i''_2 | "virtual sprite stuff"
829 :     f | j2ss | j''_2 | "virtual sprite stuff"
830 : edgomez 851 */
831 :    
832 :     /* Some calculations are disabled because we only use 2 warppoints at the moment */
833 :    
834 :     int du0 = warp->duv[0].x;
835 :     int dv0 = warp->duv[0].y;
836 :     int du1 = warp->duv[1].x;
837 :     int dv1 = warp->duv[1].y;
838 :     // int du2 = warp->duv[2].x;
839 :     // int dv2 = warp->duv[2].y;
840 : syskin 935
841 : edgomez 851 gmc->num_wp = num_wp;
842 :    
843 :     gmc->s = res; /* scaling parameters 2,4,8 or 16 */
844 :     gmc->sigma = log2bin(res-1); /* log2bin(15)=4, log2bin(16)=5, log2bin(17)=5 */
845 : syskin 935 gmc->r = 16/res;
846 : edgomez 851 gmc->rho = 4 - gmc->sigma; /* = log2bin(r-1) */
847 :    
848 :     gmc->W = width;
849 :     gmc->H = height; /* fixed reference coordinates */
850 :    
851 :     gmc->alpha = log2bin(gmc->W-1);
852 : syskin 935 gmc->Ws= 1<<gmc->alpha;
853 : edgomez 851
854 :     // gmc->beta = log2bin(gmc->H-1);
855 : syskin 935 // gmc->Hs= 1<<gmc->beta;
856 : edgomez 851
857 :     // printf("du0=%d dv0=%d du1=%d dv1=%d s=%d sigma=%d W=%d alpha=%d, Ws=%d, rho=%d\n",du0,dv0,du1,dv1,gmc->s,gmc->sigma,gmc->W,gmc->alpha,gmc->Ws,gmc->rho);
858 :    
859 :     /* i2s is only needed for num_wp >= 3, etc. */
860 :     /* the 's' values are in 1/s pel resolution */
861 :     gmc->i0s = res/2 * ( du0 );
862 :     gmc->j0s = res/2 * ( dv0 );
863 :     gmc->i1s = res/2 * (2*width + du1 + du0 );
864 :     gmc->j1s = res/2 * ( dv1 + dv0 );
865 :     // gmc->i2s = res/2 * ( du2 + du0 );
866 :     // gmc->j2s = res/2 * (2*height + dv2 + dv0 );
867 : syskin 935
868 : edgomez 851 /* i2s and i2ss are only needed for num_wp == 3, etc. */
869 :    
870 :     /* the 'ss' values are in 1/16 pel resolution */
871 : syskin 935 gmc->i1ss = 16*gmc->Ws + ROUNDED_DIV(((gmc->W-gmc->Ws)*(gmc->r*gmc->i0s) + gmc->Ws*(gmc->r*gmc->i1s - 16*gmc->W)),gmc->W);
872 :     gmc->j1ss = ROUNDED_DIV( ((gmc->W - gmc->Ws)*(gmc->r*gmc->j0s) + gmc->Ws*gmc->r*gmc->j1s) ,gmc->W );
873 : edgomez 851
874 : syskin 935 // gmc->i2ss = ROUNDED_DIV( ((gmc->H - gmc->Hs)*(gmc->r*gmc->i0s) + gmc->Hs*(gmc->r*gmc->i2s)), gmc->H);
875 : edgomez 851 // gmc->j2ss = 16*gmc->Hs + ROUNDED_DIV( ((gmc->H-gmc->Hs)*(gmc->r*gmc->j0s) + gmc->Ws*(gmc->r*gmc->j2s - 16*gmc->H)), gmc->H);
876 :    
877 : syskin 935 return;
878 : edgomez 851 }
879 :    
880 : syskin 935 void
881 : edgomez 851 generate_GMCimage( const GMC_DATA *const gmc_data, // [input] precalculated data
882 : syskin 935 const IMAGE *const pRef, // [input]
883 :     const int mb_width,
884 : edgomez 851 const int mb_height,
885 :     const int stride,
886 : syskin 935 const int stride2,
887 : edgomez 851 const int fcode, // [input] some parameters...
888 :     const int32_t quarterpel, // [input] for rounding avgMV
889 :     const int reduced_resolution, // [input] ignored
890 :     const int32_t rounding, // [input] for rounding image data
891 :     MACROBLOCK *const pMBs, // [output] average motion vectors
892 :     IMAGE *const pGMC) // [output] full warped image
893 :     {
894 :    
895 :     unsigned int mj,mi;
896 :     VECTOR avgMV;
897 : syskin 935
898 :     for (mj = 0;mj < mb_height; mj++)
899 :     for (mi = 0;mi < mb_width; mi++) {
900 :    
901 :     avgMV = generate_GMCimageMB(gmc_data, pRef, mi, mj,
902 : edgomez 851 stride, stride2, quarterpel, rounding, pGMC);
903 :    
904 :     pMBs[mj*mb_width+mi].amv.x = gmc_sanitize(avgMV.x, quarterpel, fcode);
905 :     pMBs[mj*mb_width+mi].amv.y = gmc_sanitize(avgMV.y, quarterpel, fcode);
906 :     pMBs[mj*mb_width+mi].mcsel = 0; /* until mode decision */
907 : Isibaar 3 }
908 :     }
909 : edgomez 851
910 :    
911 :     VECTOR generate_GMCimageMB( const GMC_DATA *const gmc_data, /* [input] all precalc data */
912 :     const IMAGE *const pRef, /* [input] */
913 :     const int mi, const int mj, /* [input] MB position */
914 :     const int stride, /* [input] Lumi stride */
915 :     const int stride2, /* [input] chroma stride */
916 :     const int quarterpel, /* [input] for rounding of avgMV */
917 :     const int rounding, /* [input] for rounding of imgae data */
918 :     IMAGE *const pGMC) /* [outut] generate image */
919 : syskin 935
920 : edgomez 851 /*
921 : syskin 935 type | variable name | ISO name (TeX-style) | value or range | usage
922 : edgomez 851 -------------------------------------------------------------------------------------
923 : syskin 935 p | F | F(i,j) | | pelwise motion vector X in s-th pel
924 :     p | G | G(i,j) | | pelwise motion vector Y in s-th pel
925 :     p | Fc | F_c(i,j) | |
926 :     p | Gc | G_c(i,j) | | same for chroma
927 : edgomez 851
928 : syskin 935 p | Y00 | Y_{00} | [0,255*s*s] | first: 4 neighbouring Y-values
929 :     p | Y01 | Y_{01} | [0,255] | at fullpel position, around the
930 :     p | Y10 | Y_{10} | [0,255*s] | position where pelweise MV points to
931 :     p | Y11 | Y_{11} | [0,255] | later: bilinear interpol Y-values in Y00
932 : edgomez 851
933 : syskin 935 p | C00 | C_{00} | [0,255*s*s] | same for chroma Cb and Cr
934 :     p | C01 | C_{01} | [0,255] |
935 :     p | C10 | C_{10} | [0,255*s] |
936 :     p | C11 | C_{11} | [0,255] |
937 :    
938 : edgomez 851 */
939 :     {
940 :     const int W = gmc_data->W;
941 :     const int H = gmc_data->H;
942 :    
943 :     const int s = gmc_data->s;
944 :     const int sigma = gmc_data->sigma;
945 : syskin 935
946 : edgomez 851 const int r = gmc_data->r;
947 : syskin 935 const int rho = gmc_data->rho;
948 :    
949 : edgomez 851 const int i0s = gmc_data->i0s;
950 :     const int j0s = gmc_data->j0s;
951 : syskin 935
952 : edgomez 851 const int i1ss = gmc_data->i1ss;
953 : syskin 935 const int j1ss = gmc_data->j1ss;
954 :     // const int i2ss = gmc_data->i2ss;
955 :     // const int j2ss = gmc_data->j2ss;
956 : edgomez 851
957 : syskin 935 const int alpha = gmc_data->alpha;
958 :     const int Ws = gmc_data->Ws;
959 : edgomez 851
960 :     // const int beta = gmc_data->beta;
961 : syskin 935 // const int Hs = gmc_data->Hs;
962 : edgomez 851
963 :     int I,J;
964 :     VECTOR avgMV = {0,0};
965 : syskin 935
966 : edgomez 851 for (J=16*mj;J<16*(mj+1);J++)
967 :     for (I=16*mi;I<16*(mi+1);I++)
968 :     {
969 :     int F= i0s + ( ((-r*i0s+i1ss)*I + (r*j0s-j1ss)*J + (1<<(alpha+rho-1))) >> (alpha+rho) );
970 :     int G= j0s + ( ((-r*j0s+j1ss)*I + (-r*i0s+i1ss)*J + (1<<(alpha+rho-1))) >> (alpha+rho) );
971 :    
972 : syskin 935 /* this naive implementation (with lots of multiplications) isn't slower (rather faster) than
973 : edgomez 851 working incremental. Don't ask me why... maybe the whole this is memory bound? */
974 :    
975 :     const int ri= F & (s-1); // fractional part of pelwise MV X
976 :     const int rj= G & (s-1); // fractional part of pelwise MV Y
977 : syskin 935
978 : edgomez 851 int Y00,Y01,Y10,Y11;
979 :    
980 :     /* unclipped values are used for avgMV */
981 :     avgMV.x += F-(I<<sigma); /* shift position to 1/s-pel, as the MV is */
982 :     avgMV.y += G-(J<<sigma); /* TODO: don't do this (of course) */
983 :    
984 :     F >>= sigma;
985 :     G >>= sigma;
986 :    
987 : syskin 935 /* clip values to be in range. Since we have edges, clip to 1 less than lower boundary
988 : edgomez 851 this way positions F+1/G+1 are still right */
989 :    
990 :     if (F< -1)
991 :     F=-1;
992 :     else if (F>W)
993 :     F=W; /* W or W-1 doesn't matter, so save 1 subtract ;-) */
994 :     if (G< -1)
995 :     G=-1;
996 :     else if (G>H)
997 :     G=H; /* dito */
998 :    
999 :     Y00 = pRef->y[ G*stride + F ]; // Lumi values
1000 :     Y01 = pRef->y[ G*stride + F+1 ];
1001 :     Y10 = pRef->y[ G*stride + F+stride ];
1002 :     Y11 = pRef->y[ G*stride + F+stride+1 ];
1003 : syskin 935
1004 : edgomez 851 /* bilinear interpolation */
1005 :     Y00 = ((s-ri)*Y00 + ri*Y01);
1006 :     Y10 = ((s-ri)*Y10 + ri*Y11);
1007 : syskin 935 Y00 = ((s-rj)*Y00 + rj*Y10 + s*s/2 - rounding ) >> (sigma+sigma);
1008 :    
1009 : edgomez 851 pGMC->y[J*stride+I] = (uint8_t)Y00; /* output 1 Y-pixel */
1010 :     }
1011 :    
1012 : syskin 935
1013 :     /* doing chroma _here_ is even more stupid and slow, because won't be used until Compensation and
1014 : edgomez 851 most likely not even then (only if the block really _is_ GMC)
1015 :     */
1016 :    
1017 :     for (J=8*mj;J<8*(mj+1);J++) /* this plays the role of j_c,i_c in the standard */
1018 :     for (I=8*mi;I<8*(mi+1);I++) /* For I_c we have to use I_c = 4*i_c+1 ! */
1019 :     {
1020 :     /* same positions for both chroma components, U=Cb and V=Cr */
1021 : syskin 935 int Fc=((-r*i0s+i1ss)*(4*I+1) + (r*j0s-j1ss)*(4*J+1) +2*Ws*r*i0s
1022 : edgomez 851 -16*Ws +(1<<(alpha+rho+1)))>>(alpha+rho+2);
1023 : syskin 935 int Gc=((-r*j0s+j1ss)*(4*I+1) +(-r*i0s+i1ss)*(4*J+1) +2*Ws*r*j0s
1024 : edgomez 851 -16*Ws +(1<<(alpha+rho+1))) >>(alpha+rho+2);
1025 : syskin 935
1026 : edgomez 851 const int ri= Fc & (s-1); // fractional part of pelwise MV X
1027 :     const int rj= Gc & (s-1); // fractional part of pelwise MV Y
1028 :    
1029 :     int C00,C01,C10,C11;
1030 : syskin 935
1031 : edgomez 851 Fc >>= sigma;
1032 :     Gc >>= sigma;
1033 : syskin 935
1034 : edgomez 851 if (Fc< -1)
1035 :     Fc=-1;
1036 :     else if (Fc>=W/2)
1037 :     Fc=W/2; /* W or W-1 doesn't matter, so save 1 subtraction ;-) */
1038 :     if (Gc< -1)
1039 :     Gc=-1;
1040 :     else if (Gc>=H/2)
1041 :     Gc=H/2; /* dito */
1042 :    
1043 : syskin 935 /* now calculate U data */
1044 : edgomez 851 C00 = pRef->u[ Gc*stride2 + Fc ]; // chroma-value Cb
1045 :     C01 = pRef->u[ Gc*stride2 + Fc+1 ];
1046 :     C10 = pRef->u[ (Gc+1)*stride2 + Fc ];
1047 :     C11 = pRef->u[ (Gc+1)*stride2 + Fc+1 ];
1048 : syskin 935
1049 : edgomez 851 /* bilinear interpolation */
1050 :     C00 = ((s-ri)*C00 + ri*C01);
1051 :     C10 = ((s-ri)*C10 + ri*C11);
1052 : syskin 935 C00 = ((s-rj)*C00 + rj*C10 + s*s/2 - rounding ) >> (sigma+sigma);
1053 :    
1054 : edgomez 851 pGMC->u[J*stride2+I] = (uint8_t)C00; /* output 1 U-pixel */
1055 : syskin 935
1056 : edgomez 851 /* now calculate V data */
1057 :     C00 = pRef->v[ Gc*stride2 + Fc ]; // chroma-value Cr
1058 :     C01 = pRef->v[ Gc*stride2 + Fc+1 ];
1059 :     C10 = pRef->v[ (Gc+1)*stride2 + Fc ];
1060 :     C11 = pRef->v[ (Gc+1)*stride2 + Fc+1 ];
1061 : syskin 935
1062 : edgomez 851 /* bilinear interpolation */
1063 :     C00 = ((s-ri)*C00 + ri*C01);
1064 :     C10 = ((s-ri)*C10 + ri*C11);
1065 : syskin 935 C00 = ((s-rj)*C00 + rj*C10 + s*s/2 - rounding ) >> (sigma+sigma);
1066 :    
1067 : edgomez 851 pGMC->v[J*stride2+I] = (uint8_t)C00; /* output 1 V-pixel */
1068 :     }
1069 : syskin 935
1070 : edgomez 851 /* The average vector is rounded from 1/s-pel to 1/2 or 1/4 using the '//' operator*/
1071 :    
1072 :     avgMV.x = RSHIFT( avgMV.x, (sigma+7-quarterpel) );
1073 :     avgMV.y = RSHIFT( avgMV.y, (sigma+7-quarterpel) );
1074 :    
1075 :     /* ^^^^ this is the way MS Reference Software does it */
1076 : syskin 935
1077 : edgomez 851 return avgMV; /* clipping to fcode area is done outside! */
1078 :     }
1079 :    
1080 :     #endif
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4