Statistics
| Branch: | Revision:

ffmpeg / libavcodec / alpha / motion_est_alpha.c @ 5509bffa

History | View | Annotate | Download (9.55 KB)

1 57d2bce1 Falk Hüffner
/*
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 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 57d2bce1 Falk Hüffner
 */
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 115329f1 Diego Biurrun
        stq(unpkbw(p >> 32), block + 4);
34 57d2bce1 Falk Hüffner
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
87 bb198e19 Michael Niedermayer
int pix_abs8x8_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
88 57d2bce1 Falk Hüffner
{
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
119 bb270c08 Diego Biurrun
#if 0                           /* now done in assembly */
120 57d2bce1 Falk Hüffner
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
}
160 f9bb4bdf Falk Hüffner
#endif
161 57d2bce1 Falk Hüffner
162 bb198e19 Michael Niedermayer
int pix_abs16x16_x2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
163 57d2bce1 Falk Hüffner
{
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 115329f1 Diego Biurrun
           that way :)  */
191 57d2bce1 Falk Hüffner
        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 115329f1 Diego Biurrun
205 57d2bce1 Falk Hüffner
            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
235 bb198e19 Michael Niedermayer
int pix_abs16x16_y2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
236 57d2bce1 Falk Hüffner
{
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
288 bb198e19 Michael Niedermayer
int pix_abs16x16_xy2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
289 57d2bce1 Falk Hüffner
{
290
    int result = 0;
291 115329f1 Diego Biurrun
292 57d2bce1 Falk Hüffner
    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
}