dlls/dsound/dsound_convert.c

   1 /* DirectSound format conversion and mixing routines
   2  *
   3  * Copyright 2007 Maarten Lankhorst
   4  * Copyright 2011 Owen Rudge for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /* 8 bits is unsigned, the rest is signed.
  22  * First I tried to reuse existing stuff from alsa-lib, after that
  23  * didn't work, I gave up and just went for individual hacks.
  24  *
  25  * 24 bit is expensive to do, due to unaligned access.
  26  * In dlls/winex11.drv/dib_convert.c convert_888_to_0888_asis there is a way
  27  * around it, but I'm happy current code works, maybe something for later.
  28  *
  29  * The ^ 0x80 flips the signed bit, this is the conversion from
  30  * signed (-128.. 0.. 127) to unsigned (0...255)
  31  * This is only temporary: All 8 bit data should be converted to signed.
  32  * then when fed to the sound card, it should be converted to unsigned again.
  33  *
  34  * Sound is LITTLE endian
  35  */
  36
  37 #include "config.h"
  38
  39 #include <stdarg.h>
  40
  41 #define NONAMELESSSTRUCT
  42 #define NONAMELESSUNION
  43 #include "windef.h"
  44 #include "winbase.h"
  45 #include "mmsystem.h"
  46 #include "winternl.h"
  47 #include "wine/debug.h"
  48 #include "dsound.h"
  49 #include "dsdriver.h"
  50 #include "dsound_private.h"
  51
  52 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  53
  54 #ifdef WORDS_BIGENDIAN
  55 #define le16(x) RtlUshortByteSwap((x))
  56 #define le32(x) RtlUlongByteSwap((x))
  57 #else
  58 #define le16(x) (x)
  59 #define le32(x) (x)
  60 #endif
  61
  62 static inline void src_advance(const void **src, UINT stride, INT *count, UINT *freqAcc, UINT adj)
  63 {
  64     *freqAcc += adj;
  65     if (*freqAcc >= (1 << DSOUND_FREQSHIFT))
  66     {
  67         ULONG adv = (*freqAcc >> DSOUND_FREQSHIFT);
  68         *freqAcc &= (1 << DSOUND_FREQSHIFT) - 1;
  69         *(const char **)src += adv * stride;
  70         *count -= adv;
  71     }
  72 }
  73
  74 static void convert_8_to_8 (const void *src, void *dst, UINT src_stride,
  75         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
  76 {
  77     while (count > 0)
  78     {
  79         *(BYTE *)dst = *(const BYTE *)src;
  80
  81         dst = (char *)dst + dst_stride;
  82         src_advance(&src, src_stride, &count, &freqAcc, adj);
  83     }
  84 }
  85
  86 static void convert_8_to_16 (const void *src, void *dst, UINT src_stride,
  87         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
  88 {
  89     while (count > 0)
  90     {
  91         WORD dest = *(const BYTE *)src, *dest16 = dst;
  92         *dest16 = le16(dest * 257 - 32768);
  93
  94         dst = (char *)dst + dst_stride;
  95         src_advance(&src, src_stride, &count, &freqAcc, adj);
  96     }
  97 }
  98
  99 static void convert_8_to_24 (const void *src, void *dst, UINT src_stride,
 100         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 101 {
 102     while (count > 0)
 103     {
 104         BYTE dest = *(const BYTE *)src;
 105         BYTE *dest24 = dst;
 106         dest24[0] = dest;
 107         dest24[1] = dest;
 108         dest24[2] = dest - 0x80;
 109
 110         dst = (char *)dst + dst_stride;
 111         src_advance(&src, src_stride, &count, &freqAcc, adj);
 112     }
 113 }
 114
 115 static void convert_8_to_32 (const void *src, void *dst, UINT src_stride,
 116         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 117 {
 118     while (count > 0)
 119     {
 120         DWORD dest = *(const BYTE *)src, *dest32 = dst;
 121         *dest32 = le32(dest * 16843009 - 2147483648U);
 122
 123         dst = (char *)dst + dst_stride;
 124         src_advance(&src, src_stride, &count, &freqAcc, adj);
 125     }
 126 }
 127
 128 static void convert_16_to_8 (const void *src, void *dst, UINT src_stride,
 129         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 130 {
 131     while (count > 0)
 132     {
 133         BYTE *dst8 = dst;
 134         *dst8 = (le16(*(const WORD *)src)) / 256;
 135         *dst8 -= 0x80;
 136
 137         dst = (char *)dst + dst_stride;
 138         src_advance(&src, src_stride, &count, &freqAcc, adj);
 139     }
 140 }
 141
 142 static void convert_16_to_16 (const void *src, void *dst, UINT src_stride,
 143         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 144 {
 145     while (count > 0)
 146     {
 147         *(WORD *)dst = *(const WORD *)src;
 148
 149         dst = (char *)dst + dst_stride;
 150         src_advance(&src, src_stride, &count, &freqAcc, adj);
 151     }
 152 }
 153
 154 static void convert_16_to_24 (const void *src, void *dst, UINT src_stride,
 155         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 156 {
 157     while (count > 0)
 158     {
 159         WORD dest = le16(*(const WORD *)src);
 160         BYTE *dest24 = dst;
 161
 162         dest24[0] = dest / 256;
 163         dest24[1] = dest;
 164         dest24[2] = dest / 256;
 165
 166         dst = (char *)dst + dst_stride;
 167         src_advance(&src, src_stride, &count, &freqAcc, adj);
 168     }
 169 }
 170
 171 static void convert_16_to_32 (const void *src, void *dst, UINT src_stride,
 172         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 173 {
 174     while (count > 0)
 175     {
 176         DWORD dest = *(const WORD *)src, *dest32 = dst;
 177         *dest32 = dest * 65537;
 178
 179         dst = (char *)dst + dst_stride;
 180         src_advance(&src, src_stride, &count, &freqAcc, adj);
 181     }
 182 }
 183
 184 static void convert_24_to_8 (const void *src, void *dst, UINT src_stride,
 185         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 186 {
 187     while (count > 0)
 188     {
 189         BYTE *dst8 = dst;
 190         *dst8 = ((const BYTE *)src)[2];
 191
 192         dst = (char *)dst + dst_stride;
 193         src_advance(&src, src_stride, &count, &freqAcc, adj);
 194     }
 195 }
 196
 197 static void convert_24_to_16 (const void *src, void *dst, UINT src_stride,
 198         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 199 {
 200     while (count > 0)
 201     {
 202         WORD *dest16 = dst;
 203         const BYTE *source = src;
 204         *dest16 = le16(source[2] * 256 + source[1]);
 205
 206         dst = (char *)dst + dst_stride;
 207         src_advance(&src, src_stride, &count, &freqAcc, adj);
 208     }
 209 }
 210
 211 static void convert_24_to_24 (const void *src, void *dst, UINT src_stride,
 212         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 213 {
 214     while (count > 0)
 215     {
 216         BYTE *dest24 = dst;
 217         const BYTE *src24 = src;
 218
 219         dest24[0] = src24[0];
 220         dest24[1] = src24[1];
 221         dest24[2] = src24[2];
 222
 223         dst = (char *)dst + dst_stride;
 224         src_advance(&src, src_stride, &count, &freqAcc, adj);
 225     }
 226 }
 227
 228 static void convert_24_to_32 (const void *src, void *dst, UINT src_stride,
 229         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 230 {
 231     while (count > 0)
 232     {
 233         DWORD *dest32 = dst;
 234         const BYTE *source = src;
 235         *dest32 = le32(source[2] * 16777217 + source[1] * 65536 + source[0] * 256);
 236
 237         dst = (char *)dst + dst_stride;
 238         src_advance(&src, src_stride, &count, &freqAcc, adj);
 239     }
 240 }
 241
 242 static void convert_32_to_8 (const void *src, void *dst, UINT src_stride,
 243         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 244 {
 245     while (count > 0)
 246     {
 247         BYTE *dst8 = dst;
 248         *dst8 = (le32(*(const DWORD *)src) / 16777216);
 249         *dst8 -= 0x80;
 250
 251         dst = (char *)dst + dst_stride;
 252         src_advance(&src, src_stride, &count, &freqAcc, adj);
 253     }
 254 }
 255
 256 static void convert_32_to_16 (const void *src, void *dst, UINT src_stride,
 257         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 258 {
 259     while (count > 0)
 260     {
 261         WORD *dest16 = dst;
 262         *dest16 = le16(le32(*(const DWORD *)src) / 65536);
 263
 264         dst = (char *)dst + dst_stride;
 265         src_advance(&src, src_stride, &count, &freqAcc, adj);
 266     }
 267 }
 268
 269 static void convert_32_to_24 (const void *src, void *dst, UINT src_stride,
 270         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 271 {
 272     while (count > 0)
 273     {
 274         DWORD dest = le32(*(const DWORD *)src);
 275         BYTE *dest24 = dst;
 276
 277         dest24[0] = dest / 256;
 278         dest24[1] = dest / 65536;
 279         dest24[2] = dest / 16777216;
 280
 281         dst = (char *)dst + dst_stride;
 282         src_advance(&src, src_stride, &count, &freqAcc, adj);
 283     }
 284 }
 285
 286 static void convert_32_to_32 (const void *src, void *dst, UINT src_stride,
 287         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 288 {
 289     while (count > 0)
 290     {
 291         DWORD *dest = dst;
 292         *dest = *(const DWORD *)src;
 293
 294         dst = (char *)dst + dst_stride;
 295         src_advance(&src, src_stride, &count, &freqAcc, adj);
 296     }
 297 }
 298
 299 static void convert_ieee_32_to_8 (const void *src, void *dst, UINT src_stride,
 300         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 301 {
 302     while (count > 0)
 303     {
 304         DWORD src_le = le32(*(DWORD *) src);
 305         float v = *((float *) &src_le);
 306         INT8 d = 0;
 307
 308         if (v < -1.0f)
 309             d = -128;
 310         else if (v >  1.0f)
 311             d = 127;
 312         else
 313             d = v * 127.5f - 0.5f;
 314
 315         *(BYTE *) dst = d ^ 0x80;
 316
 317         dst = (char *)dst + dst_stride;
 318         src_advance(&src, src_stride, &count, &freqAcc, adj);
 319     }
 320 }
 321
 322 static void convert_ieee_32_to_16 (const void *src, void *dst, UINT src_stride,
 323         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 324 {
 325     while (count > 0)
 326     {
 327         DWORD src_le = le32(*(DWORD *) src);
 328         float v = *((float *) &src_le);
 329
 330         INT16 *d = (INT16 *) dst;
 331
 332         if (v < -1.0f)
 333             *d = -32768;
 334         else if (v >  1.0f)
 335             *d = 32767;
 336         else
 337             *d = v * 32767.5f - 0.5f;
 338
 339         *d = le16(*d);
 340
 341         dst = (char *)dst + dst_stride;
 342         src_advance(&src, src_stride, &count, &freqAcc, adj);
 343     }
 344 }
 345
 346 static void convert_ieee_32_to_24 (const void *src, void *dst, UINT src_stride,
 347         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 348 {
 349     while (count > 0)
 350     {
 351         DWORD src_le = le32(*(DWORD *) src);
 352         float v = *((float *) &src_le);
 353         BYTE *dest24 = dst;
 354
 355         if (v < -1.0f)
 356         {
 357             dest24[0] = 0;
 358             dest24[1] = 0;
 359             dest24[2] = 0x80;
 360         }
 361         else if (v > 1.0f)
 362         {
 363             dest24[0] = 0xff;
 364             dest24[1] = 0xff;
 365             dest24[2] = 0x7f;
 366         }
 367         else if (v < 0.0f)
 368         {
 369             dest24[0] = v * 8388608.0f;
 370             dest24[1] = v * 32768.0f;
 371             dest24[2] = v * 128.0f;
 372         }
 373         else if (v >= 0.0f)
 374         {
 375             dest24[0] = v * 8388608.0f;
 376             dest24[1] = v * 32768.0f;
 377             dest24[2] = v * 127.0f;
 378         }
 379
 380         dst = (char *)dst + dst_stride;
 381         src_advance(&src, src_stride, &count, &freqAcc, adj);
 382     }
 383 }
 384
 385 static void convert_ieee_32_to_32 (const void *src, void *dst, UINT src_stride,
 386         UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 387 {
 388     while (count > 0)
 389     {
 390         DWORD src_le = le32(*(DWORD *) src);
 391         float v = *((float *) &src_le);
 392         INT32 *d = (INT32 *) dst;
 393
 394         if (v < -1.0f)
 395             *d = -2147483647 - 1; /* silence warning */
 396         else if (v >  1.0f)
 397             *d = 2147483647;
 398         else
 399             *d = v * 2147483647.5f - 0.5f;
 400
 401         *d = le32(*d);
 402
 403         dst = (char *)dst + dst_stride;
 404         src_advance(&src, src_stride, &count, &freqAcc, adj);
 405     }
 406 }
 407
 408 const bitsconvertfunc convertbpp[5][4] = {
 409     { convert_8_to_8, convert_8_to_16, convert_8_to_24, convert_8_to_32 },
 410     { convert_16_to_8, convert_16_to_16, convert_16_to_24, convert_16_to_32 },
 411     { convert_24_to_8, convert_24_to_16, convert_24_to_24, convert_24_to_32 },
 412     { convert_32_to_8, convert_32_to_16, convert_32_to_24, convert_32_to_32 },
 413     { convert_ieee_32_to_8, convert_ieee_32_to_16, convert_ieee_32_to_24, convert_ieee_32_to_32 },
 414 };
 415
 416 static void mix8(signed char *src, INT *dst, unsigned len)
 417 {
 418     TRACE("%p - %p %d\n", src, dst, len);
 419     while (len--)
 420         /* 8-bit WAV is unsigned, it's here converted to signed, normalize function will convert it back again */
 421         *(dst++) += (signed char)((BYTE)*(src++) - (BYTE)0x80);
 422 }
 423
 424 static void mix16(SHORT *src, INT *dst, unsigned len)
 425 {
 426     TRACE("%p - %p %d\n", src, dst, len);
 427     len /= 2;
 428     while (len--)
 429     {
 430         *dst += le16(*src);
 431         ++dst; ++src;
 432     }
 433 }
 434
 435 static void mix24(BYTE *src, INT *dst, unsigned len)
 436 {
 437     TRACE("%p - %p %d\n", src, dst, len);
 438     len /= 3;
 439     while (len--)
 440     {
 441         DWORD field;
 442         field = ((DWORD)src[2] << 16) + ((DWORD)src[1] << 8) + (DWORD)src[0];
 443         if (src[2] & 0x80)
 444             field |= 0xFF000000U;
 445         *(dst++) += field;
 446         ++src;
 447     }
 448 }
 449
 450 static void mix32(INT *src, LONGLONG *dst, unsigned len)
 451 {
 452     TRACE("%p - %p %d\n", src, dst, len);
 453     len /= 4;
 454     while (len--)
 455         *(dst++) += le32(*(src++));
 456 }
 457
 458 const mixfunc mixfunctions[4] = {
 459     (mixfunc)mix8,
 460     (mixfunc)mix16,
 461     (mixfunc)mix24,
 462     (mixfunc)mix32
 463 };
 464
 465 static void norm8(INT *src, signed char *dst, unsigned len)
 466 {
 467     TRACE("%p - %p %d\n", src, dst, len);
 468     while (len--)
 469     {
 470         *dst = (*src) + 0x80;
 471         if (*src < -0x80)
 472             *dst = 0;
 473         else if (*src > 0x7f)
 474             *dst = 0xff;
 475         ++dst;
 476         ++src;
 477     }
 478 }
 479
 480 static void norm16(INT *src, SHORT *dst, unsigned len)
 481 {
 482     TRACE("%p - %p %d\n", src, dst, len);
 483     len /= 2;
 484     while (len--)
 485     {
 486         *dst = le16(*src);
 487         if (*src <= -0x8000)
 488             *dst = le16(0x8000);
 489         else if (*src > 0x7fff)
 490             *dst = le16(0x7fff);
 491         ++dst;
 492         ++src;
 493     }
 494 }
 495
 496 static void norm24(INT *src, BYTE *dst, unsigned len)
 497 {
 498     TRACE("%p - %p %d\n", src, dst, len);
 499     len /= 3;
 500     while (len--)
 501     {
 502         if (*src <= -0x800000)
 503         {
 504             dst[0] = 0;
 505             dst[1] = 0;
 506             dst[2] = 0x80;
 507         }
 508         else if (*src > 0x7fffff)
 509         {
 510             dst[0] = 0xff;
 511             dst[1] = 0xff;
 512             dst[2] = 0x7f;
 513         }
 514         else
 515         {
 516             dst[0] = *src;
 517             dst[1] = *src >> 8;
 518             dst[2] = *src >> 16;
 519         }
 520         ++dst;
 521         ++src;
 522     }
 523 }
 524
 525 static void norm32(LONGLONG *src, INT *dst, unsigned len)
 526 {
 527     TRACE("%p - %p %d\n", src, dst, len);
 528     len /= 4;
 529     while (len--)
 530     {
 531         *dst = le32(*src);
 532         if (*src <= -(LONGLONG)0x80000000)
 533             *dst = le32(0x80000000);
 534         else if (*src > 0x7fffffff)
 535             *dst = le32(0x7fffffff);
 536         ++dst;
 537         ++src;
 538     }
 539 }
 540
 541 const normfunc normfunctions[4] = {
 542     (normfunc)norm8,
 543     (normfunc)norm16,
 544     (normfunc)norm24,
 545     (normfunc)norm32,
 546 };