[cvs] / xvidcore / src / image / qpel.h Repository:
ViewVC logotype

Annotation of /xvidcore/src/image/qpel.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.1.4.5 - (view) (download)

1 : Isibaar 1.1.4.1 /*****************************************************************************
2 :     *
3 : edgomez 1.1.4.2 * 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 : Isibaar 1.1.4.1 *
13 : edgomez 1.1.4.2 * 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 : Isibaar 1.1.4.1 *
18 : edgomez 1.1.4.2 * 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$
23 :     *
24 :     ****************************************************************************/
25 : Isibaar 1.1.4.1
26 :     #ifndef _XVID_QPEL_H_
27 :     #define _XVID_QPEL_H_
28 :    
29 :     #include "../utils/mem_transfer.h"
30 :    
31 :     /*****************************************************************************
32 :     * Signatures
33 :     ****************************************************************************/
34 :    
35 :     #define XVID_QP_PASS_SIGNATURE(NAME) \
36 :     void (NAME)(uint8_t *dst, const uint8_t *src, int32_t length, int32_t BpS, int32_t rounding)
37 :    
38 :     typedef XVID_QP_PASS_SIGNATURE(XVID_QP_PASS);
39 :    
40 : edgomez 1.1.4.2 /* We put everything in a single struct so it can easily be passed
41 :     * to prediction functions as a whole... */
42 : Isibaar 1.1.4.1
43 : edgomez 1.1.4.2 typedef struct _XVID_QP_FUNCS {
44 : Isibaar 1.1.4.1
45 : edgomez 1.1.4.2 /* filter for QPel 16x? prediction */
46 : Isibaar 1.1.4.1
47 : edgomez 1.1.4.2 XVID_QP_PASS *H_Pass;
48 :     XVID_QP_PASS *H_Pass_Avrg;
49 :     XVID_QP_PASS *H_Pass_Avrg_Up;
50 :     XVID_QP_PASS *V_Pass;
51 :     XVID_QP_PASS *V_Pass_Avrg;
52 :     XVID_QP_PASS *V_Pass_Avrg_Up;
53 : Isibaar 1.1.4.1
54 : edgomez 1.1.4.4 /* filter for QPel 8x? prediction */
55 : Isibaar 1.1.4.1
56 : edgomez 1.1.4.2 XVID_QP_PASS *H_Pass_8;
57 :     XVID_QP_PASS *H_Pass_Avrg_8;
58 :     XVID_QP_PASS *H_Pass_Avrg_Up_8;
59 :     XVID_QP_PASS *V_Pass_8;
60 :     XVID_QP_PASS *V_Pass_Avrg_8;
61 :     XVID_QP_PASS *V_Pass_Avrg_Up_8;
62 :     } XVID_QP_FUNCS;
63 : Isibaar 1.1.4.1
64 :     /*****************************************************************************
65 :     * fwd dcl
66 :     ****************************************************************************/
67 : edgomez 1.1.4.2 extern void xvid_Init_QP();
68 : Isibaar 1.1.4.1
69 : edgomez 1.1.4.4 extern XVID_QP_FUNCS xvid_QP_Funcs_C; /* for P-frames */
70 :     extern XVID_QP_FUNCS xvid_QP_Add_Funcs_C; /* for B-frames */
71 : Isibaar 1.1.4.1
72 : edgomez 1.1.4.2 #ifdef ARCH_IS_IA32
73 : Isibaar 1.1.4.1 extern XVID_QP_FUNCS xvid_QP_Funcs_mmx;
74 :     extern XVID_QP_FUNCS xvid_QP_Add_Funcs_mmx;
75 : edgomez 1.1.4.2 #endif
76 : Isibaar 1.1.4.1
77 : edgomez 1.1.4.4 extern XVID_QP_FUNCS *xvid_QP_Funcs; /* <- main pointer for enc/dec structure */
78 :     extern XVID_QP_FUNCS *xvid_QP_Add_Funcs; /* <- main pointer for enc/dec structure */
79 : Isibaar 1.1.4.1
80 :     /*****************************************************************************
81 :     * macros
82 :     ****************************************************************************/
83 :    
84 :     /*****************************************************************************
85 :    
86 :     Passes to be performed
87 :    
88 :     case 0: copy
89 :     case 2: h-pass
90 :     case 1/3: h-pass + h-avrg
91 :     case 8: v-pass
92 :     case 10: h-pass + v-pass
93 :     case 9/11: h-pass + h-avrg + v-pass
94 :     case 4/12: v-pass + v-avrg
95 :     case 6/14: h-pass + v-pass + v-avrg
96 :     case 5/13/7/15: h-pass + h-avrg + v-pass + v-avrg
97 :    
98 :     ****************************************************************************/
99 :    
100 : edgomez 1.1.4.2 static void __inline
101 :     new_interpolate16x16_quarterpel(uint8_t * const cur,
102 :     uint8_t * const refn,
103 :     uint8_t * const refh,
104 :     uint8_t * const refv,
105 :     uint8_t * const refhv,
106 :     const uint32_t x, const uint32_t y,
107 :     const int32_t dx, const int dy,
108 :     const uint32_t stride,
109 :     const uint32_t rounding)
110 : Isibaar 1.1.4.1 {
111 :     const uint8_t *src;
112 :     uint8_t *dst;
113 :     uint8_t *tmp;
114 :     int32_t quads;
115 :     const XVID_QP_FUNCS *Ops;
116 :    
117 :     int32_t x_int, y_int;
118 :    
119 : edgomez 1.1.4.2 const int32_t xRef = x*4 + dx;
120 :     const int32_t yRef = y*4 + dy;
121 : edgomez 1.1.4.5
122 : edgomez 1.1.4.4 Ops = xvid_QP_Funcs; /* TODO: pass as argument */
123 : edgomez 1.1.4.2 quads = (dx&3) | ((dy&3)<<2);
124 : edgomez 1.1.4.5
125 : edgomez 1.1.4.2 x_int = xRef/4;
126 :     if (xRef < 0 && xRef % 4)
127 :     x_int--;
128 : edgomez 1.1.4.5
129 : edgomez 1.1.4.2 y_int = yRef/4;
130 :     if (yRef < 0 && yRef % 4)
131 :     y_int--;
132 : edgomez 1.1.4.5
133 : edgomez 1.1.4.2 dst = cur + y * stride + x;
134 : Isibaar 1.1.4.1 src = refn + y_int * stride + x_int;
135 :    
136 : edgomez 1.1.4.4 tmp = refh; /* we need at least a 16 x stride scratch block */
137 : Isibaar 1.1.4.1
138 : edgomez 1.1.4.2 switch(quads) {
139 :     case 0:
140 :     transfer8x8_copy( dst, src, stride);
141 :     transfer8x8_copy( dst+8, src+8, stride);
142 :     transfer8x8_copy( dst+8*stride, src+8*stride, stride);
143 :     transfer8x8_copy( dst+8*stride+8, src+8*stride+8, stride);
144 :     break;
145 :     case 1:
146 :     Ops->H_Pass_Avrg(dst, src, 16, stride, rounding);
147 :     break;
148 :     case 2:
149 :     Ops->H_Pass(dst, src, 16, stride, rounding);
150 :     break;
151 :     case 3:
152 :     Ops->H_Pass_Avrg_Up(dst, src, 16, stride, rounding);
153 :     break;
154 :     case 4:
155 :     Ops->V_Pass_Avrg(dst, src, 16, stride, rounding);
156 :     break;
157 :     case 5:
158 :     Ops->H_Pass_Avrg(tmp, src, 17, stride, rounding);
159 :     Ops->V_Pass_Avrg(dst, tmp, 16, stride, rounding);
160 :     break;
161 :     case 6:
162 :     Ops->H_Pass(tmp, src, 17, stride, rounding);
163 :     Ops->V_Pass_Avrg(dst, tmp, 16, stride, rounding);
164 :     break;
165 :     case 7:
166 :     Ops->H_Pass_Avrg_Up(tmp, src, 17, stride, rounding);
167 :     Ops->V_Pass_Avrg(dst, tmp, 16, stride, rounding);
168 :     break;
169 :     case 8:
170 :     Ops->V_Pass(dst, src, 16, stride, rounding);
171 :     break;
172 :     case 9:
173 :     Ops->H_Pass_Avrg(tmp, src, 17, stride, rounding);
174 :     Ops->V_Pass(dst, tmp, 16, stride, rounding);
175 :     break;
176 :     case 10:
177 :     Ops->H_Pass(tmp, src, 17, stride, rounding);
178 :     Ops->V_Pass(dst, tmp, 16, stride, rounding);
179 :     break;
180 :     case 11:
181 :     Ops->H_Pass_Avrg_Up(tmp, src, 17, stride, rounding);
182 :     Ops->V_Pass(dst, tmp, 16, stride, rounding);
183 :     break;
184 :     case 12:
185 :     Ops->V_Pass_Avrg_Up(dst, src, 16, stride, rounding);
186 :     break;
187 :     case 13:
188 :     Ops->H_Pass_Avrg(tmp, src, 17, stride, rounding);
189 :     Ops->V_Pass_Avrg_Up(dst, tmp, 16, stride, rounding);
190 :     break;
191 :     case 14:
192 :     Ops->H_Pass(tmp, src, 17, stride, rounding);
193 :     Ops->V_Pass_Avrg_Up( dst, tmp, 16, stride, rounding);
194 :     break;
195 :     case 15:
196 :     Ops->H_Pass_Avrg_Up(tmp, src, 17, stride, rounding);
197 :     Ops->V_Pass_Avrg_Up(dst, tmp, 16, stride, rounding);
198 :     break;
199 :     }
200 : Isibaar 1.1.4.1 }
201 :    
202 : edgomez 1.1.4.2 static void __inline
203 :     new_interpolate16x8_quarterpel(uint8_t * const cur,
204 :     uint8_t * const refn,
205 :     uint8_t * const refh,
206 :     uint8_t * const refv,
207 :     uint8_t * const refhv,
208 :     const uint32_t x, const uint32_t y,
209 :     const int32_t dx, const int dy,
210 :     const uint32_t stride,
211 :     const uint32_t rounding)
212 : Isibaar 1.1.4.1 {
213 :     const uint8_t *src;
214 :     uint8_t *dst;
215 :     uint8_t *tmp;
216 :     int32_t quads;
217 :     const XVID_QP_FUNCS *Ops;
218 :    
219 :     int32_t x_int, y_int;
220 :    
221 : edgomez 1.1.4.2 const int32_t xRef = x*4 + dx;
222 :     const int32_t yRef = y*4 + dy;
223 : edgomez 1.1.4.5
224 : edgomez 1.1.4.4 Ops = xvid_QP_Funcs; /* TODO: pass as argument */
225 : edgomez 1.1.4.2 quads = (dx&3) | ((dy&3)<<2);
226 : edgomez 1.1.4.5
227 : edgomez 1.1.4.2 x_int = xRef/4;
228 :     if (xRef < 0 && xRef % 4)
229 :     x_int--;
230 : edgomez 1.1.4.5
231 : edgomez 1.1.4.2 y_int = yRef/4;
232 :     if (yRef < 0 && yRef % 4)
233 :     y_int--;
234 : edgomez 1.1.4.5
235 : edgomez 1.1.4.2 dst = cur + y * stride + x;
236 : Isibaar 1.1.4.1 src = refn + y_int * stride + x_int;
237 :    
238 : edgomez 1.1.4.4 tmp = refh; /* we need at least a 16 x stride scratch block */
239 : Isibaar 1.1.4.1
240 : edgomez 1.1.4.2 switch(quads) {
241 :     case 0:
242 :     transfer8x8_copy( dst, src, stride);
243 :     transfer8x8_copy( dst+8, src+8, stride);
244 :     break;
245 :     case 1:
246 :     Ops->H_Pass_Avrg(dst, src, 8, stride, rounding);
247 :     break;
248 :     case 2:
249 :     Ops->H_Pass(dst, src, 8, stride, rounding);
250 :     break;
251 :     case 3:
252 :     Ops->H_Pass_Avrg_Up(dst, src, 8, stride, rounding);
253 :     break;
254 :     case 4:
255 :     Ops->V_Pass_Avrg_8(dst, src, 16, stride, rounding);
256 :     break;
257 :     case 5:
258 :     Ops->H_Pass_Avrg(tmp, src, 9, stride, rounding);
259 :     Ops->V_Pass_Avrg_8(dst, tmp, 16, stride, rounding);
260 :     break;
261 :     case 6:
262 :     Ops->H_Pass(tmp, src, 9, stride, rounding);
263 :     Ops->V_Pass_Avrg_8(dst, tmp, 16, stride, rounding);
264 :     break;
265 :     case 7:
266 :     Ops->H_Pass_Avrg_Up(tmp, src, 9, stride, rounding);
267 :     Ops->V_Pass_Avrg_8(dst, tmp, 16, stride, rounding);
268 :     break;
269 :     case 8:
270 :     Ops->V_Pass_8(dst, src, 16, stride, rounding);
271 :     break;
272 :     case 9:
273 :     Ops->H_Pass_Avrg(tmp, src, 9, stride, rounding);
274 :     Ops->V_Pass_8(dst, tmp, 16, stride, rounding);
275 :     break;
276 :     case 10:
277 :     Ops->H_Pass(tmp, src, 9, stride, rounding);
278 :     Ops->V_Pass_8(dst, tmp, 16, stride, rounding);
279 :     break;
280 :     case 11:
281 :     Ops->H_Pass_Avrg_Up(tmp, src, 9, stride, rounding);
282 :     Ops->V_Pass_8(dst, tmp, 16, stride, rounding);
283 :     break;
284 :     case 12:
285 :     Ops->V_Pass_Avrg_Up_8(dst, src, 16, stride, rounding);
286 :     break;
287 :     case 13:
288 :     Ops->H_Pass_Avrg(tmp, src, 9, stride, rounding);
289 :     Ops->V_Pass_Avrg_Up_8(dst, tmp, 16, stride, rounding);
290 :     break;
291 :     case 14:
292 :     Ops->H_Pass(tmp, src, 9, stride, rounding);
293 :     Ops->V_Pass_Avrg_Up_8( dst, tmp, 16, stride, rounding);
294 :     break;
295 :     case 15:
296 :     Ops->H_Pass_Avrg_Up(tmp, src, 9, stride, rounding);
297 :     Ops->V_Pass_Avrg_Up_8(dst, tmp, 16, stride, rounding);
298 :     break;
299 :     }
300 : Isibaar 1.1.4.1 }
301 :    
302 : edgomez 1.1.4.2 static void __inline
303 :     new_interpolate8x8_quarterpel(uint8_t * const cur,
304 :     uint8_t * const refn,
305 :     uint8_t * const refh,
306 :     uint8_t * const refv,
307 :     uint8_t * const refhv,
308 :     const uint32_t x, const uint32_t y,
309 :     const int32_t dx, const int dy,
310 :     const uint32_t stride,
311 :     const uint32_t rounding)
312 : Isibaar 1.1.4.1 {
313 :     const uint8_t *src;
314 :     uint8_t *dst;
315 :     uint8_t *tmp;
316 :     int32_t quads;
317 :     const XVID_QP_FUNCS *Ops;
318 :    
319 :     int32_t x_int, y_int;
320 :    
321 : edgomez 1.1.4.2 const int32_t xRef = x*4 + dx;
322 :     const int32_t yRef = y*4 + dy;
323 : edgomez 1.1.4.5
324 : edgomez 1.1.4.4 Ops = xvid_QP_Funcs; /* TODO: pass as argument */
325 : edgomez 1.1.4.2 quads = (dx&3) | ((dy&3)<<2);
326 : edgomez 1.1.4.5
327 : edgomez 1.1.4.2 x_int = xRef/4;
328 :     if (xRef < 0 && xRef % 4)
329 :     x_int--;
330 : edgomez 1.1.4.5
331 : edgomez 1.1.4.2 y_int = yRef/4;
332 :     if (yRef < 0 && yRef % 4)
333 :     y_int--;
334 : edgomez 1.1.4.5
335 : edgomez 1.1.4.2 dst = cur + y * stride + x;
336 : Isibaar 1.1.4.1 src = refn + y_int * stride + x_int;
337 :    
338 : edgomez 1.1.4.4 tmp = refh; /* we need at least a 16 x stride scratch block */
339 : Isibaar 1.1.4.1
340 : edgomez 1.1.4.2 switch(quads) {
341 :     case 0:
342 :     transfer8x8_copy( dst, src, stride);
343 :     break;
344 :     case 1:
345 :     Ops->H_Pass_Avrg_8(dst, src, 8, stride, rounding);
346 :     break;
347 :     case 2:
348 :     Ops->H_Pass_8(dst, src, 8, stride, rounding);
349 :     break;
350 :     case 3:
351 :     Ops->H_Pass_Avrg_Up_8(dst, src, 8, stride, rounding);
352 :     break;
353 :     case 4:
354 :     Ops->V_Pass_Avrg_8(dst, src, 8, stride, rounding);
355 :     break;
356 :     case 5:
357 :     Ops->H_Pass_Avrg_8(tmp, src, 9, stride, rounding);
358 :     Ops->V_Pass_Avrg_8(dst, tmp, 8, stride, rounding);
359 :     break;
360 :     case 6:
361 :     Ops->H_Pass_8(tmp, src, 9, stride, rounding);
362 :     Ops->V_Pass_Avrg_8(dst, tmp, 8, stride, rounding);
363 :     break;
364 :     case 7:
365 :     Ops->H_Pass_Avrg_Up_8(tmp, src, 9, stride, rounding);
366 :     Ops->V_Pass_Avrg_8(dst, tmp, 8, stride, rounding);
367 :     break;
368 :     case 8:
369 :     Ops->V_Pass_8(dst, src, 8, stride, rounding);
370 :     break;
371 :     case 9:
372 :     Ops->H_Pass_Avrg_8(tmp, src, 9, stride, rounding);
373 :     Ops->V_Pass_8(dst, tmp, 8, stride, rounding);
374 :     break;
375 :     case 10:
376 :     Ops->H_Pass_8(tmp, src, 9, stride, rounding);
377 :     Ops->V_Pass_8(dst, tmp, 8, stride, rounding);
378 :     break;
379 :     case 11:
380 :     Ops->H_Pass_Avrg_Up_8(tmp, src, 9, stride, rounding);
381 :     Ops->V_Pass_8(dst, tmp, 8, stride, rounding);
382 :     break;
383 :     case 12:
384 :     Ops->V_Pass_Avrg_Up_8(dst, src, 8, stride, rounding);
385 :     break;
386 :     case 13:
387 :     Ops->H_Pass_Avrg_8(tmp, src, 9, stride, rounding);
388 :     Ops->V_Pass_Avrg_Up_8(dst, tmp, 8, stride, rounding);
389 :     break;
390 :     case 14:
391 :     Ops->H_Pass_8(tmp, src, 9, stride, rounding);
392 :     Ops->V_Pass_Avrg_Up_8( dst, tmp, 8, stride, rounding);
393 :     break;
394 :     case 15:
395 :     Ops->H_Pass_Avrg_Up_8(tmp, src, 9, stride, rounding);
396 :     Ops->V_Pass_Avrg_Up_8(dst, tmp, 8, stride, rounding);
397 :     break;
398 :     }
399 : Isibaar 1.1.4.1 }
400 :    
401 :     #endif /* _XVID_QPEL_H_ */

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