msi: Test sorting a table using a column that is not selected.
[wine] / dlls / dsound / dsound_convert.c
1 /* DirectSound format conversion and mixing routines
2  *
3  * Copyright 2007 Maarten Lankhorst
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.1 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  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  */
19
20 /* 8 bits is unsigned, the rest is signed.
21  * First I tried to reuse existing stuff from alsa-lib, after that
22  * didn't work, I gave up and just went for individual hacks.
23  *
24  * 24 bit is expensive to do, due to unaligned access.
25  * In dlls/winex11.drv/dib_convert.c convert_888_to_0888_asis there is a way
26  * around it, but I'm happy current code works, maybe something for later.
27  *
28  * The ^ 0x80 flips the signed bit, this is the conversion from
29  * signed (-128.. 0.. 127) to unsigned (0...255)
30  * This is only temporary: All 8 bit data should be converted to signed.
31  * then when fed to the sound card, it should be converted to unsigned again.
32  *
33  * Sound is LITTLE endian
34  */
35
36 #include "config.h"
37 #ifdef HAVE_STDINT_H
38 #include <stdint.h>
39 #endif
40 #include <stdarg.h>
41
42 #define NONAMELESSSTRUCT
43 #define NONAMELESSUNION
44 #include "windef.h"
45 #include "winbase.h"
46 #include "mmsystem.h"
47 #include "winternl.h"
48 #include "wine/debug.h"
49 #include "dsound.h"
50 #include "dsdriver.h"
51 #include "dsound_private.h"
52
53 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
54
55 typedef struct {
56     uint8_t byte[3];
57 } int24_struct;
58
59 #ifdef WORDS_BIGENDIAN
60 #define le16(x) RtlUshortByteSwap((x))
61 #define le32(x) RtlUlongByteSwap((x))
62 #else
63 #define le16(x) (x)
64 #define le32(x) (x)
65 #endif
66
67 static void convert_8_to_8 (const void *src, void *dst)
68 {
69     uint8_t *dest = dst;
70     *dest = *(uint8_t*)src;
71 }
72
73 static void convert_8_to_16 (const void *src, void *dst)
74 {
75     uint16_t dest = *(uint8_t*)src, *dest16 = dst;
76     *dest16 = le16(dest * 257 - 32768);
77 }
78
79 static void convert_8_to_24 (const void *src, void *dst)
80 {
81     uint8_t dest = *(uint8_t*)src;
82     int24_struct *dest24 = dst;
83     dest24->byte[0] = dest;
84     dest24->byte[1] = dest;
85     dest24->byte[2] = dest - 0x80;
86 }
87
88 static void convert_8_to_32 (const void *src, void *dst)
89 {
90     uint32_t dest = *(uint8_t*)src, *dest32 = dst;
91     *dest32 = le32(dest * 16843009 - 2147483648U);
92 }
93
94 static void convert_16_to_8 (const void *src, void *dst)
95 {
96     uint8_t *dst8 = dst;
97     *dst8 = (le16(*(uint16_t*)src)) / 256;
98     *dst8 -= 0x80;
99 }
100
101 static void convert_16_to_16 (const void *src, void *dst)
102 {
103     uint16_t *dest = dst;
104     *dest = *(uint16_t*)src;
105 }
106
107 static void convert_16_to_24 (const void *src, void *dst)
108 {
109     uint16_t dest = le16(*(uint16_t*)src);
110     int24_struct *dest24 = dst;
111
112     dest24->byte[0] = dest / 256;
113     dest24->byte[1] = dest;
114     dest24->byte[2] = dest / 256;
115 }
116
117 static void convert_16_to_32 (const void *src, void *dst)
118 {
119     uint32_t dest = *(uint16_t*)src, *dest32 = dst;
120     *dest32 = dest * 65537;
121 }
122
123 static void convert_24_to_8 (const void *src, void *dst)
124 {
125     uint8_t *dst8 = dst;
126     *dst8 = ((int24_struct*)src)->byte[2];
127 }
128
129 static void convert_24_to_16 (const void *src, void *dst)
130 {
131     uint16_t *dest16 = dst;
132     const int24_struct *source = src;
133     *dest16 = le16(source->byte[2] * 256 + source->byte[1]);
134 }
135
136 static void convert_24_to_24 (const void *src, void *dst)
137 {
138     int24_struct *dest24 = dst;
139     const int24_struct *src24 = src;
140     *dest24 = *src24;
141 }
142
143 static void convert_24_to_32 (const void *src, void *dst)
144 {
145     uint32_t *dest32 = dst;
146     const int24_struct *source = src;
147     *dest32 = le32(source->byte[2] * 16777217 + source->byte[1] * 65536 + source->byte[0] * 256);
148 }
149
150 static void convert_32_to_8 (const void *src, void *dst)
151 {
152     uint8_t *dst8 = dst;
153     *dst8 = (le32(*(uint32_t*)src) / 16777216);
154     *dst8 -= 0x80;
155 }
156
157 static void convert_32_to_16 (const void *src, void *dst)
158 {
159     uint16_t *dest16 = dst;
160     *dest16 = le16(le32(*(uint32_t*)src) / 65536);
161 }
162
163 static void convert_32_to_24 (const void *src, void *dst)
164 {
165     uint32_t dest = le32(*(uint32_t*)dst);
166     int24_struct *dest24 = dst;
167
168     dest24->byte[0] = dest / 256;
169     dest24->byte[1] = dest / 65536;
170     dest24->byte[2] = dest / 16777216;
171 }
172
173 static void convert_32_to_32 (const void *src, void *dst)
174 {
175     uint32_t *dest = dst;
176     *dest = *(uint32_t*)src;
177 }
178
179 const bitsconvertfunc convertbpp[4][4] = {
180     { convert_8_to_8, convert_8_to_16, convert_8_to_24, convert_8_to_32 },
181     { convert_16_to_8, convert_16_to_16, convert_16_to_24, convert_16_to_32 },
182     { convert_24_to_8, convert_24_to_16, convert_24_to_24, convert_24_to_32 },
183     { convert_32_to_8, convert_32_to_16, convert_32_to_24, convert_32_to_32 },
184 };
185
186 static void mix8(int8_t *src, int32_t *dst, unsigned len)
187 {
188     TRACE("%p - %p %d\n", src, dst, len);
189     while (len--)
190         /* 8-bit WAV is unsigned, it's here converted to signed, normalize function will convert it back again */
191         *(dst++) += (int8_t)((uint8_t)*(src++) - (uint8_t)0x80);
192 }
193
194 static void mix16(int16_t *src, int32_t *dst, unsigned len)
195 {
196     TRACE("%p - %p %d\n", src, dst, len);
197     len /= 2;
198     while (len--)
199     {
200         *dst += le16(*src);
201         ++dst; ++src;
202     }
203 }
204
205 static void mix24(int24_struct *src, int32_t *dst, unsigned len)
206 {
207     TRACE("%p - %p %d\n", src, dst, len);
208     len /= 3;
209     while (len--)
210     {
211         uint32_t field;
212         field = ((unsigned)src->byte[2] << 16) + ((unsigned)src->byte[1] << 8) + (unsigned)src->byte[0];
213         if (src->byte[2] & 0x80)
214             field |= 0xFF000000U;
215         *(dst++) += field;
216         ++src;
217     }
218 }
219
220 static void mix32(int32_t *src, int64_t *dst, unsigned len)
221 {
222     TRACE("%p - %p %d\n", src, dst, len);
223     len /= 4;
224     while (len--)
225         *(dst++) += le32(*(src++));
226 }
227
228 const mixfunc mixfunctions[4] = {
229     (mixfunc)mix8,
230     (mixfunc)mix16,
231     (mixfunc)mix24,
232     (mixfunc)mix32
233 };
234
235 static void norm8(int32_t *src, int8_t *dst, unsigned len)
236 {
237     TRACE("%p - %p %d\n", src, dst, len);
238     while (len--)
239     {
240         *dst = (*src) + 0x80;
241         if (*src < -0x80)
242             *dst = 0;
243         else if (*src > 0x7f)
244             *dst = 0xff;
245         ++dst;
246         ++src;
247     }
248 }
249
250 static void norm16(int32_t *src, int16_t *dst, unsigned len)
251 {
252     TRACE("%p - %p %d\n", src, dst, len);
253     len /= 2;
254     while (len--)
255     {
256         *dst = le16(*src);
257         if (*src <= -0x8000)
258             *dst = le16(0x8000);
259         else if (*src > 0x7fff)
260             *dst = le16(0x7fff);
261         ++dst;
262         ++src;
263     }
264 }
265
266 static void norm24(int32_t *src, int24_struct *dst, unsigned len)
267 {
268     TRACE("%p - %p %d\n", src, dst, len);
269     len /= 3;
270     while (len--)
271     {
272         if (*src <= -0x800000)
273         {
274             dst->byte[0] = 0;
275             dst->byte[1] = 0;
276             dst->byte[2] = 0x80;
277         }
278         else if (*src > 0x7fffff)
279         {
280             dst->byte[0] = 0xff;
281             dst->byte[1] = 0xff;
282             dst->byte[2] = 0x7f;
283         }
284         else
285         {
286             dst->byte[0] = *src;
287             dst->byte[1] = *src >> 8;
288             dst->byte[2] = *src >> 16;
289         }
290         ++dst;
291         ++src;
292     }
293 }
294
295 static void norm32(int64_t *src, int32_t *dst, unsigned len)
296 {
297     TRACE("%p - %p %d\n", src, dst, len);
298     len /= 4;
299     while (len--)
300     {
301         *dst = le32(*src);
302         if (*src <= -(int64_t)0x80000000)
303             *dst = le32(0x80000000);
304         else if (*src > 0x7fffffff)
305             *dst = le32(0x7fffffff);
306         ++dst;
307         ++src;
308     }
309 }
310
311 const normfunc normfunctions[4] = {
312     (normfunc)norm8,
313     (normfunc)norm16,
314     (normfunc)norm24,
315     (normfunc)norm32,
316 };