Merge commit '21d8f4da91673051ad7055cf63d989488a56368e'
[ffmpeg.git] / libavcodec / alpha / motion_est_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 "dsputil_alpha.h"
23 #include "asm.h"
24
25 void get_pixels_mvi(int16_t *restrict block,
26                     const uint8_t *restrict pixels, int line_size)
27 {
28     int h = 8;
29
30     do {
31         uint64_t p;
32
33         p = ldq(pixels);
34         stq(unpkbw(p),       block);
35         stq(unpkbw(p >> 32), block + 4);
36
37         pixels += line_size;
38         block += 8;
39     } while (--h);
40 }
41
42 void diff_pixels_mvi(int16_t *block, const uint8_t *s1, const uint8_t *s2,
43                      int stride) {
44     int h = 8;
45     uint64_t mask = 0x4040;
46
47     mask |= mask << 16;
48     mask |= mask << 32;
49     do {
50         uint64_t x, y, c, d, a;
51         uint64_t signs;
52
53         x = ldq(s1);
54         y = ldq(s2);
55         c = cmpbge(x, y);
56         d = x - y;
57         a = zap(mask, c);       /* We use 0x4040404040404040 here...  */
58         d += 4 * a;             /* ...so we can use s4addq here.      */
59         signs = zap(-1, c);
60
61         stq(unpkbw(d)       | (unpkbw(signs)       << 8), block);
62         stq(unpkbw(d >> 32) | (unpkbw(signs >> 32) << 8), block + 4);
63
64         s1 += stride;
65         s2 += stride;
66         block += 8;
67     } while (--h);
68 }
69
70 static inline uint64_t avg2(uint64_t a, uint64_t b)
71 {
72     return (a | b) - (((a ^ b) & BYTE_VEC(0xfe)) >> 1);
73 }
74
75 static inline uint64_t avg4(uint64_t l1, uint64_t l2, uint64_t l3, uint64_t l4)
76 {
77     uint64_t r1 = ((l1 & ~BYTE_VEC(0x03)) >> 2)
78                 + ((l2 & ~BYTE_VEC(0x03)) >> 2)
79                 + ((l3 & ~BYTE_VEC(0x03)) >> 2)
80                 + ((l4 & ~BYTE_VEC(0x03)) >> 2);
81     uint64_t r2 = ((  (l1 & BYTE_VEC(0x03))
82                     + (l2 & BYTE_VEC(0x03))
83                     + (l3 & BYTE_VEC(0x03))
84                     + (l4 & BYTE_VEC(0x03))
85                     + BYTE_VEC(0x02)) >> 2) & BYTE_VEC(0x03);
86     return r1 + r2;
87 }
88
89 int pix_abs8x8_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
90 {
91     int result = 0;
92
93     if ((size_t) pix2 & 0x7) {
94         /* works only when pix2 is actually unaligned */
95         do {                    /* do 8 pixel a time */
96             uint64_t p1, p2;
97
98             p1  = ldq(pix1);
99             p2  = uldq(pix2);
100             result += perr(p1, p2);
101
102             pix1 += line_size;
103             pix2 += line_size;
104         } while (--h);
105     } else {
106         do {
107             uint64_t p1, p2;
108
109             p1 = ldq(pix1);
110             p2 = ldq(pix2);
111             result += perr(p1, p2);
112
113             pix1 += line_size;
114             pix2 += line_size;
115         } while (--h);
116     }
117
118     return result;
119 }
120
121 #if 0                           /* now done in assembly */
122 int pix_abs16x16_mvi(uint8_t *pix1, uint8_t *pix2, int line_size)
123 {
124     int result = 0;
125     int h = 16;
126
127     if ((size_t) pix2 & 0x7) {
128         /* works only when pix2 is actually unaligned */
129         do {                    /* do 16 pixel a time */
130             uint64_t p1_l, p1_r, p2_l, p2_r;
131             uint64_t t;
132
133             p1_l  = ldq(pix1);
134             p1_r  = ldq(pix1 + 8);
135             t     = ldq_u(pix2 + 8);
136             p2_l  = extql(ldq_u(pix2), pix2) | extqh(t, pix2);
137             p2_r  = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2);
138             pix1 += line_size;
139             pix2 += line_size;
140
141             result += perr(p1_l, p2_l)
142                     + perr(p1_r, p2_r);
143         } while (--h);
144     } else {
145         do {
146             uint64_t p1_l, p1_r, p2_l, p2_r;
147
148             p1_l = ldq(pix1);
149             p1_r = ldq(pix1 + 8);
150             p2_l = ldq(pix2);
151             p2_r = ldq(pix2 + 8);
152             pix1 += line_size;
153             pix2 += line_size;
154
155             result += perr(p1_l, p2_l)
156                     + perr(p1_r, p2_r);
157         } while (--h);
158     }
159
160     return result;
161 }
162 #endif
163
164 int pix_abs16x16_x2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
165 {
166     int result = 0;
167     uint64_t disalign = (size_t) pix2 & 0x7;
168
169     switch (disalign) {
170     case 0:
171         do {
172             uint64_t p1_l, p1_r, p2_l, p2_r;
173             uint64_t l, r;
174
175             p1_l = ldq(pix1);
176             p1_r = ldq(pix1 + 8);
177             l    = ldq(pix2);
178             r    = ldq(pix2 + 8);
179             p2_l = avg2(l, (l >> 8) | ((uint64_t) r << 56));
180             p2_r = avg2(r, (r >> 8) | ((uint64_t) pix2[16] << 56));
181             pix1 += line_size;
182             pix2 += line_size;
183
184             result += perr(p1_l, p2_l)
185                     + perr(p1_r, p2_r);
186         } while (--h);
187         break;
188     case 7:
189         /* |.......l|lllllllr|rrrrrrr*|
190            This case is special because disalign1 would be 8, which
191            gets treated as 0 by extqh.  At least it is a bit faster
192            that way :)  */
193         do {
194             uint64_t p1_l, p1_r, p2_l, p2_r;
195             uint64_t l, m, r;
196
197             p1_l = ldq(pix1);
198             p1_r = ldq(pix1 + 8);
199             l     = ldq_u(pix2);
200             m     = ldq_u(pix2 + 8);
201             r     = ldq_u(pix2 + 16);
202             p2_l  = avg2(extql(l, disalign) | extqh(m, disalign), m);
203             p2_r  = avg2(extql(m, disalign) | extqh(r, disalign), r);
204             pix1 += line_size;
205             pix2 += line_size;
206
207             result += perr(p1_l, p2_l)
208                     + perr(p1_r, p2_r);
209         } while (--h);
210         break;
211     default:
212         do {
213             uint64_t disalign1 = disalign + 1;
214             uint64_t p1_l, p1_r, p2_l, p2_r;
215             uint64_t l, m, r;
216
217             p1_l  = ldq(pix1);
218             p1_r  = ldq(pix1 + 8);
219             l     = ldq_u(pix2);
220             m     = ldq_u(pix2 + 8);
221             r     = ldq_u(pix2 + 16);
222             p2_l  = avg2(extql(l, disalign) | extqh(m, disalign),
223                          extql(l, disalign1) | extqh(m, disalign1));
224             p2_r  = avg2(extql(m, disalign) | extqh(r, disalign),
225                          extql(m, disalign1) | extqh(r, disalign1));
226             pix1 += line_size;
227             pix2 += line_size;
228
229             result += perr(p1_l, p2_l)
230                     + perr(p1_r, p2_r);
231         } while (--h);
232         break;
233     }
234     return result;
235 }
236
237 int pix_abs16x16_y2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
238 {
239     int result = 0;
240
241     if ((size_t) pix2 & 0x7) {
242         uint64_t t, p2_l, p2_r;
243         t     = ldq_u(pix2 + 8);
244         p2_l  = extql(ldq_u(pix2), pix2) | extqh(t, pix2);
245         p2_r  = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2);
246
247         do {
248             uint64_t p1_l, p1_r, np2_l, np2_r;
249             uint64_t t;
250
251             p1_l  = ldq(pix1);
252             p1_r  = ldq(pix1 + 8);
253             pix2 += line_size;
254             t     = ldq_u(pix2 + 8);
255             np2_l = extql(ldq_u(pix2), pix2) | extqh(t, pix2);
256             np2_r = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2);
257
258             result += perr(p1_l, avg2(p2_l, np2_l))
259                     + perr(p1_r, avg2(p2_r, np2_r));
260
261             pix1 += line_size;
262             p2_l  = np2_l;
263             p2_r  = np2_r;
264
265         } while (--h);
266     } else {
267         uint64_t p2_l, p2_r;
268         p2_l = ldq(pix2);
269         p2_r = ldq(pix2 + 8);
270         do {
271             uint64_t p1_l, p1_r, np2_l, np2_r;
272
273             p1_l = ldq(pix1);
274             p1_r = ldq(pix1 + 8);
275             pix2 += line_size;
276             np2_l = ldq(pix2);
277             np2_r = ldq(pix2 + 8);
278
279             result += perr(p1_l, avg2(p2_l, np2_l))
280                     + perr(p1_r, avg2(p2_r, np2_r));
281
282             pix1 += line_size;
283             p2_l  = np2_l;
284             p2_r  = np2_r;
285         } while (--h);
286     }
287     return result;
288 }
289
290 int pix_abs16x16_xy2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
291 {
292     int result = 0;
293
294     uint64_t p1_l, p1_r;
295     uint64_t p2_l, p2_r, p2_x;
296
297     p1_l = ldq(pix1);
298     p1_r = ldq(pix1 + 8);
299
300     if ((size_t) pix2 & 0x7) { /* could be optimized a lot */
301         p2_l = uldq(pix2);
302         p2_r = uldq(pix2 + 8);
303         p2_x = (uint64_t) pix2[16] << 56;
304     } else {
305         p2_l = ldq(pix2);
306         p2_r = ldq(pix2 + 8);
307         p2_x = ldq(pix2 + 16) << 56;
308     }
309
310     do {
311         uint64_t np1_l, np1_r;
312         uint64_t np2_l, np2_r, np2_x;
313
314         pix1 += line_size;
315         pix2 += line_size;
316
317         np1_l = ldq(pix1);
318         np1_r = ldq(pix1 + 8);
319
320         if ((size_t) pix2 & 0x7) { /* could be optimized a lot */
321             np2_l = uldq(pix2);
322             np2_r = uldq(pix2 + 8);
323             np2_x = (uint64_t) pix2[16] << 56;
324         } else {
325             np2_l = ldq(pix2);
326             np2_r = ldq(pix2 + 8);
327             np2_x = ldq(pix2 + 16) << 56;
328         }
329
330         result += perr(p1_l,
331                        avg4( p2_l, ( p2_l >> 8) | ((uint64_t)  p2_r << 56),
332                             np2_l, (np2_l >> 8) | ((uint64_t) np2_r << 56)))
333                 + perr(p1_r,
334                        avg4( p2_r, ( p2_r >> 8) | ((uint64_t)  p2_x),
335                             np2_r, (np2_r >> 8) | ((uint64_t) np2_x)));
336
337         p1_l = np1_l;
338         p1_r = np1_r;
339         p2_l = np2_l;
340         p2_r = np2_r;
341         p2_x = np2_x;
342     } while (--h);
343
344     return result;
345 }