dsound_convert.c 6.46 KB
Newer Older
1 2 3
/* DirectSound format conversion and mixing routines
 *
 * Copyright 2007 Maarten Lankhorst
4
 * Copyright 2011 Owen Rudge for CodeWeavers
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

/* 8 bits is unsigned, the rest is signed.
 * First I tried to reuse existing stuff from alsa-lib, after that
 * didn't work, I gave up and just went for individual hacks.
 *
 * 24 bit is expensive to do, due to unaligned access.
 * In dlls/winex11.drv/dib_convert.c convert_888_to_0888_asis there is a way
 * around it, but I'm happy current code works, maybe something for later.
 *
 * The ^ 0x80 flips the signed bit, this is the conversion from
 * signed (-128.. 0.. 127) to unsigned (0...255)
 * This is only temporary: All 8 bit data should be converted to signed.
 * then when fed to the sound card, it should be converted to unsigned again.
 *
 * Sound is LITTLE endian
 */

#include "config.h"
38

39
#include <stdarg.h>
40
#include <math.h>
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

#define NONAMELESSSTRUCT
#define NONAMELESSUNION
#include "windef.h"
#include "winbase.h"
#include "mmsystem.h"
#include "winternl.h"
#include "wine/debug.h"
#include "dsound.h"
#include "dsound_private.h"

WINE_DEFAULT_DEBUG_CHANNEL(dsound);

#ifdef WORDS_BIGENDIAN
#define le16(x) RtlUshortByteSwap((x))
#define le32(x) RtlUlongByteSwap((x))
#else
#define le16(x) (x)
#define le32(x) (x)
#endif

62
static float get8(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
63
{
64 65 66
    const BYTE* buf = dsb->buffer->memory;
    buf += pos + channel;
    return (buf[0] - 0x80) / (float)0x80;
67 68
}

69
static float get16(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
70
{
71 72 73 74
    const BYTE* buf = dsb->buffer->memory;
    const SHORT *sbuf = (const SHORT*)(buf + pos + 2 * channel);
    SHORT sample = (SHORT)le16(*sbuf);
    return sample / (float)0x8000;
75 76
}

77
static float get24(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
78
{
79 80 81 82 83 84 85 86
    LONG sample;
    const BYTE* buf = dsb->buffer->memory;
    buf += pos + 3 * channel;
    /* The next expression deliberately has an overflow for buf[2] >= 0x80,
       this is how negative values are made.
     */
    sample = (buf[0] << 8) | (buf[1] << 16) | (buf[2] << 24);
    return sample / (float)0x80000000U;
87 88
}

89
static float get32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
90
{
91 92 93 94
    const BYTE* buf = dsb->buffer->memory;
    const LONG *sbuf = (const LONG*)(buf + pos + 4 * channel);
    LONG sample = le32(*sbuf);
    return sample / (float)0x80000000U;
95 96
}

97
static float getieee32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
98
{
99 100 101 102
    const BYTE* buf = dsb->buffer->memory;
    const float *sbuf = (const float*)(buf + pos + 4 * channel);
    /* The value will be clipped later, when put into some non-float buffer */
    return *sbuf;
103 104
}

105
const bitsgetfunc getbpp[5] = {get8, get16, get24, get32, getieee32};
106

107 108 109 110 111 112 113 114 115 116 117 118
float get_mono(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
{
    DWORD channels = dsb->pwfx->nChannels;
    DWORD c;
    float val = 0;
    /* XXX: does Windows include LFE into the mix? */
    for (c = 0; c < channels; c++)
        val += dsb->get_aux(dsb, pos, c);
    val /= channels;
    return val;
}

119 120 121 122 123 124 125 126 127 128 129
static inline unsigned char f_to_8(float value)
{
    if(value <= -1.f)
        return 0;
    if(value >= 1.f * 0x7f / 0x80)
        return 0xFF;
    return lrintf((value + 1.f) * 0x80);
}

static inline SHORT f_to_16(float value)
{
130
    if(value <= -1.f)
131 132 133 134
        return 0x8000;
    if(value >= 1.f * 0x7FFF / 0x8000)
        return 0x7FFF;
    return le16(lrintf(value * 0x8000));
135 136
}

137 138
static LONG f_to_24(float value)
{
139
    if(value <= -1.f)
140 141 142 143
        return 0x80000000;
    if(value >= 1.f * 0x7FFFFF / 0x800000)
        return 0x7FFFFF00;
    return lrintf(value * 0x80000000U);
144 145
}

146 147 148 149 150 151 152 153 154
static inline LONG f_to_32(float value)
{
    if(value <= -1.f)
        return 0x80000000;
    if(value >= 1.f * 0x7FFFFFFF / 0x80000000U)  /* this rounds to 1.f */
        return 0x7FFFFFFF;
    return le32(lrintf(value * 0x80000000U));
}

155
void putieee32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value)
156
{
157 158 159
    BYTE *buf = (BYTE *)dsb->device->tmp_buffer;
    float *fbuf = (float*)(buf + pos + sizeof(float) * channel);
    *fbuf = value;
160 161
}

162 163 164 165 166 167
void put_mono2stereo(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value)
{
    dsb->put_aux(dsb, pos, 0, value);
    dsb->put_aux(dsb, pos, 1, value);
}

168
void mixieee32(float *src, float *dst, unsigned samples)
169
{
170 171
    TRACE("%p - %p %d\n", src, dst, samples);
    while (samples--)
172
        *(dst++) += *(src++);
173 174
}

175
static void norm8(float *src, unsigned char *dst, unsigned len)
176 177 178 179
{
    TRACE("%p - %p %d\n", src, dst, len);
    while (len--)
    {
180
        *dst = f_to_8(*src);
181 182 183 184 185
        ++dst;
        ++src;
    }
}

186
static void norm16(float *src, SHORT *dst, unsigned len)
187 188 189 190 191
{
    TRACE("%p - %p %d\n", src, dst, len);
    len /= 2;
    while (len--)
    {
192
        *dst = f_to_16(*src);
193 194 195 196 197
        ++dst;
        ++src;
    }
}

198
static void norm24(float *src, BYTE *dst, unsigned len)
199 200 201 202 203
{
    TRACE("%p - %p %d\n", src, dst, len);
    len /= 3;
    while (len--)
    {
204 205 206 207
        LONG t = f_to_24(*src);
        dst[0] = (t >> 8) & 0xFF;
        dst[1] = (t >> 16) & 0xFF;
        dst[2] = t >> 24;
208
        dst += 3;
209 210 211 212
        ++src;
    }
}

213
static void norm32(float *src, INT *dst, unsigned len)
214 215 216 217 218
{
    TRACE("%p - %p %d\n", src, dst, len);
    len /= 4;
    while (len--)
    {
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
        *dst = f_to_32(*src);
        ++dst;
        ++src;
    }
}

static void normieee32(float *src, float *dst, unsigned len)
{
    TRACE("%p - %p %d\n", src, dst, len);
    len /= 4;
    while (len--)
    {
        if(*src > 1)
            *dst = 1;
        else if(*src < -1)
            *dst = -1;
        else
            *dst = *src;
237 238 239 240 241
        ++dst;
        ++src;
    }
}

242
const normfunc normfunctions[5] = {
243 244 245 246
    (normfunc)norm8,
    (normfunc)norm16,
    (normfunc)norm24,
    (normfunc)norm32,
247
    (normfunc)normieee32
248
};