1 /*****************************************************************************
2 *
3 * XVID MPEG-4 VIDEO CODEC
4 * - QPel interpolation -
5 *
6 * Copyright(C) 2003 Pascal Massimino <skal@planet-d.net>
7 *
8 * This program is free software ; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation ; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY ; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program ; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * $Id: qpel.h 1985 2011-05-18 09:02:35Z Isibaar $
23 *
24 ****************************************************************************/
25
26 #ifndef _XVID_QPEL_H_
27 #define _XVID_QPEL_H_
28
29 #include "interpolate8x8.h"
30 #include "../utils/mem_transfer.h"
31
32 /*****************************************************************************
33 * Signatures
34 ****************************************************************************/
35
36 #define XVID_QP_PASS_SIGNATURE(NAME) \
37 void (NAME)(uint8_t *dst, const uint8_t *src, int32_t length, int32_t BpS, int32_t rounding)
38
39 typedef XVID_QP_PASS_SIGNATURE(XVID_QP_PASS);
40
41 /* We put everything in a single struct so it can easily be passed
42 * to prediction functions as a whole... */
43
44 typedef struct _XVID_QP_FUNCS {
45
46 /* filter for QPel 16x? prediction */
47
48 XVID_QP_PASS *H_Pass;
49 XVID_QP_PASS *H_Pass_Avrg;
50 XVID_QP_PASS *H_Pass_Avrg_Up;
51 XVID_QP_PASS *V_Pass;
52 XVID_QP_PASS *V_Pass_Avrg;
53 XVID_QP_PASS *V_Pass_Avrg_Up;
54
55 /* filter for QPel 8x? prediction */
56
57 XVID_QP_PASS *H_Pass_8;
58 XVID_QP_PASS *H_Pass_Avrg_8;
59 XVID_QP_PASS *H_Pass_Avrg_Up_8;
60 XVID_QP_PASS *V_Pass_8;
61 XVID_QP_PASS *V_Pass_Avrg_8;
62 XVID_QP_PASS *V_Pass_Avrg_Up_8;
63 } XVID_QP_FUNCS;
64
65 /*****************************************************************************
66 * fwd dcl
67 ****************************************************************************/
68 extern void xvid_Init_QP();
69
70 extern XVID_QP_FUNCS xvid_QP_Funcs_C_ref; /* for P-frames */
71 extern XVID_QP_FUNCS xvid_QP_Add_Funcs_C_ref; /* for B-frames */
72
73 extern XVID_QP_FUNCS xvid_QP_Funcs_C; /* for P-frames */
74 extern XVID_QP_FUNCS xvid_QP_Add_Funcs_C; /* for B-frames */
75
76 #if defined(ARCH_IS_IA32) || defined(ARCH_IS_X86_64)
77 extern XVID_QP_FUNCS xvid_QP_Funcs_mmx;
78 extern XVID_QP_FUNCS xvid_QP_Add_Funcs_mmx;
79 #endif
80
81 #ifdef ARCH_IS_PPC
82 extern XVID_QP_FUNCS xvid_QP_Funcs_Altivec_C;
83 extern XVID_QP_FUNCS xvid_QP_Add_Funcs_Altivec_C;
84 #endif
85
86 extern XVID_QP_FUNCS *xvid_QP_Funcs; /* <- main pointer for enc/dec structure */
87 extern XVID_QP_FUNCS *xvid_QP_Add_Funcs; /* <- main pointer for enc/dec structure */
88
89 /*****************************************************************************
90 * macros
91 ****************************************************************************/
92
93 /*****************************************************************************
94
95 Passes to be performed
96
97 case 0: copy
98 case 2: h-pass
99 case 1/3: h-pass + h-avrg
100 case 8: v-pass
101 case 10: h-pass + v-pass
102 case 9/11: h-pass + h-avrg + v-pass
103 case 4/12: v-pass + v-avrg
104 case 6/14: h-pass + v-pass + v-avrg
105 case 5/13/7/15: h-pass + h-avrg + v-pass + v-avrg
106
107 ****************************************************************************/
108
109 static void __inline
interpolate16x16_quarterpel(uint8_t * const cur,uint8_t * const refn,uint8_t * const refh,uint8_t * const refv,uint8_t * const refhv,const uint32_t x,const uint32_t y,const int32_t dx,const int dy,const uint32_t stride,const uint32_t rounding)110 interpolate16x16_quarterpel(uint8_t * const cur,
111 uint8_t * const refn,
112 uint8_t * const refh,
113 uint8_t * const refv,
114 uint8_t * const refhv,
115 const uint32_t x, const uint32_t y,
116 const int32_t dx, const int dy,
117 const uint32_t stride,
118 const uint32_t rounding)
119 {
120 const uint8_t *src;
121 uint8_t *dst;
122 uint8_t *tmp;
123 int32_t quads;
124 const XVID_QP_FUNCS *Ops;
125
126 int32_t x_int, y_int;
127
128 const int32_t xRef = (int)x*4 + dx;
129 const int32_t yRef = (int)y*4 + dy;
130
131 Ops = xvid_QP_Funcs;
132 quads = (dx&3) | ((dy&3)<<2);
133
134 x_int = xRef >> 2;
135 y_int = yRef >> 2;
136
137 dst = cur + y * stride + x;
138 src = refn + y_int * (int)stride + x_int;
139
140 tmp = refh; /* we need at least a 16 x stride scratch block */
141
142 switch(quads) {
143 case 0:
144 transfer8x8_copy(dst, src, stride);
145 transfer8x8_copy(dst+8, src+8, stride);
146 transfer8x8_copy(dst+8*stride, src+8*stride, stride);
147 transfer8x8_copy(dst+8*stride+8, src+8*stride+8, stride);
148 break;
149 case 1:
150 Ops->H_Pass_Avrg(dst, src, 16, stride, rounding);
151 break;
152 case 2:
153 Ops->H_Pass(dst, src, 16, stride, rounding);
154 break;
155 case 3:
156 Ops->H_Pass_Avrg_Up(dst, src, 16, stride, rounding);
157 break;
158 case 4:
159 Ops->V_Pass_Avrg(dst, src, 16, stride, rounding);
160 break;
161 case 5:
162 Ops->H_Pass_Avrg(tmp, src, 17, stride, rounding);
163 Ops->V_Pass_Avrg(dst, tmp, 16, stride, rounding);
164 break;
165 case 6:
166 Ops->H_Pass(tmp, src, 17, stride, rounding);
167 Ops->V_Pass_Avrg(dst, tmp, 16, stride, rounding);
168 break;
169 case 7:
170 Ops->H_Pass_Avrg_Up(tmp, src, 17, stride, rounding);
171 Ops->V_Pass_Avrg(dst, tmp, 16, stride, rounding);
172 break;
173 case 8:
174 Ops->V_Pass(dst, src, 16, stride, rounding);
175 break;
176 case 9:
177 Ops->H_Pass_Avrg(tmp, src, 17, stride, rounding);
178 Ops->V_Pass(dst, tmp, 16, stride, rounding);
179 break;
180 case 10:
181 Ops->H_Pass(tmp, src, 17, stride, rounding);
182 Ops->V_Pass(dst, tmp, 16, stride, rounding);
183 break;
184 case 11:
185 Ops->H_Pass_Avrg_Up(tmp, src, 17, stride, rounding);
186 Ops->V_Pass(dst, tmp, 16, stride, rounding);
187 break;
188 case 12:
189 Ops->V_Pass_Avrg_Up(dst, src, 16, stride, rounding);
190 break;
191 case 13:
192 Ops->H_Pass_Avrg(tmp, src, 17, stride, rounding);
193 Ops->V_Pass_Avrg_Up(dst, tmp, 16, stride, rounding);
194 break;
195 case 14:
196 Ops->H_Pass(tmp, src, 17, stride, rounding);
197 Ops->V_Pass_Avrg_Up( dst, tmp, 16, stride, rounding);
198 break;
199 case 15:
200 Ops->H_Pass_Avrg_Up(tmp, src, 17, stride, rounding);
201 Ops->V_Pass_Avrg_Up(dst, tmp, 16, stride, rounding);
202 break;
203 }
204 }
205
206 static void __inline
interpolate16x16_add_quarterpel(uint8_t * const cur,uint8_t * const refn,uint8_t * const refh,uint8_t * const refv,uint8_t * const refhv,const uint32_t x,const uint32_t y,const int32_t dx,const int dy,const uint32_t stride,const uint32_t rounding)207 interpolate16x16_add_quarterpel(uint8_t * const cur,
208 uint8_t * const refn,
209 uint8_t * const refh,
210 uint8_t * const refv,
211 uint8_t * const refhv,
212 const uint32_t x, const uint32_t y,
213 const int32_t dx, const int dy,
214 const uint32_t stride,
215 const uint32_t rounding)
216 {
217 const uint8_t *src;
218 uint8_t *dst;
219 uint8_t *tmp;
220 int32_t quads;
221 const XVID_QP_FUNCS *Ops;
222 const XVID_QP_FUNCS *Ops_Copy;
223
224 int32_t x_int, y_int;
225
226 const int32_t xRef = (int)x*4 + dx;
227 const int32_t yRef = (int)y*4 + dy;
228
229 Ops = xvid_QP_Add_Funcs;
230 Ops_Copy = xvid_QP_Funcs;
231 quads = (dx&3) | ((dy&3)<<2);
232
233 x_int = xRef >> 2;
234 y_int = yRef >> 2;
235
236 dst = cur + y * stride + x;
237 src = refn + y_int * (int)stride + x_int;
238
239 tmp = refh; /* we need at least a 16 x stride scratch block */
240
241 switch(quads) {
242 case 0:
243 /* NB: there is no halfpel involved ! the name's function can be
244 * misleading */
245 interpolate8x8_halfpel_add(dst, src, stride, rounding);
246 interpolate8x8_halfpel_add(dst+8, src+8, stride, rounding);
247 interpolate8x8_halfpel_add(dst+8*stride, src+8*stride, stride, rounding);
248 interpolate8x8_halfpel_add(dst+8*stride+8, src+8*stride+8, stride, rounding);
249 break;
250 case 1:
251 Ops->H_Pass_Avrg(dst, src, 16, stride, rounding);
252 break;
253 case 2:
254 Ops->H_Pass(dst, src, 16, stride, rounding);
255 break;
256 case 3:
257 Ops->H_Pass_Avrg_Up(dst, src, 16, stride, rounding);
258 break;
259 case 4:
260 Ops->V_Pass_Avrg(dst, src, 16, stride, rounding);
261 break;
262 case 5:
263 Ops_Copy->H_Pass_Avrg(tmp, src, 17, stride, rounding);
264 Ops->V_Pass_Avrg(dst, tmp, 16, stride, rounding);
265 break;
266 case 6:
267 Ops_Copy->H_Pass(tmp, src, 17, stride, rounding);
268 Ops->V_Pass_Avrg(dst, tmp, 16, stride, rounding);
269 break;
270 case 7:
271 Ops_Copy->H_Pass_Avrg_Up(tmp, src, 17, stride, rounding);
272 Ops->V_Pass_Avrg(dst, tmp, 16, stride, rounding);
273 break;
274 case 8:
275 Ops->V_Pass(dst, src, 16, stride, rounding);
276 break;
277 case 9:
278 Ops_Copy->H_Pass_Avrg(tmp, src, 17, stride, rounding);
279 Ops->V_Pass(dst, tmp, 16, stride, rounding);
280 break;
281 case 10:
282 Ops_Copy->H_Pass(tmp, src, 17, stride, rounding);
283 Ops->V_Pass(dst, tmp, 16, stride, rounding);
284 break;
285 case 11:
286 Ops_Copy->H_Pass_Avrg_Up(tmp, src, 17, stride, rounding);
287 Ops->V_Pass(dst, tmp, 16, stride, rounding);
288 break;
289 case 12:
290 Ops->V_Pass_Avrg_Up(dst, src, 16, stride, rounding);
291 break;
292 case 13:
293 Ops_Copy->H_Pass_Avrg(tmp, src, 17, stride, rounding);
294 Ops->V_Pass_Avrg_Up(dst, tmp, 16, stride, rounding);
295 break;
296 case 14:
297 Ops_Copy->H_Pass(tmp, src, 17, stride, rounding);
298 Ops->V_Pass_Avrg_Up( dst, tmp, 16, stride, rounding);
299 break;
300 case 15:
301 Ops_Copy->H_Pass_Avrg_Up(tmp, src, 17, stride, rounding);
302 Ops->V_Pass_Avrg_Up(dst, tmp, 16, stride, rounding);
303 break;
304 }
305 }
306
307 static void __inline
interpolate16x8_quarterpel(uint8_t * const cur,uint8_t * const refn,uint8_t * const refh,uint8_t * const refv,uint8_t * const refhv,const uint32_t x,const uint32_t y,const int32_t dx,const int dy,const uint32_t stride,const uint32_t rounding)308 interpolate16x8_quarterpel(uint8_t * const cur,
309 uint8_t * const refn,
310 uint8_t * const refh,
311 uint8_t * const refv,
312 uint8_t * const refhv,
313 const uint32_t x, const uint32_t y,
314 const int32_t dx, const int dy,
315 const uint32_t stride,
316 const uint32_t rounding)
317 {
318 const uint8_t *src;
319 uint8_t *dst;
320 uint8_t *tmp;
321 int32_t quads;
322 const XVID_QP_FUNCS *Ops;
323
324 int32_t x_int, y_int;
325
326 const int32_t xRef = (int)x*4 + dx;
327 const int32_t yRef = (int)y*4 + dy;
328
329 Ops = xvid_QP_Funcs;
330 quads = (dx&3) | ((dy&3)<<2);
331
332 x_int = xRef >> 2;
333 y_int = yRef >> 2;
334
335 dst = cur + y * stride + x;
336 src = refn + y_int * (int)stride + x_int;
337
338 tmp = refh; /* we need at least a 16 x stride scratch block */
339
340 switch(quads) {
341 case 0:
342 transfer8x8_copy( dst, src, stride);
343 transfer8x8_copy( dst+8, src+8, stride);
344 break;
345 case 1:
346 Ops->H_Pass_Avrg(dst, src, 8, stride, rounding);
347 break;
348 case 2:
349 Ops->H_Pass(dst, src, 8, stride, rounding);
350 break;
351 case 3:
352 Ops->H_Pass_Avrg_Up(dst, src, 8, stride, rounding);
353 break;
354 case 4:
355 Ops->V_Pass_Avrg_8(dst, src, 16, stride, rounding);
356 break;
357 case 5:
358 Ops->H_Pass_Avrg(tmp, src, 9, stride, rounding);
359 Ops->V_Pass_Avrg_8(dst, tmp, 16, stride, rounding);
360 break;
361 case 6:
362 Ops->H_Pass(tmp, src, 9, stride, rounding);
363 Ops->V_Pass_Avrg_8(dst, tmp, 16, stride, rounding);
364 break;
365 case 7:
366 Ops->H_Pass_Avrg_Up(tmp, src, 9, stride, rounding);
367 Ops->V_Pass_Avrg_8(dst, tmp, 16, stride, rounding);
368 break;
369 case 8:
370 Ops->V_Pass_8(dst, src, 16, stride, rounding);
371 break;
372 case 9:
373 Ops->H_Pass_Avrg(tmp, src, 9, stride, rounding);
374 Ops->V_Pass_8(dst, tmp, 16, stride, rounding);
375 break;
376 case 10:
377 Ops->H_Pass(tmp, src, 9, stride, rounding);
378 Ops->V_Pass_8(dst, tmp, 16, stride, rounding);
379 break;
380 case 11:
381 Ops->H_Pass_Avrg_Up(tmp, src, 9, stride, rounding);
382 Ops->V_Pass_8(dst, tmp, 16, stride, rounding);
383 break;
384 case 12:
385 Ops->V_Pass_Avrg_Up_8(dst, src, 16, stride, rounding);
386 break;
387 case 13:
388 Ops->H_Pass_Avrg(tmp, src, 9, stride, rounding);
389 Ops->V_Pass_Avrg_Up_8(dst, tmp, 16, stride, rounding);
390 break;
391 case 14:
392 Ops->H_Pass(tmp, src, 9, stride, rounding);
393 Ops->V_Pass_Avrg_Up_8( dst, tmp, 16, stride, rounding);
394 break;
395 case 15:
396 Ops->H_Pass_Avrg_Up(tmp, src, 9, stride, rounding);
397 Ops->V_Pass_Avrg_Up_8(dst, tmp, 16, stride, rounding);
398 break;
399 }
400 }
401
402 static void __inline
interpolate8x8_quarterpel(uint8_t * const cur,uint8_t * const refn,uint8_t * const refh,uint8_t * const refv,uint8_t * const refhv,const uint32_t x,const uint32_t y,const int32_t dx,const int dy,const uint32_t stride,const uint32_t rounding)403 interpolate8x8_quarterpel(uint8_t * const cur,
404 uint8_t * const refn,
405 uint8_t * const refh,
406 uint8_t * const refv,
407 uint8_t * const refhv,
408 const uint32_t x, const uint32_t y,
409 const int32_t dx, const int dy,
410 const uint32_t stride,
411 const uint32_t rounding)
412 {
413 const uint8_t *src;
414 uint8_t *dst;
415 uint8_t *tmp;
416 int32_t quads;
417 const XVID_QP_FUNCS *Ops;
418
419 int32_t x_int, y_int;
420
421 const int32_t xRef = (int)x*4 + dx;
422 const int32_t yRef = (int)y*4 + dy;
423
424 Ops = xvid_QP_Funcs;
425 quads = (dx&3) | ((dy&3)<<2);
426
427 x_int = xRef >> 2;
428 y_int = yRef >> 2;
429
430 dst = cur + y * stride + x;
431 src = refn + y_int * (int)stride + x_int;
432
433 tmp = refh; /* we need at least a 16 x stride scratch block */
434
435 switch(quads) {
436 case 0:
437 transfer8x8_copy( dst, src, stride);
438 break;
439 case 1:
440 Ops->H_Pass_Avrg_8(dst, src, 8, stride, rounding);
441 break;
442 case 2:
443 Ops->H_Pass_8(dst, src, 8, stride, rounding);
444 break;
445 case 3:
446 Ops->H_Pass_Avrg_Up_8(dst, src, 8, stride, rounding);
447 break;
448 case 4:
449 Ops->V_Pass_Avrg_8(dst, src, 8, stride, rounding);
450 break;
451 case 5:
452 Ops->H_Pass_Avrg_8(tmp, src, 9, stride, rounding);
453 Ops->V_Pass_Avrg_8(dst, tmp, 8, stride, rounding);
454 break;
455 case 6:
456 Ops->H_Pass_8(tmp, src, 9, stride, rounding);
457 Ops->V_Pass_Avrg_8(dst, tmp, 8, stride, rounding);
458 break;
459 case 7:
460 Ops->H_Pass_Avrg_Up_8(tmp, src, 9, stride, rounding);
461 Ops->V_Pass_Avrg_8(dst, tmp, 8, stride, rounding);
462 break;
463 case 8:
464 Ops->V_Pass_8(dst, src, 8, stride, rounding);
465 break;
466 case 9:
467 Ops->H_Pass_Avrg_8(tmp, src, 9, stride, rounding);
468 Ops->V_Pass_8(dst, tmp, 8, stride, rounding);
469 break;
470 case 10:
471 Ops->H_Pass_8(tmp, src, 9, stride, rounding);
472 Ops->V_Pass_8(dst, tmp, 8, stride, rounding);
473 break;
474 case 11:
475 Ops->H_Pass_Avrg_Up_8(tmp, src, 9, stride, rounding);
476 Ops->V_Pass_8(dst, tmp, 8, stride, rounding);
477 break;
478 case 12:
479 Ops->V_Pass_Avrg_Up_8(dst, src, 8, stride, rounding);
480 break;
481 case 13:
482 Ops->H_Pass_Avrg_8(tmp, src, 9, stride, rounding);
483 Ops->V_Pass_Avrg_Up_8(dst, tmp, 8, stride, rounding);
484 break;
485 case 14:
486 Ops->H_Pass_8(tmp, src, 9, stride, rounding);
487 Ops->V_Pass_Avrg_Up_8( dst, tmp, 8, stride, rounding);
488 break;
489 case 15:
490 Ops->H_Pass_Avrg_Up_8(tmp, src, 9, stride, rounding);
491 Ops->V_Pass_Avrg_Up_8(dst, tmp, 8, stride, rounding);
492 break;
493 }
494 }
495
496 static void __inline
interpolate8x8_add_quarterpel(uint8_t * const cur,uint8_t * const refn,uint8_t * const refh,uint8_t * const refv,uint8_t * const refhv,const uint32_t x,const uint32_t y,const int32_t dx,const int dy,const uint32_t stride,const uint32_t rounding)497 interpolate8x8_add_quarterpel(uint8_t * const cur,
498 uint8_t * const refn,
499 uint8_t * const refh,
500 uint8_t * const refv,
501 uint8_t * const refhv,
502 const uint32_t x, const uint32_t y,
503 const int32_t dx, const int dy,
504 const uint32_t stride,
505 const uint32_t rounding)
506 {
507 const uint8_t *src;
508 uint8_t *dst;
509 uint8_t *tmp;
510 int32_t quads;
511 const XVID_QP_FUNCS *Ops;
512 const XVID_QP_FUNCS *Ops_Copy;
513
514 int32_t x_int, y_int;
515
516 const int32_t xRef = (int)x*4 + dx;
517 const int32_t yRef = (int)y*4 + dy;
518
519 Ops = xvid_QP_Add_Funcs;
520 Ops_Copy = xvid_QP_Funcs;
521 quads = (dx&3) | ((dy&3)<<2);
522
523 x_int = xRef >> 2;
524 y_int = yRef >> 2;
525
526 dst = cur + y * stride + x;
527 src = refn + y_int * (int)stride + x_int;
528
529 tmp = refh; /* we need at least a 16 x stride scratch block */
530
531 switch(quads) {
532 case 0:
533 /* Misleading function name, there is no halfpel involved
534 * just dst and src averaging with rounding=0 */
535 interpolate8x8_halfpel_add(dst, src, stride, rounding);
536 break;
537 case 1:
538 Ops->H_Pass_Avrg_8(dst, src, 8, stride, rounding);
539 break;
540 case 2:
541 Ops->H_Pass_8(dst, src, 8, stride, rounding);
542 break;
543 case 3:
544 Ops->H_Pass_Avrg_Up_8(dst, src, 8, stride, rounding);
545 break;
546 case 4:
547 Ops->V_Pass_Avrg_8(dst, src, 8, stride, rounding);
548 break;
549 case 5:
550 Ops_Copy->H_Pass_Avrg_8(tmp, src, 9, stride, rounding);
551 Ops->V_Pass_Avrg_8(dst, tmp, 8, stride, rounding);
552 break;
553 case 6:
554 Ops_Copy->H_Pass_8(tmp, src, 9, stride, rounding);
555 Ops->V_Pass_Avrg_8(dst, tmp, 8, stride, rounding);
556 break;
557 case 7:
558 Ops_Copy->H_Pass_Avrg_Up_8(tmp, src, 9, stride, rounding);
559 Ops->V_Pass_Avrg_8(dst, tmp, 8, stride, rounding);
560 break;
561 case 8:
562 Ops->V_Pass_8(dst, src, 8, stride, rounding);
563 break;
564 case 9:
565 Ops_Copy->H_Pass_Avrg_8(tmp, src, 9, stride, rounding);
566 Ops->V_Pass_8(dst, tmp, 8, stride, rounding);
567 break;
568 case 10:
569 Ops_Copy->H_Pass_8(tmp, src, 9, stride, rounding);
570 Ops->V_Pass_8(dst, tmp, 8, stride, rounding);
571 break;
572 case 11:
573 Ops_Copy->H_Pass_Avrg_Up_8(tmp, src, 9, stride, rounding);
574 Ops->V_Pass_8(dst, tmp, 8, stride, rounding);
575 break;
576 case 12:
577 Ops->V_Pass_Avrg_Up_8(dst, src, 8, stride, rounding);
578 break;
579 case 13:
580 Ops_Copy->H_Pass_Avrg_8(tmp, src, 9, stride, rounding);
581 Ops->V_Pass_Avrg_Up_8(dst, tmp, 8, stride, rounding);
582 break;
583 case 14:
584 Ops_Copy->H_Pass_8(tmp, src, 9, stride, rounding);
585 Ops->V_Pass_Avrg_Up_8( dst, tmp, 8, stride, rounding);
586 break;
587 case 15:
588 Ops_Copy->H_Pass_Avrg_Up_8(tmp, src, 9, stride, rounding);
589 Ops->V_Pass_Avrg_Up_8(dst, tmp, 8, stride, rounding);
590 break;
591 }
592 }
593
594 #endif /* _XVID_QPEL_H_ */
595