Mercurial > libavcodec.hg
annotate alpha/motion_est_alpha.c @ 3466:af598a3e2340 libavcodec
avoid overflows of qp and pic_type
author | stefang |
---|---|
date | Fri, 14 Jul 2006 18:38:23 +0000 |
parents | 0b546eab515d |
children | c8c591fe26f8 |
rev | line source |
---|---|
586 | 1 /* |
2 * Alpha optimized DSP utils | |
3 * Copyright (c) 2002 Falk Hueffner <falk@debian.org> | |
4 * | |
5 * This library is free software; you can redistribute it and/or | |
6 * modify it under the terms of the GNU Lesser General Public | |
7 * License as published by the Free Software Foundation; either | |
8 * version 2 of the License, or (at your option) any later version. | |
9 * | |
10 * This library is distributed in the hope that it will be useful, | |
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 * Lesser General Public License for more details. | |
14 * | |
15 * You should have received a copy of the GNU Lesser General Public | |
16 * License along with this library; if not, write to the Free Software | |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
586 | 18 */ |
19 | |
20 #include "asm.h" | |
21 #include "../dsputil.h" | |
22 | |
23 void get_pixels_mvi(DCTELEM *restrict block, | |
24 const uint8_t *restrict pixels, int line_size) | |
25 { | |
26 int h = 8; | |
27 | |
28 do { | |
29 uint64_t p; | |
30 | |
31 p = ldq(pixels); | |
32 stq(unpkbw(p), block); | |
2967 | 33 stq(unpkbw(p >> 32), block + 4); |
586 | 34 |
35 pixels += line_size; | |
36 block += 8; | |
37 } while (--h); | |
38 } | |
39 | |
40 void diff_pixels_mvi(DCTELEM *block, const uint8_t *s1, const uint8_t *s2, | |
41 int stride) { | |
42 int h = 8; | |
43 uint64_t mask = 0x4040; | |
44 | |
45 mask |= mask << 16; | |
46 mask |= mask << 32; | |
47 do { | |
48 uint64_t x, y, c, d, a; | |
49 uint64_t signs; | |
50 | |
51 x = ldq(s1); | |
52 y = ldq(s2); | |
53 c = cmpbge(x, y); | |
54 d = x - y; | |
55 a = zap(mask, c); /* We use 0x4040404040404040 here... */ | |
56 d += 4 * a; /* ...so we can use s4addq here. */ | |
57 signs = zap(-1, c); | |
58 | |
59 stq(unpkbw(d) | (unpkbw(signs) << 8), block); | |
60 stq(unpkbw(d >> 32) | (unpkbw(signs >> 32) << 8), block + 4); | |
61 | |
62 s1 += stride; | |
63 s2 += stride; | |
64 block += 8; | |
65 } while (--h); | |
66 } | |
67 | |
68 static inline uint64_t avg2(uint64_t a, uint64_t b) | |
69 { | |
70 return (a | b) - (((a ^ b) & BYTE_VEC(0xfe)) >> 1); | |
71 } | |
72 | |
73 static inline uint64_t avg4(uint64_t l1, uint64_t l2, uint64_t l3, uint64_t l4) | |
74 { | |
75 uint64_t r1 = ((l1 & ~BYTE_VEC(0x03)) >> 2) | |
76 + ((l2 & ~BYTE_VEC(0x03)) >> 2) | |
77 + ((l3 & ~BYTE_VEC(0x03)) >> 2) | |
78 + ((l4 & ~BYTE_VEC(0x03)) >> 2); | |
79 uint64_t r2 = (( (l1 & BYTE_VEC(0x03)) | |
80 + (l2 & BYTE_VEC(0x03)) | |
81 + (l3 & BYTE_VEC(0x03)) | |
82 + (l4 & BYTE_VEC(0x03)) | |
83 + BYTE_VEC(0x02)) >> 2) & BYTE_VEC(0x03); | |
84 return r1 + r2; | |
85 } | |
86 | |
1708 | 87 int pix_abs8x8_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h) |
586 | 88 { |
89 int result = 0; | |
90 | |
91 if ((size_t) pix2 & 0x7) { | |
92 /* works only when pix2 is actually unaligned */ | |
93 do { /* do 8 pixel a time */ | |
94 uint64_t p1, p2; | |
95 | |
96 p1 = ldq(pix1); | |
97 p2 = uldq(pix2); | |
98 result += perr(p1, p2); | |
99 | |
100 pix1 += line_size; | |
101 pix2 += line_size; | |
102 } while (--h); | |
103 } else { | |
104 do { | |
105 uint64_t p1, p2; | |
106 | |
107 p1 = ldq(pix1); | |
108 p2 = ldq(pix2); | |
109 result += perr(p1, p2); | |
110 | |
111 pix1 += line_size; | |
112 pix2 += line_size; | |
113 } while (--h); | |
114 } | |
115 | |
116 return result; | |
117 } | |
118 | |
2979 | 119 #if 0 /* now done in assembly */ |
586 | 120 int pix_abs16x16_mvi(uint8_t *pix1, uint8_t *pix2, int line_size) |
121 { | |
122 int result = 0; | |
123 int h = 16; | |
124 | |
125 if ((size_t) pix2 & 0x7) { | |
126 /* works only when pix2 is actually unaligned */ | |
127 do { /* do 16 pixel a time */ | |
128 uint64_t p1_l, p1_r, p2_l, p2_r; | |
129 uint64_t t; | |
130 | |
131 p1_l = ldq(pix1); | |
132 p1_r = ldq(pix1 + 8); | |
133 t = ldq_u(pix2 + 8); | |
134 p2_l = extql(ldq_u(pix2), pix2) | extqh(t, pix2); | |
135 p2_r = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2); | |
136 pix1 += line_size; | |
137 pix2 += line_size; | |
138 | |
139 result += perr(p1_l, p2_l) | |
140 + perr(p1_r, p2_r); | |
141 } while (--h); | |
142 } else { | |
143 do { | |
144 uint64_t p1_l, p1_r, p2_l, p2_r; | |
145 | |
146 p1_l = ldq(pix1); | |
147 p1_r = ldq(pix1 + 8); | |
148 p2_l = ldq(pix2); | |
149 p2_r = ldq(pix2 + 8); | |
150 pix1 += line_size; | |
151 pix2 += line_size; | |
152 | |
153 result += perr(p1_l, p2_l) | |
154 + perr(p1_r, p2_r); | |
155 } while (--h); | |
156 } | |
157 | |
158 return result; | |
159 } | |
705
107a56aa74f5
Add Alpha assembly for pix_abs16x16. Optimized for pca56, no large win
mellum
parents:
586
diff
changeset
|
160 #endif |
586 | 161 |
1708 | 162 int pix_abs16x16_x2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h) |
586 | 163 { |
164 int result = 0; | |
165 uint64_t disalign = (size_t) pix2 & 0x7; | |
166 | |
167 switch (disalign) { | |
168 case 0: | |
169 do { | |
170 uint64_t p1_l, p1_r, p2_l, p2_r; | |
171 uint64_t l, r; | |
172 | |
173 p1_l = ldq(pix1); | |
174 p1_r = ldq(pix1 + 8); | |
175 l = ldq(pix2); | |
176 r = ldq(pix2 + 8); | |
177 p2_l = avg2(l, (l >> 8) | ((uint64_t) r << 56)); | |
178 p2_r = avg2(r, (r >> 8) | ((uint64_t) pix2[16] << 56)); | |
179 pix1 += line_size; | |
180 pix2 += line_size; | |
181 | |
182 result += perr(p1_l, p2_l) | |
183 + perr(p1_r, p2_r); | |
184 } while (--h); | |
185 break; | |
186 case 7: | |
187 /* |.......l|lllllllr|rrrrrrr*| | |
188 This case is special because disalign1 would be 8, which | |
189 gets treated as 0 by extqh. At least it is a bit faster | |
2967 | 190 that way :) */ |
586 | 191 do { |
192 uint64_t p1_l, p1_r, p2_l, p2_r; | |
193 uint64_t l, m, r; | |
194 | |
195 p1_l = ldq(pix1); | |
196 p1_r = ldq(pix1 + 8); | |
197 l = ldq_u(pix2); | |
198 m = ldq_u(pix2 + 8); | |
199 r = ldq_u(pix2 + 16); | |
200 p2_l = avg2(extql(l, disalign) | extqh(m, disalign), m); | |
201 p2_r = avg2(extql(m, disalign) | extqh(r, disalign), r); | |
202 pix1 += line_size; | |
203 pix2 += line_size; | |
2967 | 204 |
586 | 205 result += perr(p1_l, p2_l) |
206 + perr(p1_r, p2_r); | |
207 } while (--h); | |
208 break; | |
209 default: | |
210 do { | |
211 uint64_t disalign1 = disalign + 1; | |
212 uint64_t p1_l, p1_r, p2_l, p2_r; | |
213 uint64_t l, m, r; | |
214 | |
215 p1_l = ldq(pix1); | |
216 p1_r = ldq(pix1 + 8); | |
217 l = ldq_u(pix2); | |
218 m = ldq_u(pix2 + 8); | |
219 r = ldq_u(pix2 + 16); | |
220 p2_l = avg2(extql(l, disalign) | extqh(m, disalign), | |
221 extql(l, disalign1) | extqh(m, disalign1)); | |
222 p2_r = avg2(extql(m, disalign) | extqh(r, disalign), | |
223 extql(m, disalign1) | extqh(r, disalign1)); | |
224 pix1 += line_size; | |
225 pix2 += line_size; | |
226 | |
227 result += perr(p1_l, p2_l) | |
228 + perr(p1_r, p2_r); | |
229 } while (--h); | |
230 break; | |
231 } | |
232 return result; | |
233 } | |
234 | |
1708 | 235 int pix_abs16x16_y2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h) |
586 | 236 { |
237 int result = 0; | |
238 | |
239 if ((size_t) pix2 & 0x7) { | |
240 uint64_t t, p2_l, p2_r; | |
241 t = ldq_u(pix2 + 8); | |
242 p2_l = extql(ldq_u(pix2), pix2) | extqh(t, pix2); | |
243 p2_r = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2); | |
244 | |
245 do { | |
246 uint64_t p1_l, p1_r, np2_l, np2_r; | |
247 uint64_t t; | |
248 | |
249 p1_l = ldq(pix1); | |
250 p1_r = ldq(pix1 + 8); | |
251 pix2 += line_size; | |
252 t = ldq_u(pix2 + 8); | |
253 np2_l = extql(ldq_u(pix2), pix2) | extqh(t, pix2); | |
254 np2_r = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2); | |
255 | |
256 result += perr(p1_l, avg2(p2_l, np2_l)) | |
257 + perr(p1_r, avg2(p2_r, np2_r)); | |
258 | |
259 pix1 += line_size; | |
260 p2_l = np2_l; | |
261 p2_r = np2_r; | |
262 | |
263 } while (--h); | |
264 } else { | |
265 uint64_t p2_l, p2_r; | |
266 p2_l = ldq(pix2); | |
267 p2_r = ldq(pix2 + 8); | |
268 do { | |
269 uint64_t p1_l, p1_r, np2_l, np2_r; | |
270 | |
271 p1_l = ldq(pix1); | |
272 p1_r = ldq(pix1 + 8); | |
273 pix2 += line_size; | |
274 np2_l = ldq(pix2); | |
275 np2_r = ldq(pix2 + 8); | |
276 | |
277 result += perr(p1_l, avg2(p2_l, np2_l)) | |
278 + perr(p1_r, avg2(p2_r, np2_r)); | |
279 | |
280 pix1 += line_size; | |
281 p2_l = np2_l; | |
282 p2_r = np2_r; | |
283 } while (--h); | |
284 } | |
285 return result; | |
286 } | |
287 | |
1708 | 288 int pix_abs16x16_xy2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h) |
586 | 289 { |
290 int result = 0; | |
2967 | 291 |
586 | 292 uint64_t p1_l, p1_r; |
293 uint64_t p2_l, p2_r, p2_x; | |
294 | |
295 p1_l = ldq(pix1); | |
296 p1_r = ldq(pix1 + 8); | |
297 | |
298 if ((size_t) pix2 & 0x7) { /* could be optimized a lot */ | |
299 p2_l = uldq(pix2); | |
300 p2_r = uldq(pix2 + 8); | |
301 p2_x = (uint64_t) pix2[16] << 56; | |
302 } else { | |
303 p2_l = ldq(pix2); | |
304 p2_r = ldq(pix2 + 8); | |
305 p2_x = ldq(pix2 + 16) << 56; | |
306 } | |
307 | |
308 do { | |
309 uint64_t np1_l, np1_r; | |
310 uint64_t np2_l, np2_r, np2_x; | |
311 | |
312 pix1 += line_size; | |
313 pix2 += line_size; | |
314 | |
315 np1_l = ldq(pix1); | |
316 np1_r = ldq(pix1 + 8); | |
317 | |
318 if ((size_t) pix2 & 0x7) { /* could be optimized a lot */ | |
319 np2_l = uldq(pix2); | |
320 np2_r = uldq(pix2 + 8); | |
321 np2_x = (uint64_t) pix2[16] << 56; | |
322 } else { | |
323 np2_l = ldq(pix2); | |
324 np2_r = ldq(pix2 + 8); | |
325 np2_x = ldq(pix2 + 16) << 56; | |
326 } | |
327 | |
328 result += perr(p1_l, | |
329 avg4( p2_l, ( p2_l >> 8) | ((uint64_t) p2_r << 56), | |
330 np2_l, (np2_l >> 8) | ((uint64_t) np2_r << 56))) | |
331 + perr(p1_r, | |
332 avg4( p2_r, ( p2_r >> 8) | ((uint64_t) p2_x), | |
333 np2_r, (np2_r >> 8) | ((uint64_t) np2_x))); | |
334 | |
335 p1_l = np1_l; | |
336 p1_r = np1_r; | |
337 p2_l = np2_l; | |
338 p2_r = np2_r; | |
339 p2_x = np2_x; | |
340 } while (--h); | |
341 | |
342 return result; | |
343 } |