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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.8 - (view) (download)

1 : chl 1.6 /*****************************************************************************
2 :     *
3 :     * XVID MPEG-4 VIDEO CODEC
4 :     * - 8x8 block-based halfpel interpolation - headers
5 :     *
6 :     * Copyright(C) 2002 Peter Ross <pross@xvid.org>
7 :     *
8 : edgomez 1.7 * This file is part of XviD, a free MPEG-4 video encoder/decoder
9 : chl 1.6 *
10 : edgomez 1.7 * XviD is free software; you can redistribute it and/or modify it
11 :     * under the terms of the GNU General Public License as published by
12 : chl 1.6 * the Free Software Foundation; either version 2 of the License, or
13 :     * (at your option) any later version.
14 :     *
15 :     * This program is distributed in the hope that it will be useful,
16 :     * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 :     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 :     * GNU General Public License for more details.
19 :     *
20 :     * You should have received a copy of the GNU General Public License
21 :     * along with this program; if not, write to the Free Software
22 :     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 : edgomez 1.7 *
24 :     * Under section 8 of the GNU General Public License, the copyright
25 :     * holders of XVID explicitly forbid distribution in the following
26 :     * countries:
27 :     *
28 :     * - Japan
29 :     * - United States of America
30 :     *
31 :     * Linking XviD statically or dynamically with other modules is making a
32 :     * combined work based on XviD. Thus, the terms and conditions of the
33 :     * GNU General Public License cover the whole combination.
34 :     *
35 :     * As a special exception, the copyright holders of XviD give you
36 :     * permission to link XviD with independent modules that communicate with
37 :     * XviD solely through the VFW1.1 and DShow interfaces, regardless of the
38 :     * license terms of these independent modules, and to copy and distribute
39 :     * the resulting combined work under terms of your choice, provided that
40 :     * every copy of the combined work is accompanied by a complete copy of
41 :     * the source code of XviD (the version of XviD used to produce the
42 :     * combined work), being distributed under the terms of the GNU General
43 :     * Public License plus this exception. An independent module is a module
44 :     * which is not derived from or based on XviD.
45 :     *
46 :     * Note that people who make modified versions of XviD are not obligated
47 :     * to grant this special exception for their modified versions; it is
48 :     * their choice whether to do so. The GNU General Public License gives
49 :     * permission to release a modified version without this exception; this
50 :     * exception also makes it possible to release a modified version which
51 :     * carries forward this exception.
52 :     *
53 : edgomez 1.8 * $Id: interpolate8x8.h,v 1.7 2002/11/17 00:20:30 edgomez Exp $
54 : chl 1.6 *
55 :     ****************************************************************************/
56 :    
57 : Isibaar 1.1 #include "../utils/mem_transfer.h"
58 :    
59 : edgomez 1.3 typedef void (INTERPOLATE8X8) (uint8_t * const dst,
60 :     const uint8_t * const src,
61 :     const uint32_t stride,
62 :     const uint32_t rounding);
63 :     typedef INTERPOLATE8X8 *INTERPOLATE8X8_PTR;
64 : Isibaar 1.1
65 :     extern INTERPOLATE8X8_PTR interpolate8x8_halfpel_h;
66 :     extern INTERPOLATE8X8_PTR interpolate8x8_halfpel_v;
67 :     extern INTERPOLATE8X8_PTR interpolate8x8_halfpel_hv;
68 :    
69 :     INTERPOLATE8X8 interpolate8x8_halfpel_h_c;
70 :     INTERPOLATE8X8 interpolate8x8_halfpel_v_c;
71 :     INTERPOLATE8X8 interpolate8x8_halfpel_hv_c;
72 :    
73 :     INTERPOLATE8X8 interpolate8x8_halfpel_h_mmx;
74 :     INTERPOLATE8X8 interpolate8x8_halfpel_v_mmx;
75 :     INTERPOLATE8X8 interpolate8x8_halfpel_hv_mmx;
76 :    
77 :     INTERPOLATE8X8 interpolate8x8_halfpel_h_xmm;
78 :     INTERPOLATE8X8 interpolate8x8_halfpel_v_xmm;
79 :     INTERPOLATE8X8 interpolate8x8_halfpel_hv_xmm;
80 :    
81 :     INTERPOLATE8X8 interpolate8x8_halfpel_h_3dn;
82 :     INTERPOLATE8X8 interpolate8x8_halfpel_v_3dn;
83 :     INTERPOLATE8X8 interpolate8x8_halfpel_hv_3dn;
84 :    
85 : Isibaar 1.4 INTERPOLATE8X8 interpolate8x8_halfpel_h_ia64;
86 :     INTERPOLATE8X8 interpolate8x8_halfpel_v_ia64;
87 :     INTERPOLATE8X8 interpolate8x8_halfpel_hv_ia64;
88 :    
89 : Isibaar 1.5 void interpolate8x8_lowpass_h(uint8_t *dst, uint8_t *src, int32_t dst_stride, int32_t src_stride, int32_t rounding);
90 :     void interpolate8x8_lowpass_v(uint8_t *dst, uint8_t *src, int32_t dst_stride, int32_t src_stride, int32_t rounding);
91 :     void interpolate8x8_lowpass_hv(uint8_t *dst1, uint8_t *dst2, uint8_t *src, int32_t dst1_stride, int32_t dst2_stride, int32_t src_stride, int32_t rounding);
92 :     void interpolate8x8_bilinear2(uint8_t *dst, uint8_t *src1, uint8_t *src2, int32_t dst_stride, int32_t src_stride, int32_t rounding);
93 :     void interpolate8x8_bilinear4(uint8_t *dst, uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4, int32_t stride, int32_t rounding);
94 :    
95 :     void interpolate8x8_c(uint8_t * const dst,
96 :     const uint8_t * const src,
97 :     const uint32_t x,
98 :     const uint32_t y,
99 :     const uint32_t stride);
100 :    
101 : edgomez 1.3 static __inline void
102 :     interpolate8x8_switch(uint8_t * const cur,
103 :     const uint8_t * const refn,
104 :     const uint32_t x,
105 :     const uint32_t y,
106 :     const int32_t dx,
107 :     const int dy,
108 :     const uint32_t stride,
109 :     const uint32_t rounding)
110 : Isibaar 1.1 {
111 :     int32_t ddx, ddy;
112 :    
113 : edgomez 1.8 switch (((dx & 1) << 1) + (dy & 1)) /* ((dx%2)?2:0)+((dy%2)?1:0) */
114 : edgomez 1.3 {
115 :     case 0:
116 :     ddx = dx / 2;
117 :     ddy = dy / 2;
118 :     transfer8x8_copy(cur + y * stride + x,
119 : Isibaar 1.4 refn + (int)((y + ddy) * stride + x + ddx), stride);
120 : Isibaar 1.1 break;
121 :    
122 : edgomez 1.3 case 1:
123 :     ddx = dx / 2;
124 :     ddy = (dy - 1) / 2;
125 :     interpolate8x8_halfpel_v(cur + y * stride + x,
126 : Isibaar 1.4 refn + (int)((y + ddy) * stride + x + ddx), stride,
127 : edgomez 1.3 rounding);
128 : Isibaar 1.1 break;
129 :    
130 : edgomez 1.3 case 2:
131 :     ddx = (dx - 1) / 2;
132 :     ddy = dy / 2;
133 :     interpolate8x8_halfpel_h(cur + y * stride + x,
134 : Isibaar 1.4 refn + (int)((y + ddy) * stride + x + ddx), stride,
135 : edgomez 1.3 rounding);
136 : Isibaar 1.1 break;
137 :    
138 : edgomez 1.3 default:
139 :     ddx = (dx - 1) / 2;
140 :     ddy = (dy - 1) / 2;
141 :     interpolate8x8_halfpel_hv(cur + y * stride + x,
142 : Isibaar 1.4 refn + (int)((y + ddy) * stride + x + ddx), stride,
143 : edgomez 1.3 rounding);
144 : Isibaar 1.1 break;
145 : edgomez 1.3 }
146 : Isibaar 1.1 }
147 : chenm001 1.2
148 :    
149 : Isibaar 1.5 static __inline void interpolate8x8_quarterpel(uint8_t * const cur,
150 :     uint8_t * const refn,
151 :     const uint32_t x, const uint32_t y,
152 :     const int32_t dx, const int dy,
153 :     const uint32_t stride,
154 :     const uint32_t rounding)
155 :     {
156 :     const int32_t xRef = x*4 + dx;
157 :     const int32_t yRef = y*4 + dy;
158 :    
159 :     uint8_t *src, *dst;
160 :     int32_t x_int, y_int, x_frac, y_frac;
161 :    
162 :     uint8_t halfpel_h[72];
163 :     uint8_t halfpel_v[64];
164 :     uint8_t halfpel_hv[64];
165 :    
166 :     x_int = xRef/4;
167 :     if (xRef < 0 && xRef % 4)
168 :     x_int--;
169 :    
170 :     x_frac = xRef - (4*x_int);
171 :    
172 :     y_int = yRef/4;
173 :     if (yRef < 0 && yRef % 4)
174 :     y_int--;
175 :    
176 :     y_frac = yRef - (4*y_int);
177 :    
178 :     src = refn + y_int * stride + x_int;
179 :     dst = cur + y * stride + x;
180 :    
181 :     switch((y_frac << 2) | (x_frac)) {
182 :    
183 :     case 0:
184 :     transfer8x8_copy(dst, src, stride);
185 :     break;
186 :    
187 :     case 1:
188 :     interpolate8x8_lowpass_h(halfpel_h, src, 8, stride, rounding);
189 :     interpolate8x8_bilinear2(dst, src, halfpel_h, stride, stride, rounding);
190 :     break;
191 :    
192 :     case 2:
193 :     interpolate8x8_lowpass_h(dst, src, stride, stride, rounding);
194 :     break;
195 :    
196 :     case 3:
197 :     interpolate8x8_lowpass_h(halfpel_h, src, 8, stride, rounding);
198 :     interpolate8x8_bilinear2(dst, src+1, halfpel_h, stride, stride, rounding);
199 :     break;
200 :    
201 :     case 4:
202 :     interpolate8x8_lowpass_v(halfpel_v, src, 8, stride, rounding);
203 :     interpolate8x8_bilinear2(dst, src, halfpel_v, stride, stride, rounding);
204 :     break;
205 :    
206 :     case 5:
207 :     interpolate8x8_lowpass_v(halfpel_v, src, 8, stride, rounding);
208 :     interpolate8x8_lowpass_hv(halfpel_hv, halfpel_h, src, 8, 8, stride, rounding);
209 :     interpolate8x8_bilinear4(dst, src, halfpel_h, halfpel_v, halfpel_hv, stride, rounding);
210 :     break;
211 :    
212 :     case 6:
213 :     interpolate8x8_lowpass_hv(halfpel_hv, halfpel_h, src, 8, 8, stride, rounding);
214 :     interpolate8x8_bilinear2(dst, halfpel_h, halfpel_hv, stride, 8, 1-rounding);
215 :     break;
216 :    
217 :     case 7:
218 :     interpolate8x8_lowpass_v(halfpel_v, src+1, 8, stride, 16-rounding);
219 :     interpolate8x8_lowpass_hv(halfpel_hv, halfpel_h, src, 8, 8, stride, rounding);
220 :     interpolate8x8_bilinear4(dst, src+1, halfpel_h, halfpel_v, halfpel_hv, stride, rounding);
221 :     break;
222 :    
223 :     case 8:
224 :     interpolate8x8_lowpass_v(dst, src, stride, stride, rounding);
225 :     break;
226 :    
227 :     case 9:
228 :     interpolate8x8_lowpass_v(halfpel_v, src, 8, stride, 16-rounding);
229 :     interpolate8x8_lowpass_hv(halfpel_hv, halfpel_h, src, 8, 8, stride, rounding);
230 :     interpolate8x8_bilinear2(dst, halfpel_v, halfpel_hv, stride, 8, rounding);
231 :     break;
232 :    
233 :     case 10:
234 :     interpolate8x8_lowpass_hv(dst, halfpel_h, src, stride, 8, stride, rounding);
235 :     break;
236 :    
237 :     case 11:
238 :     interpolate8x8_lowpass_v(halfpel_v, src+1, 8, stride, 16-rounding);
239 :     interpolate8x8_lowpass_hv(halfpel_hv, halfpel_h, src, 8, 8, stride, rounding);
240 :     interpolate8x8_bilinear2(dst, halfpel_v, halfpel_hv, stride, 8, rounding);
241 :     break;
242 :    
243 :     case 12:
244 :     interpolate8x8_lowpass_v(halfpel_v, src, 8, stride, rounding);
245 :     interpolate8x8_bilinear2(dst, src+stride, halfpel_v, stride, stride, rounding);
246 :     break;
247 :    
248 :     case 13:
249 :     interpolate8x8_lowpass_v(halfpel_v, src, 8, stride, rounding);
250 :     interpolate8x8_lowpass_hv(halfpel_hv, halfpel_h, src, 8, 8, stride, rounding);
251 :     interpolate8x8_bilinear4(dst, src+stride, halfpel_h+8, halfpel_v, halfpel_hv, stride, rounding);
252 :     break;
253 :    
254 :     case 14:
255 :     interpolate8x8_lowpass_hv(halfpel_hv, halfpel_h, src, 8, 8, stride, rounding);
256 :     interpolate8x8_bilinear2(dst, halfpel_h+8, halfpel_hv, stride, 8, rounding);
257 :     break;
258 :    
259 :     case 15:
260 :     interpolate8x8_lowpass_v(halfpel_v, src+1, 8, stride, rounding);
261 :     interpolate8x8_lowpass_hv(halfpel_hv, halfpel_h, src, 8, 8, stride, rounding);
262 :     interpolate8x8_bilinear4(dst, src+stride+1, halfpel_h+8, halfpel_v, halfpel_hv, stride, rounding);
263 :     break;
264 :     }
265 : chl 1.6 }

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