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 #include <math.h>
  41
  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 "dsound_private.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  51
  52 #ifdef WORDS_BIGENDIAN
  53 #define le16(x) RtlUshortByteSwap((x))
  54 #define le32(x) RtlUlongByteSwap((x))
  55 #else
  56 #define le16(x) (x)
  57 #define le32(x) (x)
  58 #endif
  59
  60 static float get8(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
  61 {
  62     const BYTE* buf = dsb->buffer->memory;
  63     buf += pos + channel;
  64     return (buf[0] - 0x80) / (float)0x80;
  65 }
  66
  67 static float get16(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
  68 {
  69     const BYTE* buf = dsb->buffer->memory;
  70     const SHORT *sbuf = (const SHORT*)(buf + pos + 2 * channel);
  71     SHORT sample = (SHORT)le16(*sbuf);
  72     return sample / (float)0x8000;
  73 }
  74
  75 static float get24(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
  76 {
  77     LONG sample;
  78     const BYTE* buf = dsb->buffer->memory;
  79     buf += pos + 3 * channel;
  80     /* The next expression deliberately has an overflow for buf[2] >= 0x80,
  81        this is how negative values are made.
  82      */
  83     sample = (buf[0] << 8) | (buf[1] << 16) | (buf[2] << 24);
  84     return sample / (float)0x80000000U;
  85 }
  86
  87 static float get32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
  88 {
  89     const BYTE* buf = dsb->buffer->memory;
  90     const LONG *sbuf = (const LONG*)(buf + pos + 4 * channel);
  91     LONG sample = le32(*sbuf);
  92     return sample / (float)0x80000000U;
  93 }
  94
  95 static float getieee32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
  96 {
  97     const BYTE* buf = dsb->buffer->memory;
  98     const float *sbuf = (const float*)(buf + pos + 4 * channel);
  99     /* The value will be clipped later, when put into some non-float buffer */
 100     return *sbuf;
 101 }
 102
 103 const bitsgetfunc getbpp[5] = {get8, get16, get24, get32, getieee32};
 104
 105 float get_mono(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
 106 {
 107     DWORD channels = dsb->pwfx->nChannels;
 108     DWORD c;
 109     float val = 0;
 110     /* XXX: does Windows include LFE into the mix? */
 111     for (c = 0; c < channels; c++)
 112         val += dsb->get_aux(dsb, pos, c);
 113     val /= channels;
 114     return val;
 115 }
 116
 117 static inline unsigned char f_to_8(float value)
 118 {
 119     if(value <= -1.f)
 120         return 0;
 121     if(value >= 1.f * 0x7f / 0x80)
 122         return 0xFF;
 123     return lrintf((value + 1.f) * 0x80);
 124 }
 125
 126 static inline SHORT f_to_16(float value)
 127 {
 128     if(value <= -1.f)
 129         return 0x8000;
 130     if(value >= 1.f * 0x7FFF / 0x8000)
 131         return 0x7FFF;
 132     return le16(lrintf(value * 0x8000));
 133 }
 134
 135 static LONG f_to_24(float value)
 136 {
 137     if(value <= -1.f)
 138         return 0x80000000;
 139     if(value >= 1.f * 0x7FFFFF / 0x800000)
 140         return 0x7FFFFF00;
 141     return lrintf(value * 0x80000000U);
 142 }
 143
 144 static inline LONG f_to_32(float value)
 145 {
 146     if(value <= -1.f)
 147         return 0x80000000;
 148     if(value >= 1.f * 0x7FFFFFFF / 0x80000000U)  /* this rounds to 1.f */
 149         return 0x7FFFFFFF;
 150     return le32(lrintf(value * 0x80000000U));
 151 }
 152
 153 void putieee32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value)
 154 {
 155     BYTE *buf = (BYTE *)dsb->device->tmp_buffer;
 156     float *fbuf = (float*)(buf + pos + sizeof(float) * channel);
 157     *fbuf = value;
 158 }
 159
 160 void put_mono2stereo(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value)
 161 {
 162     dsb->put_aux(dsb, pos, 0, value);
 163     dsb->put_aux(dsb, pos, 1, value);
 164 }
 165
 166 void put_mono2quad(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value)
 167 {
 168     dsb->put_aux(dsb, pos, 0, value);
 169     dsb->put_aux(dsb, pos, 1, value);
 170     dsb->put_aux(dsb, pos, 2, value);
 171     dsb->put_aux(dsb, pos, 3, value);
 172 }
 173
 174 void put_stereo2quad(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value)
 175 {
 176     if (channel == 0) { /* Left */
 177         dsb->put_aux(dsb, pos, 0, value); /* Front left */
 178         dsb->put_aux(dsb, pos, 2, value); /* Back left */
 179     } else if (channel == 1) { /* Right */
 180         dsb->put_aux(dsb, pos, 1, value); /* Front right */
 181         dsb->put_aux(dsb, pos, 3, value); /* Back right */
 182     }
 183 }
 184
 185 void put_mono2surround51(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value)
 186 {
 187     dsb->put_aux(dsb, pos, 0, value);
 188     dsb->put_aux(dsb, pos, 1, value);
 189     dsb->put_aux(dsb, pos, 2, value);
 190     dsb->put_aux(dsb, pos, 3, value);
 191     dsb->put_aux(dsb, pos, 4, value);
 192     dsb->put_aux(dsb, pos, 5, value);
 193 }
 194
 195 void put_stereo2surround51(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value)
 196 {
 197     if (channel == 0) { /* Left */
 198         dsb->put_aux(dsb, pos, 0, value); /* Front left */
 199         dsb->put_aux(dsb, pos, 4, value); /* Back left */
 200
 201         dsb->put_aux(dsb, pos, 2, 0.0f); /* Mute front centre */
 202         dsb->put_aux(dsb, pos, 3, 0.0f); /* Mute LFE */
 203     } else if (channel == 1) { /* Right */
 204         dsb->put_aux(dsb, pos, 1, value); /* Front right */
 205         dsb->put_aux(dsb, pos, 5, value); /* Back right */
 206     }
 207 }
 208
 209 void mixieee32(float *src, float *dst, unsigned samples)
 210 {
 211     TRACE("%p - %p %d\n", src, dst, samples);
 212     while (samples--)
 213         *(dst++) += *(src++);
 214 }
 215
 216 static void norm8(float *src, unsigned char *dst, unsigned len)
 217 {
 218     TRACE("%p - %p %d\n", src, dst, len);
 219     while (len--)
 220     {
 221         *dst = f_to_8(*src);
 222         ++dst;
 223         ++src;
 224     }
 225 }
 226
 227 static void norm16(float *src, SHORT *dst, unsigned len)
 228 {
 229     TRACE("%p - %p %d\n", src, dst, len);
 230     len /= 2;
 231     while (len--)
 232     {
 233         *dst = f_to_16(*src);
 234         ++dst;
 235         ++src;
 236     }
 237 }
 238
 239 static void norm24(float *src, BYTE *dst, unsigned len)
 240 {
 241     TRACE("%p - %p %d\n", src, dst, len);
 242     len /= 3;
 243     while (len--)
 244     {
 245         LONG t = f_to_24(*src);
 246         dst[0] = (t >> 8) & 0xFF;
 247         dst[1] = (t >> 16) & 0xFF;
 248         dst[2] = t >> 24;
 249         dst += 3;
 250         ++src;
 251     }
 252 }
 253
 254 static void norm32(float *src, INT *dst, unsigned len)
 255 {
 256     TRACE("%p - %p %d\n", src, dst, len);
 257     len /= 4;
 258     while (len--)
 259     {
 260         *dst = f_to_32(*src);
 261         ++dst;
 262         ++src;
 263     }
 264 }
 265
 266 const normfunc normfunctions[5] = {
 267     (normfunc)norm8,
 268     (normfunc)norm16,
 269     (normfunc)norm24,
 270     (normfunc)norm32,
 271 };