fmtconvert: check compile-time x86 instruction set flags
[ffmpeg.git] / libavcodec / x86 / fmtconvert_mmx.c
1 /*
2  * Format Conversion Utils
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of Libav.
7  *
8  * Libav is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * Libav is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  *
22  * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
23  */
24
25 #include "libavutil/cpu.h"
26 #include "libavutil/x86_cpu.h"
27 #include "libavcodec/fmtconvert.h"
28
29 static void int32_to_float_fmul_scalar_sse(float *dst, const int *src, float mul, int len)
30 {
31     x86_reg i = -4*len;
32     __asm__ volatile(
33         "movss  %3, %%xmm4 \n"
34         "shufps $0, %%xmm4, %%xmm4 \n"
35         "1: \n"
36         "cvtpi2ps   (%2,%0), %%xmm0 \n"
37         "cvtpi2ps  8(%2,%0), %%xmm1 \n"
38         "cvtpi2ps 16(%2,%0), %%xmm2 \n"
39         "cvtpi2ps 24(%2,%0), %%xmm3 \n"
40         "movlhps  %%xmm1,    %%xmm0 \n"
41         "movlhps  %%xmm3,    %%xmm2 \n"
42         "mulps    %%xmm4,    %%xmm0 \n"
43         "mulps    %%xmm4,    %%xmm2 \n"
44         "movaps   %%xmm0,   (%1,%0) \n"
45         "movaps   %%xmm2, 16(%1,%0) \n"
46         "add $32, %0 \n"
47         "jl 1b \n"
48         :"+r"(i)
49         :"r"(dst+len), "r"(src+len), "m"(mul)
50     );
51 }
52
53 static void int32_to_float_fmul_scalar_sse2(float *dst, const int *src, float mul, int len)
54 {
55     x86_reg i = -4*len;
56     __asm__ volatile(
57         "movss  %3, %%xmm4 \n"
58         "shufps $0, %%xmm4, %%xmm4 \n"
59         "1: \n"
60         "cvtdq2ps   (%2,%0), %%xmm0 \n"
61         "cvtdq2ps 16(%2,%0), %%xmm1 \n"
62         "mulps    %%xmm4,    %%xmm0 \n"
63         "mulps    %%xmm4,    %%xmm1 \n"
64         "movaps   %%xmm0,   (%1,%0) \n"
65         "movaps   %%xmm1, 16(%1,%0) \n"
66         "add $32, %0 \n"
67         "jl 1b \n"
68         :"+r"(i)
69         :"r"(dst+len), "r"(src+len), "m"(mul)
70     );
71 }
72
73 #if HAVE_YASM
74
75 void ff_float_to_int16_3dnow(int16_t *dst, const float *src, long len);
76 void ff_float_to_int16_sse  (int16_t *dst, const float *src, long len);
77 void ff_float_to_int16_sse2 (int16_t *dst, const float *src, long len);
78
79 void ff_float_to_int16_interleave6_sse(int16_t *dst, const float **src, int len);
80 void ff_float_to_int16_interleave6_3dnow(int16_t *dst, const float **src, int len);
81 void ff_float_to_int16_interleave6_3dn2(int16_t *dst, const float **src, int len);
82
83 #define ff_float_to_int16_interleave6_sse2 ff_float_to_int16_interleave6_sse
84
85 #define FLOAT_TO_INT16_INTERLEAVE(cpu, body) \
86 /* gcc pessimizes register allocation if this is in the same function as float_to_int16_interleave_sse2*/\
87 static av_noinline void float_to_int16_interleave_misc_##cpu(int16_t *dst, const float **src, long len, int channels){\
88     DECLARE_ALIGNED(16, int16_t, tmp)[len];\
89     int i,j,c;\
90     for(c=0; c<channels; c++){\
91         ff_float_to_int16_##cpu(tmp, src[c], len);\
92         for(i=0, j=c; i<len; i++, j+=channels)\
93             dst[j] = tmp[i];\
94     }\
95 }\
96 \
97 static void float_to_int16_interleave_##cpu(int16_t *dst, const float **src, long len, int channels){\
98     if(channels==1)\
99         ff_float_to_int16_##cpu(dst, src[0], len);\
100     else if(channels==2){\
101         x86_reg reglen = len; \
102         const float *src0 = src[0];\
103         const float *src1 = src[1];\
104         __asm__ volatile(\
105             "shl $2, %0 \n"\
106             "add %0, %1 \n"\
107             "add %0, %2 \n"\
108             "add %0, %3 \n"\
109             "neg %0 \n"\
110             body\
111             :"+r"(reglen), "+r"(dst), "+r"(src0), "+r"(src1)\
112         );\
113     }else if(channels==6){\
114         ff_float_to_int16_interleave6_##cpu(dst, src, len);\
115     }else\
116         float_to_int16_interleave_misc_##cpu(dst, src, len, channels);\
117 }
118
119 FLOAT_TO_INT16_INTERLEAVE(3dnow,
120     "1:                         \n"
121     "pf2id     (%2,%0), %%mm0   \n"
122     "pf2id    8(%2,%0), %%mm1   \n"
123     "pf2id     (%3,%0), %%mm2   \n"
124     "pf2id    8(%3,%0), %%mm3   \n"
125     "packssdw    %%mm1, %%mm0   \n"
126     "packssdw    %%mm3, %%mm2   \n"
127     "movq        %%mm0, %%mm1   \n"
128     "punpcklwd   %%mm2, %%mm0   \n"
129     "punpckhwd   %%mm2, %%mm1   \n"
130     "movq        %%mm0,  (%1,%0)\n"
131     "movq        %%mm1, 8(%1,%0)\n"
132     "add $16, %0                \n"
133     "js 1b                      \n"
134     "femms                      \n"
135 )
136
137 FLOAT_TO_INT16_INTERLEAVE(sse,
138     "1:                         \n"
139     "cvtps2pi  (%2,%0), %%mm0   \n"
140     "cvtps2pi 8(%2,%0), %%mm1   \n"
141     "cvtps2pi  (%3,%0), %%mm2   \n"
142     "cvtps2pi 8(%3,%0), %%mm3   \n"
143     "packssdw    %%mm1, %%mm0   \n"
144     "packssdw    %%mm3, %%mm2   \n"
145     "movq        %%mm0, %%mm1   \n"
146     "punpcklwd   %%mm2, %%mm0   \n"
147     "punpckhwd   %%mm2, %%mm1   \n"
148     "movq        %%mm0,  (%1,%0)\n"
149     "movq        %%mm1, 8(%1,%0)\n"
150     "add $16, %0                \n"
151     "js 1b                      \n"
152     "emms                       \n"
153 )
154
155 FLOAT_TO_INT16_INTERLEAVE(sse2,
156     "1:                         \n"
157     "cvtps2dq  (%2,%0), %%xmm0  \n"
158     "cvtps2dq  (%3,%0), %%xmm1  \n"
159     "packssdw   %%xmm1, %%xmm0  \n"
160     "movhlps    %%xmm0, %%xmm1  \n"
161     "punpcklwd  %%xmm1, %%xmm0  \n"
162     "movdqa     %%xmm0, (%1,%0) \n"
163     "add $16, %0                \n"
164     "js 1b                      \n"
165 )
166
167 static void float_to_int16_interleave_3dn2(int16_t *dst, const float **src, long len, int channels){
168     if(channels==6)
169         ff_float_to_int16_interleave6_3dn2(dst, src, len);
170     else
171         float_to_int16_interleave_3dnow(dst, src, len, channels);
172 }
173
174 void ff_float_interleave2_mmx(float *dst, const float **src, unsigned int len);
175 void ff_float_interleave2_sse(float *dst, const float **src, unsigned int len);
176
177 void ff_float_interleave6_mmx(float *dst, const float **src, unsigned int len);
178 void ff_float_interleave6_sse(float *dst, const float **src, unsigned int len);
179
180 static void float_interleave_mmx(float *dst, const float **src,
181                                  unsigned int len, int channels)
182 {
183     if (channels == 2) {
184         ff_float_interleave2_mmx(dst, src, len);
185     } else if (channels == 6)
186         ff_float_interleave6_mmx(dst, src, len);
187     else
188         ff_float_interleave_c(dst, src, len, channels);
189 }
190
191 static void float_interleave_sse(float *dst, const float **src,
192                                  unsigned int len, int channels)
193 {
194     if (channels == 2) {
195         ff_float_interleave2_sse(dst, src, len);
196     } else if (channels == 6)
197         ff_float_interleave6_sse(dst, src, len);
198     else
199         ff_float_interleave_c(dst, src, len, channels);
200 }
201 #endif
202
203 void ff_fmt_convert_init_x86(FmtConvertContext *c, AVCodecContext *avctx)
204 {
205     int mm_flags = av_get_cpu_flags();
206
207     if (mm_flags & AV_CPU_FLAG_MMX) {
208 #if HAVE_YASM
209         c->float_interleave = float_interleave_mmx;
210
211         if (HAVE_AMD3DNOW && mm_flags & AV_CPU_FLAG_3DNOW) {
212             if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
213                 c->float_to_int16 = ff_float_to_int16_3dnow;
214                 c->float_to_int16_interleave = float_to_int16_interleave_3dnow;
215             }
216         }
217         if (HAVE_AMD3DNOWEXT && mm_flags & AV_CPU_FLAG_3DNOWEXT) {
218             if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
219                 c->float_to_int16_interleave = float_to_int16_interleave_3dn2;
220             }
221         }
222 #endif
223         if (HAVE_SSE && mm_flags & AV_CPU_FLAG_SSE) {
224             c->int32_to_float_fmul_scalar = int32_to_float_fmul_scalar_sse;
225 #if HAVE_YASM
226             c->float_to_int16 = ff_float_to_int16_sse;
227             c->float_to_int16_interleave = float_to_int16_interleave_sse;
228             c->float_interleave = float_interleave_sse;
229 #endif
230         }
231         if (HAVE_SSE && mm_flags & AV_CPU_FLAG_SSE2) {
232             c->int32_to_float_fmul_scalar = int32_to_float_fmul_scalar_sse2;
233 #if HAVE_YASM
234             c->float_to_int16 = ff_float_to_int16_sse2;
235             c->float_to_int16_interleave = float_to_int16_interleave_sse2;
236 #endif
237         }
238     }
239 }