8f360190f479144ecf26c133ad4769e7824bbaf1
[deb_ffmpeg.git] / me_cmp_alpha.c
1 /*
2 * Alpha optimized DSP utils
3 * Copyright (c) 2002 Falk Hueffner <falk@debian.org>
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include "libavutil/attributes.h"
23 #include "libavcodec/me_cmp.h"
24 #include "asm.h"
25
26 int pix_abs16x16_mvi_asm(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h);
27
28 static inline uint64_t avg2(uint64_t a, uint64_t b)
29 {
30 return (a | b) - (((a ^ b) & BYTE_VEC(0xfe)) >> 1);
31 }
32
33 static inline uint64_t avg4(uint64_t l1, uint64_t l2, uint64_t l3, uint64_t l4)
34 {
35 uint64_t r1 = ((l1 & ~BYTE_VEC(0x03)) >> 2)
36 + ((l2 & ~BYTE_VEC(0x03)) >> 2)
37 + ((l3 & ~BYTE_VEC(0x03)) >> 2)
38 + ((l4 & ~BYTE_VEC(0x03)) >> 2);
39 uint64_t r2 = (( (l1 & BYTE_VEC(0x03))
40 + (l2 & BYTE_VEC(0x03))
41 + (l3 & BYTE_VEC(0x03))
42 + (l4 & BYTE_VEC(0x03))
43 + BYTE_VEC(0x02)) >> 2) & BYTE_VEC(0x03);
44 return r1 + r2;
45 }
46
47 static int pix_abs8x8_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
48 {
49 int result = 0;
50
51 if ((size_t) pix2 & 0x7) {
52 /* works only when pix2 is actually unaligned */
53 do { /* do 8 pixel a time */
54 uint64_t p1, p2;
55
56 p1 = ldq(pix1);
57 p2 = uldq(pix2);
58 result += perr(p1, p2);
59
60 pix1 += line_size;
61 pix2 += line_size;
62 } while (--h);
63 } else {
64 do {
65 uint64_t p1, p2;
66
67 p1 = ldq(pix1);
68 p2 = ldq(pix2);
69 result += perr(p1, p2);
70
71 pix1 += line_size;
72 pix2 += line_size;
73 } while (--h);
74 }
75
76 return result;
77 }
78
79 #if 0 /* now done in assembly */
80 int pix_abs16x16_mvi(uint8_t *pix1, uint8_t *pix2, int line_size)
81 {
82 int result = 0;
83 int h = 16;
84
85 if ((size_t) pix2 & 0x7) {
86 /* works only when pix2 is actually unaligned */
87 do { /* do 16 pixel a time */
88 uint64_t p1_l, p1_r, p2_l, p2_r;
89 uint64_t t;
90
91 p1_l = ldq(pix1);
92 p1_r = ldq(pix1 + 8);
93 t = ldq_u(pix2 + 8);
94 p2_l = extql(ldq_u(pix2), pix2) | extqh(t, pix2);
95 p2_r = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2);
96 pix1 += line_size;
97 pix2 += line_size;
98
99 result += perr(p1_l, p2_l)
100 + perr(p1_r, p2_r);
101 } while (--h);
102 } else {
103 do {
104 uint64_t p1_l, p1_r, p2_l, p2_r;
105
106 p1_l = ldq(pix1);
107 p1_r = ldq(pix1 + 8);
108 p2_l = ldq(pix2);
109 p2_r = ldq(pix2 + 8);
110 pix1 += line_size;
111 pix2 += line_size;
112
113 result += perr(p1_l, p2_l)
114 + perr(p1_r, p2_r);
115 } while (--h);
116 }
117
118 return result;
119 }
120 #endif
121
122 static int pix_abs16x16_x2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
123 {
124 int result = 0;
125 uint64_t disalign = (size_t) pix2 & 0x7;
126
127 switch (disalign) {
128 case 0:
129 do {
130 uint64_t p1_l, p1_r, p2_l, p2_r;
131 uint64_t l, r;
132
133 p1_l = ldq(pix1);
134 p1_r = ldq(pix1 + 8);
135 l = ldq(pix2);
136 r = ldq(pix2 + 8);
137 p2_l = avg2(l, (l >> 8) | ((uint64_t) r << 56));
138 p2_r = avg2(r, (r >> 8) | ((uint64_t) pix2[16] << 56));
139 pix1 += line_size;
140 pix2 += line_size;
141
142 result += perr(p1_l, p2_l)
143 + perr(p1_r, p2_r);
144 } while (--h);
145 break;
146 case 7:
147 /* |.......l|lllllllr|rrrrrrr*|
148 This case is special because disalign1 would be 8, which
149 gets treated as 0 by extqh. At least it is a bit faster
150 that way :) */
151 do {
152 uint64_t p1_l, p1_r, p2_l, p2_r;
153 uint64_t l, m, r;
154
155 p1_l = ldq(pix1);
156 p1_r = ldq(pix1 + 8);
157 l = ldq_u(pix2);
158 m = ldq_u(pix2 + 8);
159 r = ldq_u(pix2 + 16);
160 p2_l = avg2(extql(l, disalign) | extqh(m, disalign), m);
161 p2_r = avg2(extql(m, disalign) | extqh(r, disalign), r);
162 pix1 += line_size;
163 pix2 += line_size;
164
165 result += perr(p1_l, p2_l)
166 + perr(p1_r, p2_r);
167 } while (--h);
168 break;
169 default:
170 do {
171 uint64_t disalign1 = disalign + 1;
172 uint64_t p1_l, p1_r, p2_l, p2_r;
173 uint64_t l, m, r;
174
175 p1_l = ldq(pix1);
176 p1_r = ldq(pix1 + 8);
177 l = ldq_u(pix2);
178 m = ldq_u(pix2 + 8);
179 r = ldq_u(pix2 + 16);
180 p2_l = avg2(extql(l, disalign) | extqh(m, disalign),
181 extql(l, disalign1) | extqh(m, disalign1));
182 p2_r = avg2(extql(m, disalign) | extqh(r, disalign),
183 extql(m, disalign1) | extqh(r, disalign1));
184 pix1 += line_size;
185 pix2 += line_size;
186
187 result += perr(p1_l, p2_l)
188 + perr(p1_r, p2_r);
189 } while (--h);
190 break;
191 }
192 return result;
193 }
194
195 static int pix_abs16x16_y2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
196 {
197 int result = 0;
198
199 if ((size_t) pix2 & 0x7) {
200 uint64_t t, p2_l, p2_r;
201 t = ldq_u(pix2 + 8);
202 p2_l = extql(ldq_u(pix2), pix2) | extqh(t, pix2);
203 p2_r = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2);
204
205 do {
206 uint64_t p1_l, p1_r, np2_l, np2_r;
207 uint64_t t;
208
209 p1_l = ldq(pix1);
210 p1_r = ldq(pix1 + 8);
211 pix2 += line_size;
212 t = ldq_u(pix2 + 8);
213 np2_l = extql(ldq_u(pix2), pix2) | extqh(t, pix2);
214 np2_r = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2);
215
216 result += perr(p1_l, avg2(p2_l, np2_l))
217 + perr(p1_r, avg2(p2_r, np2_r));
218
219 pix1 += line_size;
220 p2_l = np2_l;
221 p2_r = np2_r;
222
223 } while (--h);
224 } else {
225 uint64_t p2_l, p2_r;
226 p2_l = ldq(pix2);
227 p2_r = ldq(pix2 + 8);
228 do {
229 uint64_t p1_l, p1_r, np2_l, np2_r;
230
231 p1_l = ldq(pix1);
232 p1_r = ldq(pix1 + 8);
233 pix2 += line_size;
234 np2_l = ldq(pix2);
235 np2_r = ldq(pix2 + 8);
236
237 result += perr(p1_l, avg2(p2_l, np2_l))
238 + perr(p1_r, avg2(p2_r, np2_r));
239
240 pix1 += line_size;
241 p2_l = np2_l;
242 p2_r = np2_r;
243 } while (--h);
244 }
245 return result;
246 }
247
248 static int pix_abs16x16_xy2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
249 {
250 int result = 0;
251
252 uint64_t p1_l, p1_r;
253 uint64_t p2_l, p2_r, p2_x;
254
255 p1_l = ldq(pix1);
256 p1_r = ldq(pix1 + 8);
257
258 if ((size_t) pix2 & 0x7) { /* could be optimized a lot */
259 p2_l = uldq(pix2);
260 p2_r = uldq(pix2 + 8);
261 p2_x = (uint64_t) pix2[16] << 56;
262 } else {
263 p2_l = ldq(pix2);
264 p2_r = ldq(pix2 + 8);
265 p2_x = ldq(pix2 + 16) << 56;
266 }
267
268 do {
269 uint64_t np1_l, np1_r;
270 uint64_t np2_l, np2_r, np2_x;
271
272 pix1 += line_size;
273 pix2 += line_size;
274
275 np1_l = ldq(pix1);
276 np1_r = ldq(pix1 + 8);
277
278 if ((size_t) pix2 & 0x7) { /* could be optimized a lot */
279 np2_l = uldq(pix2);
280 np2_r = uldq(pix2 + 8);
281 np2_x = (uint64_t) pix2[16] << 56;
282 } else {
283 np2_l = ldq(pix2);
284 np2_r = ldq(pix2 + 8);
285 np2_x = ldq(pix2 + 16) << 56;
286 }
287
288 result += perr(p1_l,
289 avg4( p2_l, ( p2_l >> 8) | ((uint64_t) p2_r << 56),
290 np2_l, (np2_l >> 8) | ((uint64_t) np2_r << 56)))
291 + perr(p1_r,
292 avg4( p2_r, ( p2_r >> 8) | ((uint64_t) p2_x),
293 np2_r, (np2_r >> 8) | ((uint64_t) np2_x)));
294
295 p1_l = np1_l;
296 p1_r = np1_r;
297 p2_l = np2_l;
298 p2_r = np2_r;
299 p2_x = np2_x;
300 } while (--h);
301
302 return result;
303 }
304
305 av_cold void ff_me_cmp_init_alpha(MECmpContext *c, AVCodecContext *avctx)
306 {
307 /* amask clears all bits that correspond to present features. */
308 if (amask(AMASK_MVI) == 0) {
309 c->sad[0] = pix_abs16x16_mvi_asm;
310 c->sad[1] = pix_abs8x8_mvi;
311 c->pix_abs[0][0] = pix_abs16x16_mvi_asm;
312 c->pix_abs[1][0] = pix_abs8x8_mvi;
313 c->pix_abs[0][1] = pix_abs16x16_x2_mvi;
314 c->pix_abs[0][2] = pix_abs16x16_y2_mvi;
315 c->pix_abs[0][3] = pix_abs16x16_xy2_mvi;
316 }
317 }