dsputil: Split off HuffYUV decoding bits into their own context
[ffmpeg.git] / libavcodec / x86 / dsputil_mmx.c
1 /*
2  * MMX optimized DSP utils
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
7  *
8  * This file is part of Libav.
9  *
10  * Libav is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * Libav is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 #include "config.h"
26 #include "libavutil/cpu.h"
27 #include "libavutil/x86/asm.h"
28 #include "constants.h"
29 #include "dsputil_x86.h"
30 #include "inline_asm.h"
31
32 #if HAVE_INLINE_ASM
33
34 void ff_put_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
35                                int line_size)
36 {
37     const int16_t *p;
38     uint8_t *pix;
39
40     /* read the pixels */
41     p   = block;
42     pix = pixels;
43     /* unrolled loop */
44     __asm__ volatile (
45         "movq      (%3), %%mm0          \n\t"
46         "movq     8(%3), %%mm1          \n\t"
47         "movq    16(%3), %%mm2          \n\t"
48         "movq    24(%3), %%mm3          \n\t"
49         "movq    32(%3), %%mm4          \n\t"
50         "movq    40(%3), %%mm5          \n\t"
51         "movq    48(%3), %%mm6          \n\t"
52         "movq    56(%3), %%mm7          \n\t"
53         "packuswb %%mm1, %%mm0          \n\t"
54         "packuswb %%mm3, %%mm2          \n\t"
55         "packuswb %%mm5, %%mm4          \n\t"
56         "packuswb %%mm7, %%mm6          \n\t"
57         "movq     %%mm0, (%0)           \n\t"
58         "movq     %%mm2, (%0, %1)       \n\t"
59         "movq     %%mm4, (%0, %1, 2)    \n\t"
60         "movq     %%mm6, (%0, %2)       \n\t"
61         :: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),
62            "r" (p)
63         : "memory");
64     pix += line_size * 4;
65     p   += 32;
66
67     // if here would be an exact copy of the code above
68     // compiler would generate some very strange code
69     // thus using "r"
70     __asm__ volatile (
71         "movq       (%3), %%mm0         \n\t"
72         "movq      8(%3), %%mm1         \n\t"
73         "movq     16(%3), %%mm2         \n\t"
74         "movq     24(%3), %%mm3         \n\t"
75         "movq     32(%3), %%mm4         \n\t"
76         "movq     40(%3), %%mm5         \n\t"
77         "movq     48(%3), %%mm6         \n\t"
78         "movq     56(%3), %%mm7         \n\t"
79         "packuswb  %%mm1, %%mm0         \n\t"
80         "packuswb  %%mm3, %%mm2         \n\t"
81         "packuswb  %%mm5, %%mm4         \n\t"
82         "packuswb  %%mm7, %%mm6         \n\t"
83         "movq      %%mm0, (%0)          \n\t"
84         "movq      %%mm2, (%0, %1)      \n\t"
85         "movq      %%mm4, (%0, %1, 2)   \n\t"
86         "movq      %%mm6, (%0, %2)      \n\t"
87         :: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),
88            "r" (p)
89         : "memory");
90 }
91
92 #define put_signed_pixels_clamped_mmx_half(off)             \
93     "movq          "#off"(%2), %%mm1        \n\t"           \
94     "movq     16 + "#off"(%2), %%mm2        \n\t"           \
95     "movq     32 + "#off"(%2), %%mm3        \n\t"           \
96     "movq     48 + "#off"(%2), %%mm4        \n\t"           \
97     "packsswb  8 + "#off"(%2), %%mm1        \n\t"           \
98     "packsswb 24 + "#off"(%2), %%mm2        \n\t"           \
99     "packsswb 40 + "#off"(%2), %%mm3        \n\t"           \
100     "packsswb 56 + "#off"(%2), %%mm4        \n\t"           \
101     "paddb              %%mm0, %%mm1        \n\t"           \
102     "paddb              %%mm0, %%mm2        \n\t"           \
103     "paddb              %%mm0, %%mm3        \n\t"           \
104     "paddb              %%mm0, %%mm4        \n\t"           \
105     "movq               %%mm1, (%0)         \n\t"           \
106     "movq               %%mm2, (%0, %3)     \n\t"           \
107     "movq               %%mm3, (%0, %3, 2)  \n\t"           \
108     "movq               %%mm4, (%0, %1)     \n\t"
109
110 void ff_put_signed_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
111                                       int line_size)
112 {
113     x86_reg line_skip = line_size;
114     x86_reg line_skip3;
115
116     __asm__ volatile (
117         "movq "MANGLE(ff_pb_80)", %%mm0     \n\t"
118         "lea         (%3, %3, 2), %1        \n\t"
119         put_signed_pixels_clamped_mmx_half(0)
120         "lea         (%0, %3, 4), %0        \n\t"
121         put_signed_pixels_clamped_mmx_half(64)
122         : "+&r" (pixels), "=&r" (line_skip3)
123         : "r" (block), "r" (line_skip)
124         : "memory");
125 }
126
127 void ff_add_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
128                                int line_size)
129 {
130     const int16_t *p;
131     uint8_t *pix;
132     int i;
133
134     /* read the pixels */
135     p   = block;
136     pix = pixels;
137     MOVQ_ZERO(mm7);
138     i = 4;
139     do {
140         __asm__ volatile (
141             "movq        (%2), %%mm0    \n\t"
142             "movq       8(%2), %%mm1    \n\t"
143             "movq      16(%2), %%mm2    \n\t"
144             "movq      24(%2), %%mm3    \n\t"
145             "movq          %0, %%mm4    \n\t"
146             "movq          %1, %%mm6    \n\t"
147             "movq       %%mm4, %%mm5    \n\t"
148             "punpcklbw  %%mm7, %%mm4    \n\t"
149             "punpckhbw  %%mm7, %%mm5    \n\t"
150             "paddsw     %%mm4, %%mm0    \n\t"
151             "paddsw     %%mm5, %%mm1    \n\t"
152             "movq       %%mm6, %%mm5    \n\t"
153             "punpcklbw  %%mm7, %%mm6    \n\t"
154             "punpckhbw  %%mm7, %%mm5    \n\t"
155             "paddsw     %%mm6, %%mm2    \n\t"
156             "paddsw     %%mm5, %%mm3    \n\t"
157             "packuswb   %%mm1, %%mm0    \n\t"
158             "packuswb   %%mm3, %%mm2    \n\t"
159             "movq       %%mm0, %0       \n\t"
160             "movq       %%mm2, %1       \n\t"
161             : "+m" (*pix), "+m" (*(pix + line_size))
162             : "r" (p)
163             : "memory");
164         pix += line_size * 2;
165         p   += 16;
166     } while (--i);
167 }
168
169 #define CLEAR_BLOCKS(name, n)                           \
170 void name(int16_t *blocks)                              \
171 {                                                       \
172     __asm__ volatile (                                  \
173         "pxor %%mm7, %%mm7              \n\t"           \
174         "mov     %1,        %%"REG_a"   \n\t"           \
175         "1:                             \n\t"           \
176         "movq %%mm7,   (%0, %%"REG_a")  \n\t"           \
177         "movq %%mm7,  8(%0, %%"REG_a")  \n\t"           \
178         "movq %%mm7, 16(%0, %%"REG_a")  \n\t"           \
179         "movq %%mm7, 24(%0, %%"REG_a")  \n\t"           \
180         "add    $32, %%"REG_a"          \n\t"           \
181         "js      1b                     \n\t"           \
182         :: "r"(((uint8_t *) blocks) + 128 * n),         \
183            "i"(-128 * n)                                \
184         : "%"REG_a);                                    \
185 }
186 CLEAR_BLOCKS(ff_clear_blocks_mmx, 6)
187 CLEAR_BLOCKS(ff_clear_block_mmx, 1)
188
189 void ff_clear_block_sse(int16_t *block)
190 {
191     __asm__ volatile (
192         "xorps  %%xmm0, %%xmm0          \n"
193         "movaps %%xmm0,    (%0)         \n"
194         "movaps %%xmm0,  16(%0)         \n"
195         "movaps %%xmm0,  32(%0)         \n"
196         "movaps %%xmm0,  48(%0)         \n"
197         "movaps %%xmm0,  64(%0)         \n"
198         "movaps %%xmm0,  80(%0)         \n"
199         "movaps %%xmm0,  96(%0)         \n"
200         "movaps %%xmm0, 112(%0)         \n"
201         :: "r" (block)
202         : "memory");
203 }
204
205 void ff_clear_blocks_sse(int16_t *blocks)
206 {
207     __asm__ volatile (
208         "xorps  %%xmm0, %%xmm0              \n"
209         "mov        %1,         %%"REG_a"   \n"
210         "1:                                 \n"
211         "movaps %%xmm0,    (%0, %%"REG_a")  \n"
212         "movaps %%xmm0,  16(%0, %%"REG_a")  \n"
213         "movaps %%xmm0,  32(%0, %%"REG_a")  \n"
214         "movaps %%xmm0,  48(%0, %%"REG_a")  \n"
215         "movaps %%xmm0,  64(%0, %%"REG_a")  \n"
216         "movaps %%xmm0,  80(%0, %%"REG_a")  \n"
217         "movaps %%xmm0,  96(%0, %%"REG_a")  \n"
218         "movaps %%xmm0, 112(%0, %%"REG_a")  \n"
219         "add      $128,         %%"REG_a"   \n"
220         "js         1b                      \n"
221         :: "r"(((uint8_t *) blocks) + 128 * 6), "i"(-128 * 6)
222         : "%"REG_a);
223 }
224
225 /* Draw the edges of width 'w' of an image of size width, height
226  * this MMX version can only handle w == 8 || w == 16. */
227 void ff_draw_edges_mmx(uint8_t *buf, int wrap, int width, int height,
228                        int w, int h, int sides)
229 {
230     uint8_t *ptr, *last_line;
231     int i;
232
233     last_line = buf + (height - 1) * wrap;
234     /* left and right */
235     ptr = buf;
236     if (w == 8) {
237         __asm__ volatile (
238             "1:                             \n\t"
239             "movd            (%0), %%mm0    \n\t"
240             "punpcklbw      %%mm0, %%mm0    \n\t"
241             "punpcklwd      %%mm0, %%mm0    \n\t"
242             "punpckldq      %%mm0, %%mm0    \n\t"
243             "movq           %%mm0, -8(%0)   \n\t"
244             "movq      -8(%0, %2), %%mm1    \n\t"
245             "punpckhbw      %%mm1, %%mm1    \n\t"
246             "punpckhwd      %%mm1, %%mm1    \n\t"
247             "punpckhdq      %%mm1, %%mm1    \n\t"
248             "movq           %%mm1, (%0, %2) \n\t"
249             "add               %1, %0       \n\t"
250             "cmp               %3, %0       \n\t"
251             "jb                1b           \n\t"
252             : "+r" (ptr)
253             : "r" ((x86_reg) wrap), "r" ((x86_reg) width),
254               "r" (ptr + wrap * height));
255     } else {
256         __asm__ volatile (
257             "1:                                 \n\t"
258             "movd            (%0), %%mm0        \n\t"
259             "punpcklbw      %%mm0, %%mm0        \n\t"
260             "punpcklwd      %%mm0, %%mm0        \n\t"
261             "punpckldq      %%mm0, %%mm0        \n\t"
262             "movq           %%mm0, -8(%0)       \n\t"
263             "movq           %%mm0, -16(%0)      \n\t"
264             "movq      -8(%0, %2), %%mm1        \n\t"
265             "punpckhbw      %%mm1, %%mm1        \n\t"
266             "punpckhwd      %%mm1, %%mm1        \n\t"
267             "punpckhdq      %%mm1, %%mm1        \n\t"
268             "movq           %%mm1,  (%0, %2)    \n\t"
269             "movq           %%mm1, 8(%0, %2)    \n\t"
270             "add               %1, %0           \n\t"
271             "cmp               %3, %0           \n\t"
272             "jb                1b               \n\t"
273             : "+r" (ptr)
274             : "r" ((x86_reg) wrap), "r" ((x86_reg) width),
275               "r" (ptr + wrap * height));
276     }
277
278     /* top and bottom (and hopefully also the corners) */
279     if (sides & EDGE_TOP) {
280         for (i = 0; i < h; i += 4) {
281             ptr = buf - (i + 1) * wrap - w;
282             __asm__ volatile (
283                 "1:                             \n\t"
284                 "movq (%1, %0), %%mm0           \n\t"
285                 "movq    %%mm0, (%0)            \n\t"
286                 "movq    %%mm0, (%0, %2)        \n\t"
287                 "movq    %%mm0, (%0, %2, 2)     \n\t"
288                 "movq    %%mm0, (%0, %3)        \n\t"
289                 "add        $8, %0              \n\t"
290                 "cmp        %4, %0              \n\t"
291                 "jb         1b                  \n\t"
292                 : "+r" (ptr)
293                 : "r" ((x86_reg) buf - (x86_reg) ptr - w),
294                   "r" ((x86_reg) - wrap), "r" ((x86_reg) - wrap * 3),
295                   "r" (ptr + width + 2 * w));
296         }
297     }
298
299     if (sides & EDGE_BOTTOM) {
300         for (i = 0; i < h; i += 4) {
301             ptr = last_line + (i + 1) * wrap - w;
302             __asm__ volatile (
303                 "1:                             \n\t"
304                 "movq (%1, %0), %%mm0           \n\t"
305                 "movq    %%mm0, (%0)            \n\t"
306                 "movq    %%mm0, (%0, %2)        \n\t"
307                 "movq    %%mm0, (%0, %2, 2)     \n\t"
308                 "movq    %%mm0, (%0, %3)        \n\t"
309                 "add        $8, %0              \n\t"
310                 "cmp        %4, %0              \n\t"
311                 "jb         1b                  \n\t"
312                 : "+r" (ptr)
313                 : "r" ((x86_reg) last_line - (x86_reg) ptr - w),
314                   "r" ((x86_reg) wrap), "r" ((x86_reg) wrap * 3),
315                   "r" (ptr + width + 2 * w));
316         }
317     }
318 }
319
320 void ff_gmc_mmx(uint8_t *dst, uint8_t *src,
321                 int stride, int h, int ox, int oy,
322                 int dxx, int dxy, int dyx, int dyy,
323                 int shift, int r, int width, int height)
324 {
325     const int w    = 8;
326     const int ix   = ox  >> (16 + shift);
327     const int iy   = oy  >> (16 + shift);
328     const int oxs  = ox  >> 4;
329     const int oys  = oy  >> 4;
330     const int dxxs = dxx >> 4;
331     const int dxys = dxy >> 4;
332     const int dyxs = dyx >> 4;
333     const int dyys = dyy >> 4;
334     const uint16_t r4[4]   = { r, r, r, r };
335     const uint16_t dxy4[4] = { dxys, dxys, dxys, dxys };
336     const uint16_t dyy4[4] = { dyys, dyys, dyys, dyys };
337     const uint64_t shift2  = 2 * shift;
338     int x, y;
339
340     const int dxw = (dxx - (1 << (16 + shift))) * (w - 1);
341     const int dyh = (dyy - (1 << (16 + shift))) * (h - 1);
342     const int dxh = dxy * (h - 1);
343     const int dyw = dyx * (w - 1);
344
345     if ( // non-constant fullpel offset (3% of blocks)
346         ((ox ^ (ox + dxw)) | (ox ^ (ox + dxh)) | (ox ^ (ox + dxw + dxh)) |
347          (oy ^ (oy + dyw)) | (oy ^ (oy + dyh)) | (oy ^ (oy + dyw + dyh))) >> (16 + shift) ||
348         // uses more than 16 bits of subpel mv (only at huge resolution)
349         (dxx | dxy | dyx | dyy) & 15 ||
350         (unsigned) ix >= width  - w ||
351         (unsigned) iy >= height - h) {
352         // FIXME could still use mmx for some of the rows
353         ff_gmc_c(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy,
354                  shift, r, width, height);
355         return;
356     }
357
358     src += ix + iy * stride;
359
360     __asm__ volatile (
361         "movd         %0, %%mm6         \n\t"
362         "pxor      %%mm7, %%mm7         \n\t"
363         "punpcklwd %%mm6, %%mm6         \n\t"
364         "punpcklwd %%mm6, %%mm6         \n\t"
365         :: "r" (1 << shift));
366
367     for (x = 0; x < w; x += 4) {
368         uint16_t dx4[4] = { oxs - dxys + dxxs * (x + 0),
369                             oxs - dxys + dxxs * (x + 1),
370                             oxs - dxys + dxxs * (x + 2),
371                             oxs - dxys + dxxs * (x + 3) };
372         uint16_t dy4[4] = { oys - dyys + dyxs * (x + 0),
373                             oys - dyys + dyxs * (x + 1),
374                             oys - dyys + dyxs * (x + 2),
375                             oys - dyys + dyxs * (x + 3) };
376
377         for (y = 0; y < h; y++) {
378             __asm__ volatile (
379                 "movq      %0, %%mm4    \n\t"
380                 "movq      %1, %%mm5    \n\t"
381                 "paddw     %2, %%mm4    \n\t"
382                 "paddw     %3, %%mm5    \n\t"
383                 "movq   %%mm4, %0       \n\t"
384                 "movq   %%mm5, %1       \n\t"
385                 "psrlw    $12, %%mm4    \n\t"
386                 "psrlw    $12, %%mm5    \n\t"
387                 : "+m" (*dx4), "+m" (*dy4)
388                 : "m" (*dxy4), "m" (*dyy4));
389
390             __asm__ volatile (
391                 "movq      %%mm6, %%mm2 \n\t"
392                 "movq      %%mm6, %%mm1 \n\t"
393                 "psubw     %%mm4, %%mm2 \n\t"
394                 "psubw     %%mm5, %%mm1 \n\t"
395                 "movq      %%mm2, %%mm0 \n\t"
396                 "movq      %%mm4, %%mm3 \n\t"
397                 "pmullw    %%mm1, %%mm0 \n\t" // (s - dx) * (s - dy)
398                 "pmullw    %%mm5, %%mm3 \n\t" // dx * dy
399                 "pmullw    %%mm5, %%mm2 \n\t" // (s - dx) * dy
400                 "pmullw    %%mm4, %%mm1 \n\t" // dx * (s - dy)
401
402                 "movd         %4, %%mm5 \n\t"
403                 "movd         %3, %%mm4 \n\t"
404                 "punpcklbw %%mm7, %%mm5 \n\t"
405                 "punpcklbw %%mm7, %%mm4 \n\t"
406                 "pmullw    %%mm5, %%mm3 \n\t" // src[1, 1] * dx * dy
407                 "pmullw    %%mm4, %%mm2 \n\t" // src[0, 1] * (s - dx) * dy
408
409                 "movd         %2, %%mm5 \n\t"
410                 "movd         %1, %%mm4 \n\t"
411                 "punpcklbw %%mm7, %%mm5 \n\t"
412                 "punpcklbw %%mm7, %%mm4 \n\t"
413                 "pmullw    %%mm5, %%mm1 \n\t" // src[1, 0] * dx * (s - dy)
414                 "pmullw    %%mm4, %%mm0 \n\t" // src[0, 0] * (s - dx) * (s - dy)
415                 "paddw        %5, %%mm1 \n\t"
416                 "paddw     %%mm3, %%mm2 \n\t"
417                 "paddw     %%mm1, %%mm0 \n\t"
418                 "paddw     %%mm2, %%mm0 \n\t"
419
420                 "psrlw        %6, %%mm0 \n\t"
421                 "packuswb  %%mm0, %%mm0 \n\t"
422                 "movd      %%mm0, %0    \n\t"
423
424                 : "=m" (dst[x + y * stride])
425                 : "m" (src[0]), "m" (src[1]),
426                   "m" (src[stride]), "m" (src[stride + 1]),
427                   "m" (*r4), "m" (shift2));
428             src += stride;
429         }
430         src += 4 - h * stride;
431     }
432 }
433
434 void ff_vector_clipf_sse(float *dst, const float *src,
435                          float min, float max, int len)
436 {
437     x86_reg i = (len - 16) * 4;
438     __asm__ volatile (
439         "movss          %3, %%xmm4      \n\t"
440         "movss          %4, %%xmm5      \n\t"
441         "shufps $0, %%xmm4, %%xmm4      \n\t"
442         "shufps $0, %%xmm5, %%xmm5      \n\t"
443         "1:                             \n\t"
444         "movaps   (%2, %0), %%xmm0      \n\t" // 3/1 on intel
445         "movaps 16(%2, %0), %%xmm1      \n\t"
446         "movaps 32(%2, %0), %%xmm2      \n\t"
447         "movaps 48(%2, %0), %%xmm3      \n\t"
448         "maxps      %%xmm4, %%xmm0      \n\t"
449         "maxps      %%xmm4, %%xmm1      \n\t"
450         "maxps      %%xmm4, %%xmm2      \n\t"
451         "maxps      %%xmm4, %%xmm3      \n\t"
452         "minps      %%xmm5, %%xmm0      \n\t"
453         "minps      %%xmm5, %%xmm1      \n\t"
454         "minps      %%xmm5, %%xmm2      \n\t"
455         "minps      %%xmm5, %%xmm3      \n\t"
456         "movaps     %%xmm0,   (%1, %0)  \n\t"
457         "movaps     %%xmm1, 16(%1, %0)  \n\t"
458         "movaps     %%xmm2, 32(%1, %0)  \n\t"
459         "movaps     %%xmm3, 48(%1, %0)  \n\t"
460         "sub           $64, %0          \n\t"
461         "jge            1b              \n\t"
462         : "+&r" (i)
463         : "r" (dst), "r" (src), "m" (min), "m" (max)
464         : "memory");
465 }
466
467 #endif /* HAVE_INLINE_ASM */