Mercurial > libavcodec.hg
annotate alpha/motion_est_alpha.c @ 1708:dea5b2946999 libavcodec
interlaced motion estimation
interlaced mpeg2 encoding
P & B frames
rate distored interlaced mb decission
alternate scantable support
4mv encoding fixes (thats also why the regression tests change)
passing height to most dsp functions
interlaced mpeg4 encoding (no direct mode MBs yet)
various related cleanups
disabled old motion estimaton algorithms (log, full, ...) they will either be fixed or removed
author | michael |
---|---|
date | Tue, 30 Dec 2003 16:07:57 +0000 |
parents | 107a56aa74f5 |
children | ef2149182f1c |
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 | |
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
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); | |
33 stq(unpkbw(p >> 32), block + 4); | |
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 | |
705
107a56aa74f5
Add Alpha assembly for pix_abs16x16. Optimized for pca56, no large win
mellum
parents:
586
diff
changeset
|
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 | |
190 that way :) */ | |
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; | |
204 | |
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; | |
291 | |
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 } |