iphlpapi: Fix inverted logic in mask comparison.
[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
38 #include <stdarg.h>
39
40 #define NONAMELESSSTRUCT
41 #define NONAMELESSUNION
42 #include "windef.h"
43 #include "winbase.h"
44 #include "mmsystem.h"
45 #include "winternl.h"
46 #include "wine/debug.h"
47 #include "dsound.h"
48 #include "dsdriver.h"
49 #include "dsound_private.h"
50
51 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
52
53 #ifdef WORDS_BIGENDIAN
54 #define le16(x) RtlUshortByteSwap((x))
55 #define le32(x) RtlUlongByteSwap((x))
56 #else
57 #define le16(x) (x)
58 #define le32(x) (x)
59 #endif
60
61 static inline void src_advance(const void **src, UINT stride, INT *count, UINT *freqAcc, UINT adj)
62 {
63     *freqAcc += adj;
64     if (*freqAcc >= (1 << DSOUND_FREQSHIFT))
65     {
66         ULONG adv = (*freqAcc >> DSOUND_FREQSHIFT);
67         *freqAcc &= (1 << DSOUND_FREQSHIFT) - 1;
68         *(const char **)src += adv * stride;
69         *count -= adv;
70     }
71 }
72
73 static void convert_8_to_8 (const void *src, void *dst, UINT src_stride,
74         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
75 {
76     while (count > 0)
77     {
78         *(BYTE *)dst = *(const BYTE *)src;
79
80         dst = (char *)dst + dst_stride;
81         src_advance(&src, src_stride, &count, &freqAcc, adj);
82     }
83 }
84
85 static void convert_8_to_16 (const void *src, void *dst, UINT src_stride,
86         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
87 {
88     while (count > 0)
89     {
90         WORD dest = *(const BYTE *)src, *dest16 = dst;
91         *dest16 = le16(dest * 257 - 32768);
92
93         dst = (char *)dst + dst_stride;
94         src_advance(&src, src_stride, &count, &freqAcc, adj);
95     }
96 }
97
98 static void convert_8_to_24 (const void *src, void *dst, UINT src_stride,
99         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
100 {
101     while (count > 0)
102     {
103         BYTE dest = *(const BYTE *)src;
104         BYTE *dest24 = dst;
105         dest24[0] = dest;
106         dest24[1] = dest;
107         dest24[2] = dest - 0x80;
108
109         dst = (char *)dst + dst_stride;
110         src_advance(&src, src_stride, &count, &freqAcc, adj);
111     }
112 }
113
114 static void convert_8_to_32 (const void *src, void *dst, UINT src_stride,
115         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
116 {
117     while (count > 0)
118     {
119         DWORD dest = *(const BYTE *)src, *dest32 = dst;
120         *dest32 = le32(dest * 16843009 - 2147483648U);
121
122         dst = (char *)dst + dst_stride;
123         src_advance(&src, src_stride, &count, &freqAcc, adj);
124     }
125 }
126
127 static void convert_16_to_8 (const void *src, void *dst, UINT src_stride,
128         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
129 {
130     while (count > 0)
131     {
132         BYTE *dst8 = dst;
133         *dst8 = (le16(*(const WORD *)src)) / 256;
134         *dst8 -= 0x80;
135
136         dst = (char *)dst + dst_stride;
137         src_advance(&src, src_stride, &count, &freqAcc, adj);
138     }
139 }
140
141 static void convert_16_to_16 (const void *src, void *dst, UINT src_stride,
142         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
143 {
144     while (count > 0)
145     {
146         *(WORD *)dst = *(const WORD *)src;
147
148         dst = (char *)dst + dst_stride;
149         src_advance(&src, src_stride, &count, &freqAcc, adj);
150     }
151 }
152
153 static void convert_16_to_24 (const void *src, void *dst, UINT src_stride,
154         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
155 {
156     while (count > 0)
157     {
158         WORD dest = le16(*(const WORD *)src);
159         BYTE *dest24 = dst;
160
161         dest24[0] = dest / 256;
162         dest24[1] = dest;
163         dest24[2] = dest / 256;
164
165         dst = (char *)dst + dst_stride;
166         src_advance(&src, src_stride, &count, &freqAcc, adj);
167     }
168 }
169
170 static void convert_16_to_32 (const void *src, void *dst, UINT src_stride,
171         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
172 {
173     while (count > 0)
174     {
175         DWORD dest = *(const WORD *)src, *dest32 = dst;
176         *dest32 = dest * 65537;
177
178         dst = (char *)dst + dst_stride;
179         src_advance(&src, src_stride, &count, &freqAcc, adj);
180     }
181 }
182
183 static void convert_24_to_8 (const void *src, void *dst, UINT src_stride,
184         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
185 {
186     while (count > 0)
187     {
188         BYTE *dst8 = dst;
189         *dst8 = ((const BYTE *)src)[2];
190
191         dst = (char *)dst + dst_stride;
192         src_advance(&src, src_stride, &count, &freqAcc, adj);
193     }
194 }
195
196 static void convert_24_to_16 (const void *src, void *dst, UINT src_stride,
197         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
198 {
199     while (count > 0)
200     {
201         WORD *dest16 = dst;
202         const BYTE *source = src;
203         *dest16 = le16(source[2] * 256 + source[1]);
204
205         dst = (char *)dst + dst_stride;
206         src_advance(&src, src_stride, &count, &freqAcc, adj);
207     }
208 }
209
210 static void convert_24_to_24 (const void *src, void *dst, UINT src_stride,
211         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
212 {
213     while (count > 0)
214     {
215         BYTE *dest24 = dst;
216         const BYTE *src24 = src;
217
218         dest24[0] = src24[0];
219         dest24[1] = src24[1];
220         dest24[2] = src24[2];
221
222         dst = (char *)dst + dst_stride;
223         src_advance(&src, src_stride, &count, &freqAcc, adj);
224     }
225 }
226
227 static void convert_24_to_32 (const void *src, void *dst, UINT src_stride,
228         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
229 {
230     while (count > 0)
231     {
232         DWORD *dest32 = dst;
233         const BYTE *source = src;
234         *dest32 = le32(source[2] * 16777217 + source[1] * 65536 + source[0] * 256);
235
236         dst = (char *)dst + dst_stride;
237         src_advance(&src, src_stride, &count, &freqAcc, adj);
238     }
239 }
240
241 static void convert_32_to_8 (const void *src, void *dst, UINT src_stride,
242         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
243 {
244     while (count > 0)
245     {
246         BYTE *dst8 = dst;
247         *dst8 = (le32(*(const DWORD *)src) / 16777216);
248         *dst8 -= 0x80;
249
250         dst = (char *)dst + dst_stride;
251         src_advance(&src, src_stride, &count, &freqAcc, adj);
252     }
253 }
254
255 static void convert_32_to_16 (const void *src, void *dst, UINT src_stride,
256         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
257 {
258     while (count > 0)
259     {
260         WORD *dest16 = dst;
261         *dest16 = le16(le32(*(const DWORD *)src) / 65536);
262
263         dst = (char *)dst + dst_stride;
264         src_advance(&src, src_stride, &count, &freqAcc, adj);
265     }
266 }
267
268 static void convert_32_to_24 (const void *src, void *dst, UINT src_stride,
269         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
270 {
271     while (count > 0)
272     {
273         DWORD dest = le32(*(const DWORD *)src);
274         BYTE *dest24 = dst;
275
276         dest24[0] = dest / 256;
277         dest24[1] = dest / 65536;
278         dest24[2] = dest / 16777216;
279
280         dst = (char *)dst + dst_stride;
281         src_advance(&src, src_stride, &count, &freqAcc, adj);
282     }
283 }
284
285 static void convert_32_to_32 (const void *src, void *dst, UINT src_stride,
286         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
287 {
288     while (count > 0)
289     {
290         DWORD *dest = dst;
291         *dest = *(const DWORD *)src;
292
293         dst = (char *)dst + dst_stride;
294         src_advance(&src, src_stride, &count, &freqAcc, adj);
295     }
296 }
297
298 const bitsconvertfunc convertbpp[4][4] = {
299     { convert_8_to_8, convert_8_to_16, convert_8_to_24, convert_8_to_32 },
300     { convert_16_to_8, convert_16_to_16, convert_16_to_24, convert_16_to_32 },
301     { convert_24_to_8, convert_24_to_16, convert_24_to_24, convert_24_to_32 },
302     { convert_32_to_8, convert_32_to_16, convert_32_to_24, convert_32_to_32 },
303 };
304
305 static void mix8(signed char *src, INT *dst, unsigned len)
306 {
307     TRACE("%p - %p %d\n", src, dst, len);
308     while (len--)
309         /* 8-bit WAV is unsigned, it's here converted to signed, normalize function will convert it back again */
310         *(dst++) += (signed char)((BYTE)*(src++) - (BYTE)0x80);
311 }
312
313 static void mix16(SHORT *src, INT *dst, unsigned len)
314 {
315     TRACE("%p - %p %d\n", src, dst, len);
316     len /= 2;
317     while (len--)
318     {
319         *dst += le16(*src);
320         ++dst; ++src;
321     }
322 }
323
324 static void mix24(BYTE *src, INT *dst, unsigned len)
325 {
326     TRACE("%p - %p %d\n", src, dst, len);
327     len /= 3;
328     while (len--)
329     {
330         DWORD field;
331         field = ((DWORD)src[2] << 16) + ((DWORD)src[1] << 8) + (DWORD)src[0];
332         if (src[2] & 0x80)
333             field |= 0xFF000000U;
334         *(dst++) += field;
335         ++src;
336     }
337 }
338
339 static void mix32(INT *src, LONGLONG *dst, unsigned len)
340 {
341     TRACE("%p - %p %d\n", src, dst, len);
342     len /= 4;
343     while (len--)
344         *(dst++) += le32(*(src++));
345 }
346
347 const mixfunc mixfunctions[4] = {
348     (mixfunc)mix8,
349     (mixfunc)mix16,
350     (mixfunc)mix24,
351     (mixfunc)mix32
352 };
353
354 static void norm8(INT *src, signed char *dst, unsigned len)
355 {
356     TRACE("%p - %p %d\n", src, dst, len);
357     while (len--)
358     {
359         *dst = (*src) + 0x80;
360         if (*src < -0x80)
361             *dst = 0;
362         else if (*src > 0x7f)
363             *dst = 0xff;
364         ++dst;
365         ++src;
366     }
367 }
368
369 static void norm16(INT *src, SHORT *dst, unsigned len)
370 {
371     TRACE("%p - %p %d\n", src, dst, len);
372     len /= 2;
373     while (len--)
374     {
375         *dst = le16(*src);
376         if (*src <= -0x8000)
377             *dst = le16(0x8000);
378         else if (*src > 0x7fff)
379             *dst = le16(0x7fff);
380         ++dst;
381         ++src;
382     }
383 }
384
385 static void norm24(INT *src, BYTE *dst, unsigned len)
386 {
387     TRACE("%p - %p %d\n", src, dst, len);
388     len /= 3;
389     while (len--)
390     {
391         if (*src <= -0x800000)
392         {
393             dst[0] = 0;
394             dst[1] = 0;
395             dst[2] = 0x80;
396         }
397         else if (*src > 0x7fffff)
398         {
399             dst[0] = 0xff;
400             dst[1] = 0xff;
401             dst[2] = 0x7f;
402         }
403         else
404         {
405             dst[0] = *src;
406             dst[1] = *src >> 8;
407             dst[2] = *src >> 16;
408         }
409         ++dst;
410         ++src;
411     }
412 }
413
414 static void norm32(LONGLONG *src, INT *dst, unsigned len)
415 {
416     TRACE("%p - %p %d\n", src, dst, len);
417     len /= 4;
418     while (len--)
419     {
420         *dst = le32(*src);
421         if (*src <= -(LONGLONG)0x80000000)
422             *dst = le32(0x80000000);
423         else if (*src > 0x7fffffff)
424             *dst = le32(0x7fffffff);
425         ++dst;
426         ++src;
427     }
428 }
429
430 const normfunc normfunctions[4] = {
431     (normfunc)norm8,
432     (normfunc)norm16,
433     (normfunc)norm24,
434     (normfunc)norm32,
435 };