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