[cvs] / xvidcore / src / motion / motion_comp.c Repository:
ViewVC logotype

Annotation of /xvidcore/src/motion/motion_comp.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1.11.2.14 - (view) (download)

1 : Isibaar 1.11.2.6 // 30.10.2002 corrected qpel chroma rounding
2 : Isibaar 1.11.2.4 // 04.10.2002 added qpel support to MBMotionCompensation
3 : edgomez 1.5 // 01.05.2002 updated MBMotionCompensationBVOP
4 :     // 14.04.2002 bframe compensation
5 : suxen_drol 1.3
6 : Isibaar 1.1 #include "../encoder.h"
7 :     #include "../utils/mbfunctions.h"
8 :     #include "../image/interpolate8x8.h"
9 : suxen_drol 1.11.2.11 #include "../image/reduced.h"
10 : Isibaar 1.1 #include "../utils/timer.h"
11 : suxen_drol 1.3 #include "motion.h"
12 : Isibaar 1.1
13 :     #define ABS(X) (((X)>0)?(X):-(X))
14 :     #define SIGN(X) (((X)>0)?1:-1)
15 :    
16 : suxen_drol 1.11.2.11
17 : edgomez 1.5 static __inline void
18 : Isibaar 1.11.2.5 compensate16x16_interpolate(int16_t * const dct_codes,
19 :     uint8_t * const cur,
20 :     const uint8_t * const ref,
21 :     const uint8_t * const refh,
22 : suxen_drol 1.11.2.11 uint8_t * const refv,
23 : Isibaar 1.11.2.5 const uint8_t * const refhv,
24 : suxen_drol 1.11.2.11 uint32_t x,
25 :     uint32_t y,
26 : Isibaar 1.11.2.5 const int32_t dx,
27 :     const int32_t dy,
28 :     const uint32_t stride,
29 :     const uint32_t quarterpel,
30 : suxen_drol 1.11.2.11 const int reduced_resolution,
31 :     const uint32_t rounding)
32 : Isibaar 1.11.2.5 {
33 : suxen_drol 1.11.2.11
34 :     if (reduced_resolution)
35 : Isibaar 1.11.2.5 {
36 : suxen_drol 1.11.2.12 const uint8_t * reference;
37 :     x*=2; y*=2;
38 : Isibaar 1.11.2.5
39 : suxen_drol 1.11.2.12 reference = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
40 :    
41 :     filter_18x18_to_8x8(dct_codes, cur+y*stride + x, stride);
42 :     filter_diff_18x18_to_8x8(dct_codes, reference, stride);
43 : suxen_drol 1.11.2.11
44 : suxen_drol 1.11.2.12 filter_18x18_to_8x8(dct_codes+64, cur+y*stride + x + 16, stride);
45 :     filter_diff_18x18_to_8x8(dct_codes+64, reference + 16, stride);
46 : suxen_drol 1.11.2.11
47 : suxen_drol 1.11.2.12 filter_18x18_to_8x8(dct_codes+128, cur+(y+16)*stride + x, stride);
48 :     filter_diff_18x18_to_8x8(dct_codes+128, reference + 16*stride, stride);
49 : suxen_drol 1.11.2.11
50 : suxen_drol 1.11.2.12 filter_18x18_to_8x8(dct_codes+192, cur+(y+16)*stride + x + 16, stride);
51 :     filter_diff_18x18_to_8x8(dct_codes+192, reference + 16*stride + 16, stride);
52 : suxen_drol 1.11.2.11
53 : suxen_drol 1.11.2.12 transfer32x32_copy(cur + y*stride + x, reference, stride);
54 : suxen_drol 1.11.2.11
55 :     }else{
56 :     if(quarterpel) {
57 :     interpolate16x16_quarterpel((uint8_t *) refv, (uint8_t *) ref, (uint8_t *) refh,
58 :     (uint8_t *) refh + 64, (uint8_t *) refhv, x, y, dx, dy, stride, rounding);
59 :    
60 :     transfer_8to16sub(dct_codes, cur + y*stride + x,
61 :     refv + y*stride + x, stride);
62 :     transfer_8to16sub(dct_codes+64, cur + y*stride + x + 8,
63 :     refv + y*stride + x + 8, stride);
64 :     transfer_8to16sub(dct_codes+128, cur + y*stride + x + 8*stride,
65 :     refv + y*stride + x + 8*stride, stride);
66 :     transfer_8to16sub(dct_codes+192, cur + y*stride + x + 8*stride + 8,
67 :     refv + y*stride + x + 8*stride+8, stride);
68 :    
69 :     }
70 :     else
71 :     {
72 : suxen_drol 1.11.2.12 const uint8_t * reference = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
73 : suxen_drol 1.11.2.11
74 :     transfer_8to16sub(dct_codes, cur + y * stride + x,
75 :     reference, stride);
76 :     transfer_8to16sub(dct_codes+64, cur + y * stride + x + 8,
77 :     reference + 8, stride);
78 :     transfer_8to16sub(dct_codes+128, cur + y * stride + x + 8*stride,
79 :     reference + 8*stride, stride);
80 :     transfer_8to16sub(dct_codes+192, cur + y * stride + x + 8*stride+8,
81 :     reference + 8*stride + 8, stride);
82 :     }
83 : Isibaar 1.11.2.5 }
84 :     }
85 :    
86 :     static __inline void
87 : Isibaar 1.11.2.4 compensate8x8_interpolate(int16_t * const dct_codes,
88 :     uint8_t * const cur,
89 :     const uint8_t * const ref,
90 :     const uint8_t * const refh,
91 :     const uint8_t * const refv,
92 :     const uint8_t * const refhv,
93 : suxen_drol 1.11.2.12 uint32_t x,
94 :     uint32_t y,
95 : Isibaar 1.11.2.4 const int32_t dx,
96 :     const int32_t dy,
97 :     const uint32_t stride,
98 :     const uint32_t quarterpel,
99 : suxen_drol 1.11.2.11 const int reduced_resolution,
100 : Isibaar 1.11.2.4 const uint32_t rounding)
101 : Isibaar 1.1 {
102 : suxen_drol 1.11.2.11 if (reduced_resolution)
103 : edgomez 1.5 {
104 : suxen_drol 1.11.2.12 const uint8_t * reference;
105 :     x*=2; y*=2;
106 :    
107 :     reference = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
108 :    
109 :     filter_18x18_to_8x8(dct_codes, cur+y*stride + x, stride);
110 :     filter_diff_18x18_to_8x8(dct_codes, reference, stride);
111 :    
112 :     transfer16x16_copy(cur + y*stride + x, reference, stride);
113 :    
114 : suxen_drol 1.11.2.11 } else {
115 :    
116 :     if(quarterpel) {
117 :     interpolate8x8_quarterpel((uint8_t *) refv, (uint8_t *) ref, (uint8_t *) refh,
118 :     (uint8_t *) refh + 64, (uint8_t *) refhv, x, y, dx, dy, stride, rounding);
119 : Isibaar 1.11.2.4
120 : suxen_drol 1.11.2.11 transfer_8to16sub(dct_codes, cur + y*stride + x,
121 :     refv + y*stride + x, stride);
122 :     }
123 :     else
124 : Isibaar 1.11.2.4 {
125 : suxen_drol 1.11.2.12 const uint8_t * reference = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
126 : suxen_drol 1.11.2.11
127 :     transfer_8to16sub(dct_codes, cur + y * stride + x,
128 :     reference, stride);
129 : Isibaar 1.11.2.4 }
130 : edgomez 1.5 }
131 : Isibaar 1.1 }
132 :    
133 : suxen_drol 1.11.2.13
134 :    
135 :     /* XXX: slow, inelegant... */
136 :     static void
137 :     interpolate18x18_switch(uint8_t * const cur,
138 :     const uint8_t * const refn,
139 :     const uint32_t x,
140 :     const uint32_t y,
141 :     const int32_t dx,
142 :     const int dy,
143 :     const uint32_t stride,
144 :     const uint32_t rounding)
145 :     {
146 :     interpolate8x8_switch(cur, refn, x-1, y-1, dx, dy, stride, rounding);
147 :     interpolate8x8_switch(cur, refn, x+7, y-1, dx, dy, stride, rounding);
148 :     interpolate8x8_switch(cur, refn, x+9, y-1, dx, dy, stride, rounding);
149 :    
150 :     interpolate8x8_switch(cur, refn, x-1, y+7, dx, dy, stride, rounding);
151 :     interpolate8x8_switch(cur, refn, x+7, y+7, dx, dy, stride, rounding);
152 :     interpolate8x8_switch(cur, refn, x+9, y+7, dx, dy, stride, rounding);
153 :    
154 :     interpolate8x8_switch(cur, refn, x-1, y+9, dx, dy, stride, rounding);
155 :     interpolate8x8_switch(cur, refn, x+7, y+9, dx, dy, stride, rounding);
156 :     interpolate8x8_switch(cur, refn, x+9, y+9, dx, dy, stride, rounding);
157 :     }
158 :    
159 :    
160 : edgomez 1.5 void
161 :     MBMotionCompensation(MACROBLOCK * const mb,
162 :     const uint32_t i,
163 :     const uint32_t j,
164 :     const IMAGE * const ref,
165 :     const IMAGE * const refh,
166 :     const IMAGE * const refv,
167 :     const IMAGE * const refhv,
168 :     IMAGE * const cur,
169 :     int16_t * dct_codes,
170 :     const uint32_t width,
171 :     const uint32_t height,
172 :     const uint32_t edged_width,
173 : Isibaar 1.11.2.4 const uint32_t quarterpel,
174 : suxen_drol 1.11.2.11 const int reduced_resolution,
175 : edgomez 1.5 const uint32_t rounding)
176 : Isibaar 1.1 {
177 : suxen_drol 1.11.2.11
178 : chl 1.11.2.9 if (mb->mode == MODE_NOT_CODED || mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
179 : chl 1.11.2.2
180 : chl 1.11.2.9 int32_t dx = (quarterpel ? mb->qmvs[0].x : mb->mvs[0].x);
181 :     int32_t dy = (quarterpel ? mb->qmvs[0].y : mb->mvs[0].y);
182 : Isibaar 1.1
183 : syskin 1.11.2.14 if ( (!reduced_resolution) && (mb->mode == MODE_NOT_CODED) && (dx==0) && (dy==0) ) { /* quick copy */
184 : suxen_drol 1.11.2.11 transfer16x16_copy(cur->y + 16 * (i + j * edged_width),
185 :     ref->y + 16 * (i + j * edged_width),
186 :     edged_width);
187 : chl 1.11.2.9
188 :     transfer8x8_copy(cur->u + 8 * (i + j * edged_width/2),
189 :     ref->u + 8 * (i + j * edged_width/2),
190 :     edged_width / 2);
191 :     transfer8x8_copy(cur->v + 8 * (i + j * edged_width/2),
192 :     ref->v + 8 * (i + j * edged_width/2),
193 :     edged_width / 2);
194 :     return;
195 : Isibaar 1.11.2.4 }
196 : chl 1.11.2.9 /* quick MODE_NOT_CODED for GMC with MV!=(0,0) is still needed */
197 : Isibaar 1.11.2.4
198 : suxen_drol 1.11.2.12 if (reduced_resolution)
199 :     {
200 :     dx = RRV_MV_SCALEUP(dx);
201 :     dy = RRV_MV_SCALEUP(dy);
202 :     }
203 :    
204 : Isibaar 1.11.2.5 compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,
205 : suxen_drol 1.11.2.11 refv->y, refhv->y, 16 * i, 16 * j, dx, dy,
206 :     edged_width, quarterpel, reduced_resolution, rounding);
207 : Isibaar 1.11.2.4
208 :     if (quarterpel)
209 :     {
210 : Isibaar 1.11.2.7 dx /= 2;
211 :     dy /= 2;
212 : Isibaar 1.11.2.4 }
213 : Isibaar 1.11.2.7
214 :     dx = (dx >> 1) + roundtab_79[dx & 0x3];
215 :     dy = (dy >> 1) + roundtab_79[dy & 0x3];
216 : Isibaar 1.1
217 : suxen_drol 1.11.2.12 /* uv-block-based compensation
218 :     XXX: rrv doesnt work with 16x16 block-based intepolation.
219 :     we need to use 18x18-block interpolation */
220 : suxen_drol 1.11.2.11 if (reduced_resolution)
221 :     {
222 : suxen_drol 1.11.2.12 const stride = edged_width/2;
223 :     uint8_t * current, * reference;
224 :    
225 :     current = cur->u + 16*j*stride + 16*i;
226 :     reference = refv->u + 16*j*stride + 16*i;
227 : suxen_drol 1.11.2.13 //interpolate16x16_switch(refv->u, ref->u, 16*i, 16*j, dx, dy, stride, rounding);
228 :     interpolate18x18_switch(refv->u, ref->u, 16*i, 16*j, dx, dy, stride, rounding);
229 : suxen_drol 1.11.2.12 filter_18x18_to_8x8(dct_codes + 4*64, current, stride);
230 :     filter_diff_18x18_to_8x8(dct_codes + 4*64, reference, stride);
231 :     transfer16x16_copy(current, reference, stride);
232 :    
233 :     current = cur->v + 16*j*stride + 16*i;
234 :     reference = refv->v + 16*j*stride + 16*i;
235 : suxen_drol 1.11.2.13 //interpolate16x16_switch(refv->v, ref->v, 16*i, 16*j, dx, dy, stride, rounding);
236 :     interpolate18x18_switch(refv->v, ref->v, 16*i, 16*j, dx, dy, stride, rounding);
237 : suxen_drol 1.11.2.12 filter_18x18_to_8x8(dct_codes + 5*64, current, stride);
238 :     filter_diff_18x18_to_8x8(dct_codes + 5*64, reference, stride);
239 :     transfer16x16_copy(current, reference, stride);
240 : suxen_drol 1.11.2.11 }else{
241 :     transfer_8to16sub(&dct_codes[4 * 64],
242 :     cur->u + 8 * j * edged_width / 2 + 8 * i,
243 :     interpolate8x8_switch2(refv->u, ref->u, 8 * i, 8 * j,
244 :     dx, dy, edged_width / 2, rounding),
245 :     edged_width / 2);
246 : edgomez 1.5
247 : suxen_drol 1.11.2.11 transfer_8to16sub(&dct_codes[5 * 64],
248 :     cur->v + 8 * j * edged_width / 2 + 8 * i,
249 :     interpolate8x8_switch2(refv->u, ref->v, 8 * i, 8 * j,
250 :     dx, dy, edged_width / 2, rounding),
251 :     edged_width / 2);
252 :     }
253 : suxen_drol 1.11.2.1
254 : chl 1.11.2.2 } else { // mode == MODE_INTER4V
255 : suxen_drol 1.11.2.12 int i;
256 : Isibaar 1.1 int32_t sum, dx, dy;
257 : suxen_drol 1.11.2.12 VECTOR mvs[4];
258 : Isibaar 1.1
259 : Isibaar 1.11.2.4 if(quarterpel)
260 : suxen_drol 1.11.2.12 for (i = 0; i < 4; i++) mvs[i] = mb->qmvs[i];
261 : Isibaar 1.11.2.4 else
262 : suxen_drol 1.11.2.12 for (i = 0; i < 4; i++) mvs[i] = mb->mvs[i];
263 : Isibaar 1.11.2.4
264 : suxen_drol 1.11.2.11 if (reduced_resolution)
265 :     {
266 : suxen_drol 1.11.2.12 for (i = 0; i < 4; i++)
267 :     {
268 :     mvs[i].x = RRV_MV_SCALEUP(mvs[i].x);
269 :     mvs[i].y = RRV_MV_SCALEUP(mvs[i].y);
270 :     }
271 : suxen_drol 1.11.2.11 }
272 : Isibaar 1.11.2.4
273 : suxen_drol 1.11.2.12 compensate8x8_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,
274 :     refv->y, refhv->y, 16 * i, 16 * j, mvs[0].x,
275 :     mvs[0].y, edged_width, quarterpel, reduced_resolution, rounding);
276 :     compensate8x8_interpolate(&dct_codes[1 * 64], cur->y, ref->y, refh->y,
277 :     refv->y, refhv->y, 16 * i + 8, 16 * j,
278 :     mvs[1].x, mvs[1].y, edged_width, quarterpel, reduced_resolution, rounding);
279 :     compensate8x8_interpolate(&dct_codes[2 * 64], cur->y, ref->y, refh->y,
280 :     refv->y, refhv->y, 16 * i, 16 * j + 8,
281 :     mvs[2].x, mvs[2].y, edged_width, quarterpel, reduced_resolution, rounding);
282 :     compensate8x8_interpolate(&dct_codes[3 * 64], cur->y, ref->y, refh->y,
283 :     refv->y, refhv->y, 16 * i + 8, 16 * j + 8,
284 :     mvs[3].x, mvs[3].y, edged_width, quarterpel, reduced_resolution, rounding);
285 :    
286 : Isibaar 1.11.2.4 if(quarterpel)
287 : Isibaar 1.11.2.6 sum = (mvs[0].x / 2) + (mvs[1].x / 2) + (mvs[2].x / 2) + (mvs[3].x / 2);
288 :     else
289 :     sum = mvs[0].x + mvs[1].x + mvs[2].x + mvs[3].x;
290 : Isibaar 1.1
291 : Isibaar 1.11.2.6 dx = (sum >> 3) + roundtab_76[sum & 0xf];
292 : Isibaar 1.11.2.4
293 :     if(quarterpel)
294 : Isibaar 1.11.2.6 sum = (mvs[0].y / 2) + (mvs[1].y / 2) + (mvs[2].y / 2) + (mvs[3].y / 2);
295 :     else
296 :     sum = mvs[0].y + mvs[1].y + mvs[2].y + mvs[3].y;
297 : Isibaar 1.11.2.4
298 : Isibaar 1.11.2.6 dy = (sum >> 3) + roundtab_76[sum & 0xf];
299 : Isibaar 1.1
300 : suxen_drol 1.11.2.12
301 :     /* uv-block-based compensation
302 :     XXX: rrv doesnt work with 16x16 block-based intepolation.
303 :     we need to use 18x18-block interpolation */
304 : suxen_drol 1.11.2.11 if (reduced_resolution)
305 :     {
306 : suxen_drol 1.11.2.12 const stride = edged_width/2;
307 :     uint8_t * current, * reference;
308 :    
309 :     current = cur->u + 16*j*stride + 16*i;
310 :     reference = refv->u + 16*j*stride + 16*i;
311 :     interpolate16x16_switch(refv->u, ref->u, 16*i, 16*j, dx, dy, stride, rounding);
312 :     filter_18x18_to_8x8(dct_codes + 4*64, current, stride);
313 :     filter_diff_18x18_to_8x8(dct_codes + 4*64, reference, stride);
314 :     transfer16x16_copy(current, reference, stride);
315 :    
316 :     current = cur->v + 16*j*stride + 16*i;
317 :     reference = refv->v + 16*j*stride + 16*i;
318 :     interpolate16x16_switch(refv->v, ref->v, 16*i, 16*j, dx, dy, stride, rounding);
319 :     filter_18x18_to_8x8(dct_codes + 5*64, current, stride);
320 :     filter_diff_18x18_to_8x8(dct_codes + 5*64, reference, stride);
321 :     transfer16x16_copy(current, reference, stride);
322 :    
323 : suxen_drol 1.11.2.11 }else{
324 :     transfer_8to16sub(&dct_codes[4 * 64],
325 :     cur->u + 8 * j * edged_width / 2 + 8 * i,
326 :     interpolate8x8_switch2(refv->u, ref->u, 8 * i, 8 * j,
327 :     dx, dy, edged_width / 2, rounding),
328 :     edged_width / 2);
329 : edgomez 1.5
330 : suxen_drol 1.11.2.11 transfer_8to16sub(&dct_codes[5 * 64],
331 :     cur->v + 8 * j * edged_width / 2 + 8 * i,
332 :     interpolate8x8_switch2(refv->u, ref->v, 8 * i, 8 * j,
333 :     dx, dy, edged_width / 2, rounding),
334 :     edged_width / 2);
335 :     }
336 : Isibaar 1.1 }
337 :     }
338 : suxen_drol 1.3
339 :    
340 : edgomez 1.5 void
341 :     MBMotionCompensationBVOP(MBParam * pParam,
342 :     MACROBLOCK * const mb,
343 :     const uint32_t i,
344 :     const uint32_t j,
345 :     IMAGE * const cur,
346 :     const IMAGE * const f_ref,
347 :     const IMAGE * const f_refh,
348 :     const IMAGE * const f_refv,
349 :     const IMAGE * const f_refhv,
350 :     const IMAGE * const b_ref,
351 :     const IMAGE * const b_refh,
352 :     const IMAGE * const b_refv,
353 :     const IMAGE * const b_refhv,
354 :     int16_t * dct_codes)
355 : suxen_drol 1.3 {
356 :     static const uint32_t roundtab[16] =
357 :     { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };
358 :    
359 :     const int32_t edged_width = pParam->edged_width;
360 :     int32_t dx, dy;
361 :     int32_t b_dx, b_dy;
362 : chl 1.11 int k,sum;
363 : suxen_drol 1.3 int x = i;
364 :     int y = j;
365 : syskin 1.11.2.10 uint32_t quarterpel = pParam->m_quarterpel;
366 : suxen_drol 1.3
367 : edgomez 1.5 switch (mb->mode) {
368 :     case MODE_FORWARD:
369 : suxen_drol 1.3
370 : syskin 1.11.2.10 if (quarterpel) {
371 :     dx = mb->qmvs[0].x;
372 :     dy = mb->qmvs[0].y;
373 :     } else {
374 :     dx = mb->mvs[0].x;
375 :     dy = mb->mvs[0].y;
376 :     }
377 : suxen_drol 1.3
378 : syskin 1.11.2.10 compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, f_ref->y, f_refh->y,
379 :     f_refv->y, f_refhv->y, 16 * i, 16 * j, dx,
380 : suxen_drol 1.11.2.11 dy, edged_width, quarterpel, 0 /*reduced_resolution*/, 0);
381 : syskin 1.11.2.10
382 :     if (quarterpel) {
383 :     dx /= 2;
384 :     dy /= 2;
385 :     }
386 : suxen_drol 1.3
387 : syskin 1.11.2.10 dx = (dx >> 1) + roundtab_79[dx & 0x3];
388 :     dy = (dy >> 1) + roundtab_79[dy & 0x3];
389 : suxen_drol 1.3
390 : chl 1.11.2.2 /* uv-block-based compensation */
391 : suxen_drol 1.11.2.1 transfer_8to16sub(&dct_codes[4 * 64],
392 : chl 1.11.2.2 cur->u + 8 * j * edged_width / 2 + 8 * i,
393 :     interpolate8x8_switch2(f_refv->u, f_ref->u, 8 * i, 8 * j,
394 :     dx, dy, edged_width / 2, 0),
395 :    
396 : suxen_drol 1.11.2.1 edged_width / 2);
397 :    
398 :     transfer_8to16sub(&dct_codes[5 * 64],
399 : chl 1.11.2.2 cur->v + 8 * j * edged_width / 2 + 8 * i,
400 :     interpolate8x8_switch2(f_refv->u, f_ref->v, 8 * i, 8 * j,
401 :     dx, dy, edged_width / 2, 0),
402 :    
403 : suxen_drol 1.11.2.1 edged_width / 2);
404 : suxen_drol 1.3
405 :     break;
406 :    
407 : edgomez 1.5 case MODE_BACKWARD:
408 : syskin 1.11.2.10 if (quarterpel) {
409 :     b_dx = mb->b_qmvs[0].x;
410 :     b_dy = mb->b_qmvs[0].y;
411 :     } else {
412 :     b_dx = mb->b_mvs[0].x;
413 :     b_dy = mb->b_mvs[0].y;
414 :     }
415 : suxen_drol 1.3
416 : syskin 1.11.2.10 compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, b_ref->y, b_refh->y,
417 :     b_refv->y, b_refhv->y, 16 * i, 16 * j, b_dx,
418 : suxen_drol 1.11.2.11 b_dy, edged_width, quarterpel, 0 /*reduced_resolution*/, 0);
419 : syskin 1.11.2.10
420 :     if (quarterpel) {
421 :     b_dx /= 2;
422 :     b_dy /= 2;
423 :     }
424 :    
425 :     b_dx = (b_dx >> 1) + roundtab_79[b_dx & 0x3];
426 :     b_dy = (b_dy >> 1) + roundtab_79[b_dy & 0x3];
427 : suxen_drol 1.3
428 :    
429 : chl 1.11.2.2 /* uv-block-based compensation */
430 : suxen_drol 1.11.2.1 transfer_8to16sub(&dct_codes[4 * 64],
431 : chl 1.11.2.2 cur->u + 8 * j * edged_width / 2 + 8 * i,
432 :     interpolate8x8_switch2(f_refv->u, b_ref->u, 8 * i, 8 * j,
433 :     b_dx, b_dy, edged_width / 2, 0),
434 :    
435 :     edged_width / 2);
436 : suxen_drol 1.11.2.1
437 :     transfer_8to16sub(&dct_codes[5 * 64],
438 : chl 1.11.2.2 cur->v + 8 * j * edged_width / 2 + 8 * i,
439 :     interpolate8x8_switch2(f_refv->u, b_ref->v, 8 * i, 8 * j,
440 :     b_dx, b_dy, edged_width / 2, 0),
441 :    
442 :     edged_width / 2);
443 : suxen_drol 1.3
444 :     break;
445 :    
446 : chl 1.11 case MODE_INTERPOLATE: /* _could_ use DIRECT, but would be overkill (no 4MV there) */
447 : chl 1.11.2.2 case MODE_DIRECT_NO4V:
448 : chl 1.11
449 : syskin 1.11.2.10 if (quarterpel) {
450 :     dx = mb->qmvs[0].x;
451 :     dy = mb->qmvs[0].y;
452 :     b_dx = mb->b_qmvs[0].x;
453 :     b_dy = mb->b_qmvs[0].y;
454 :    
455 :     interpolate16x16_quarterpel((uint8_t *) f_refv->y, (uint8_t *) f_ref->y, (uint8_t *) f_refh->y,
456 :     (uint8_t *) f_refh->y + 64, (uint8_t *) f_refhv->y, 16*i, 16*j, dx, dy, edged_width, 0);
457 :     interpolate16x16_quarterpel((uint8_t *) b_refv->y, (uint8_t *) b_ref->y, (uint8_t *) b_refh->y,
458 :     (uint8_t *) b_refh->y + 64, (uint8_t *) b_refhv->y, 16*i, 16*j, b_dx, b_dy, edged_width, 0);
459 :    
460 :     for (k = 0; k < 4; k++) {
461 :     transfer_8to16sub2(&dct_codes[k * 64],
462 :     cur->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
463 :     f_refv->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
464 :     b_refv->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
465 :     edged_width);
466 :     }
467 :     b_dx /= 2;
468 :     b_dy /= 2;
469 :     dx /= 2;
470 :     dy /= 2;
471 :    
472 :     } else {
473 :     dx = mb->mvs[0].x;
474 :     dy = mb->mvs[0].y;
475 :     b_dx = mb->b_mvs[0].x;
476 :     b_dy = mb->b_mvs[0].y;
477 :    
478 :     for (k = 0; k < 4; k++) {
479 :     transfer_8to16sub2(&dct_codes[k * 64],
480 :     cur->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
481 :     get_ref(f_ref->y, f_refh->y, f_refv->y,
482 :     f_refhv->y, 2*i + (k&1), 2*j + (k>>1), 8, dx, dy,
483 :     edged_width),
484 :     get_ref(b_ref->y, b_refh->y, b_refv->y,
485 :     b_refhv->y, 2*i + (k&1), 2 * j+(k>>1), 8, b_dx, b_dy,
486 :     edged_width),
487 :     edged_width);
488 :     }
489 : suxen_drol 1.3
490 : chl 1.11 }
491 : suxen_drol 1.3
492 :    
493 : syskin 1.11.2.10 dx = (dx >> 1) + roundtab_79[dx & 0x3];
494 :     dy = (dy >> 1) + roundtab_79[dy & 0x3];
495 :    
496 :     b_dx = (b_dx >> 1) + roundtab_79[b_dx & 0x3];
497 :     b_dy = (b_dy >> 1) + roundtab_79[b_dy & 0x3];
498 : suxen_drol 1.3
499 : chl 1.11.2.2 transfer_8to16sub2(&dct_codes[4 * 64],
500 :     cur->u + (y * 8) * edged_width / 2 + (x * 8),
501 :     interpolate8x8_switch2(f_refv->u, b_ref->u, 8 * i, 8 * j,
502 :     b_dx, b_dy, edged_width / 2, 0),
503 :     interpolate8x8_switch2(f_refv->u + 8, f_ref->u, 8 * i, 8 * j,
504 :     dx, dy, edged_width / 2, 0),
505 :     edged_width / 2);
506 : suxen_drol 1.11.2.1
507 : chl 1.11.2.2 transfer_8to16sub2(&dct_codes[5 * 64],
508 :     cur->v + (y * 8) * edged_width / 2 + (x * 8),
509 :     interpolate8x8_switch2(f_refv->u, b_ref->v, 8 * i, 8 * j,
510 :     b_dx, b_dy, edged_width / 2, 0),
511 :     interpolate8x8_switch2(f_refv->u + 8, f_ref->v, 8 * i, 8 * j,
512 :     dx, dy, edged_width / 2, 0),
513 : suxen_drol 1.11.2.1 edged_width / 2);
514 : chl 1.11.2.2
515 : suxen_drol 1.3 break;
516 : chl 1.11
517 :     case MODE_DIRECT:
518 : syskin 1.11.2.10 if (quarterpel) {
519 :     for (k=0;k<4;k++) {
520 : chl 1.11
521 : syskin 1.11.2.10 dx = mb->qmvs[k].x;
522 :     dy = mb->qmvs[k].y;
523 :     b_dx = mb->b_qmvs[k].x;
524 :     b_dy = mb->b_qmvs[k].y;
525 :    
526 :     interpolate8x8_quarterpel((uint8_t *) f_refv->y,
527 :     (uint8_t *) f_ref->y,
528 :     (uint8_t *) f_refh->y,
529 :     (uint8_t *) f_refh->y + 64,
530 :     (uint8_t *) f_refhv->y,
531 :     16*i + (k&1)*8, 16*j + (k>>1)*8, dx, dy, edged_width, 0);
532 :     interpolate8x8_quarterpel((uint8_t *) b_refv->y,
533 :     (uint8_t *) b_ref->y,
534 :     (uint8_t *) b_refh->y,
535 :     (uint8_t *) b_refh->y + 64,
536 :     (uint8_t *) b_refhv->y,
537 :     16*i + (k&1)*8, 16*j + (k>>1)*8, b_dx, b_dy, edged_width, 0);
538 :    
539 :    
540 :     transfer_8to16sub2(&dct_codes[k * 64],
541 :     cur->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
542 :     f_refv->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
543 :     b_refv->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
544 :     edged_width);
545 :     }
546 :     sum = mb->qmvs[0].y/2 + mb->qmvs[1].y/2 + mb->qmvs[2].y/2 + mb->qmvs[3].y/2;
547 :     dy = (sum >> 3) + roundtab_76[sum & 0xf];
548 :     sum = mb->qmvs[0].x/2 + mb->qmvs[1].x/2 + mb->qmvs[2].x/2 + mb->qmvs[3].x/2;
549 :     dx = (sum >> 3) + roundtab_76[sum & 0xf];
550 :    
551 :     sum = mb->b_qmvs[0].y/2 + mb->b_qmvs[1].y/2 + mb->b_qmvs[2].y/2 + mb->b_qmvs[3].y/2;
552 :     b_dy = (sum >> 3) + roundtab_76[sum & 0xf];
553 :     sum = mb->b_qmvs[0].x/2 + mb->b_qmvs[1].x/2 + mb->b_qmvs[2].x/2 + mb->b_qmvs[3].x/2;
554 :     b_dx = (sum >> 3) + roundtab_76[sum & 0xf];
555 :    
556 :     } else {
557 :     for (k=0;k<4;k++) {
558 :     dx = mb->mvs[k].x;
559 :     dy = mb->mvs[k].y;
560 :    
561 :     b_dx = mb->b_mvs[k].x;
562 :     b_dy = mb->b_mvs[k].y;
563 :    
564 :     transfer_8to16sub2(&dct_codes[k * 64],
565 :     cur->y + (i*16 + (k&1)*8) + (j*16 + (k>>1)*8 ) * edged_width,
566 :     get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,
567 :     2*i + (k&1), 2*j + (k>>1), 8, dx, dy,
568 :     edged_width),
569 :     get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,
570 :     2*i + (k&1), 2*j + (k>>1), 8, b_dx, b_dy,
571 :     edged_width),
572 :     edged_width);
573 :     }
574 :    
575 :     sum = mb->mvs[0].x + mb->mvs[1].x + mb->mvs[2].x + mb->mvs[3].x;
576 :     dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
577 : chl 1.11
578 : syskin 1.11.2.10 sum = mb->mvs[0].y + mb->mvs[1].y + mb->mvs[2].y + mb->mvs[3].y;
579 :     dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
580 : chl 1.11
581 : syskin 1.11.2.10 sum = mb->b_mvs[0].x + mb->b_mvs[1].x + mb->b_mvs[2].x + mb->b_mvs[3].x;
582 :     b_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
583 : chl 1.11
584 : syskin 1.11.2.10 sum = mb->b_mvs[0].y + mb->b_mvs[1].y + mb->b_mvs[2].y + mb->b_mvs[3].y;
585 :     b_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
586 : chl 1.11
587 : syskin 1.11.2.10 }
588 : chl 1.11.2.2 transfer_8to16sub2(&dct_codes[4 * 64],
589 :     cur->u + (y * 8) * edged_width / 2 + (x * 8),
590 :     interpolate8x8_switch2(f_refv->u, b_ref->u, 8 * i, 8 * j,
591 :     b_dx, b_dy, edged_width / 2, 0),
592 :     interpolate8x8_switch2(f_refv->u + 8, f_ref->u, 8 * i, 8 * j, dx, dy,
593 :     edged_width / 2, 0),
594 :     edged_width / 2);
595 : chl 1.11
596 : chl 1.11.2.2 transfer_8to16sub2(&dct_codes[5 * 64],
597 :     cur->v + (y * 8) * edged_width / 2 + (x * 8),
598 :     interpolate8x8_switch2(f_refv->u, b_ref->v, 8 * i, 8 * j,
599 :     b_dx, b_dy, edged_width / 2, 0),
600 :     interpolate8x8_switch2(f_refv->u + 8, f_ref->v, 8 * i, 8 * j,
601 :     dx, dy, edged_width / 2, 0),
602 : suxen_drol 1.11.2.1 edged_width / 2);
603 : chl 1.11.2.2
604 :    
605 : suxen_drol 1.3 break;
606 :     }
607 :     }
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4