[wxWidgets.git] / src / unix / sound.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        sound.cpp
// Purpose:     wxSound
// Author:      Marcel Rasche, Vaclav Slavik
// Modified by:
// Created:     25/10/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart, Vaclav Slavik
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "sound.h"
#pragma implementation "soundbase.h"
#endif

// for compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#include "wx/setup.h"

#if defined(__BORLANDC__)
#pragma hdrstop
#endif

#if wxUSE_WAVE

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>

#if HAVE_SYS_SOUNDCARD_H
#include <sys/soundcard.h>
#endif

#ifndef WX_PRECOMP
    #include "wx/event.h"
    #include "wx/intl.h"
    #include "wx/log.h"
#endif

#include "wx/thread.h"
#include "wx/file.h"
#include "wx/module.h"
#include "wx/sound.h"
#include "wx/dynlib.h"

// ----------------------------------------------------------------------------
// wxSoundBackendNull, used in absence of audio API or card
// ----------------------------------------------------------------------------

class wxSoundBackendNull : public wxSoundBackend
{
public:
    wxString GetName() const { return _("No sound"); }
    int GetPriority() const { return 0; }
    bool IsAvailable() const { return true; }
    bool HasNativeAsyncPlayback() const { return true; }
    bool Play(wxSoundData *WXUNUSED(data), unsigned WXUNUSED(flags))
        { return true; }
};


// ----------------------------------------------------------------------------
// wxSoundBackendOSS, for Linux
// ----------------------------------------------------------------------------

#ifdef HAVE_SYS_SOUNDCARD_H

#ifndef AUDIODEV
#define AUDIODEV   "/dev/dsp"    // Default path for audio device
#endif

class wxSoundBackendOSS : public wxSoundBackend
{
public:
    wxString GetName() const { return _T("Open Sound System"); }
    int GetPriority() const { return 10; }
    bool IsAvailable() const;
    bool HasNativeAsyncPlayback() const { return false; }
    bool Play(wxSoundData *data, unsigned flags);

private:
    int OpenDSP(const wxSoundData *data);
    bool InitDSP(int dev, int iDataBits, int iChannel,
                 unsigned long ulSamplingRate);
    
    int m_DSPblkSize;        // Size of the DSP buffer
};

bool wxSoundBackendOSS::IsAvailable() const
{
    int fd;
    fd = open(AUDIODEV, O_WRONLY | O_NONBLOCK);
    if (fd < 0)
        return false;
    close(fd);
    return true;
}

bool wxSoundBackendOSS::Play(wxSoundData *data, unsigned flags)
{
    int dev = OpenDSP(data);
    
    if (dev < 0)
        return false;

    ioctl(dev, SNDCTL_DSP_SYNC, 0);
 
    do
    {
        bool play = true;
        int i;
        unsigned l = 0;
        size_t datasize = data->m_dataBytes;

        do
        {
            i= (int)((l + m_DSPblkSize) < datasize ?
                    m_DSPblkSize : (datasize - l));
            if (write(dev, &data->m_data[l], i) != i)
            {
                play = false;
            }
            l += i;
        } while (play && l < datasize);
    } while (flags & wxSOUND_LOOP);

    close(dev);
    return true;
}

int wxSoundBackendOSS::OpenDSP(const wxSoundData *data)
{
    int dev = -1;
  
    if ((dev = open(AUDIODEV, O_WRONLY, 0)) <0)
        return -1;
  
    if (!InitDSP(dev,
                 (int)data->m_bitsPerSample,
                 data->m_channels == 1 ? 0 : 1,
                 data->m_samplingRate))
    {
        close(dev);
        return -1;
    }

    return dev;
}

bool wxSoundBackendOSS::InitDSP(int dev, int iDataBits, int iChannel,
                               unsigned long ulSamplingRate)
{
    if (ioctl(dev, SNDCTL_DSP_GETBLKSIZE, &m_DSPblkSize) < 0)
        return false;
    if (m_DSPblkSize < 4096 || m_DSPblkSize > 65536)
        return false;
    if (ioctl(dev, SNDCTL_DSP_SAMPLESIZE, &iDataBits) < 0)
        return false;
    if (ioctl(dev, SNDCTL_DSP_STEREO, &iChannel) < 0)
        return false;
    if (ioctl(dev, SNDCTL_DSP_SPEED, &ulSamplingRate) < 0)
        return false;
    return true;
}

#endif // HAVE_SYS_SOUNDCARD_H


// ----------------------------------------------------------------------------
// wxSoundData
// ----------------------------------------------------------------------------
  
void wxSoundData::IncRef()
{
    m_refCnt++;
}

void wxSoundData::DecRef()
{
    if (--m_refCnt == 0)
        delete this;
}

wxSoundData::~wxSoundData()
{
    delete[] m_dataWithHeader;
}


// ----------------------------------------------------------------------------
// wxSoundAsyncPlaybackThread
// ----------------------------------------------------------------------------

#if wxUSE_THREADS

// mutex for all wxSound's synchronization
static wxMutex gs_soundMutex;

// this class manages asynchronous playback of audio if the backend doesn't
// support it natively (e.g. OSS backend)
class wxSoundAsyncPlaybackThread : public wxThread
{
public:
    wxSoundAsyncPlaybackThread(wxSoundBackend *backend,
                              wxSoundData *data, unsigned flags)
        : wxThread(), m_backend(backend), m_data(data), m_flags(flags) {}
    virtual ExitCode Entry()
    {
        m_backend->Play(m_data, m_flags & ~wxSOUND_ASYNC);
        wxMutexLocker locker(gs_soundMutex);
        m_data->DecRef();
        wxLogTrace(_T("sound"), _T("terminated async playback thread"));
        return 0;
    }
    
protected:
    wxSoundBackend *m_backend;
    wxSoundData *m_data;
    unsigned m_flags;
};

#endif // wxUSE_THREADS

// ----------------------------------------------------------------------------
// wxSound 
// ----------------------------------------------------------------------------

wxSoundBackend *wxSound::ms_backend = NULL;

// FIXME - temporary, until we have plugins architecture
#if wxUSE_LIBSDL
    #if wxUSE_PLUGINS
        wxDynamicLibrary *wxSound::ms_backendSDL = NULL;
    #else
        extern "C" wxSoundBackend *wxCreateSoundBackendSDL();
    #endif
#endif

wxSound::wxSound() : m_data(NULL)
{
}

wxSound::wxSound(const wxString& sFileName, bool isResource) : m_data(NULL)
{
    Create(sFileName, isResource);
}

wxSound::wxSound(int size, const wxByte* data) : m_data(NULL)
{
    Create(size, data);
}

wxSound::~wxSound()
{
    Free();
}

bool wxSound::Create(const wxString& fileName, bool isResource)
{
    wxASSERT_MSG( !isResource,
             _T("Loading sound from resources is only supported on Windows") );
 
    Free();
  
    wxFile fileWave;
    if (!fileWave.Open(fileName, wxFile::read))
	{
            return false;
	}

    size_t len = fileWave.Length();
    wxUint8 *data = new wxUint8[len];
    if (fileWave.Read(data, len) != len)
    {
        wxLogError(_("Couldn't load sound data from '%s'."), fileName.c_str());
        return false;
    }

    if (!LoadWAV(data, len, false))
    {
        wxLogError(_("Sound file '%s' is in unsupported format."),
                   fileName.c_str());
        return false;
    }
    
    return true;
}

bool wxSound::Create(int size, const wxByte* data)
{
    wxASSERT( data != NULL );

    Free();
    if (!LoadWAV(data, size, true))
    {
        wxLogError(_("Sound data are in unsupported format."));
        return false;
    }
    return true;
}

/*static*/ void wxSound::EnsureBackend()
{
    if (!ms_backend)
    {
        // FIXME -- make this fully dynamic when plugins architecture is in
        // place
#ifdef HAVE_SYS_SOUNDCARD_H
        ms_backend = new wxSoundBackendOSS();
        if (!ms_backend->IsAvailable())
        {
            wxDELETE(ms_backend);
        }
#endif

#if wxUSE_LIBSDL
        if (!ms_backend)
        {
#if !wxUSE_PLUGINS
            ms_backend = wxCreateSoundBackendSDL();
#else
            wxString dllname;
            dllname.Printf(_T("%s/%s"),
                wxDynamicLibrary::GetPluginsDirectory().c_str(),
                wxDynamicLibrary::CanonicalizePluginName(
                    _T("sound_sdl"), wxDL_PLUGIN_BASE).c_str());
            wxLogTrace(_T("sound"),
                       _T("trying to load SDL plugin from '%s'..."),
                       dllname.c_str());
            wxLogNull null;
            ms_backendSDL = new wxDynamicLibrary(dllname, wxDL_NOW);
            if (!ms_backendSDL->IsLoaded())
            {
                wxDELETE(ms_backendSDL);
            }
            else
            {
                typedef wxSoundBackend *(*wxCreateSoundBackend_t)();
                wxDYNLIB_FUNCTION(wxCreateSoundBackend_t,
                                  wxCreateSoundBackendSDL, *ms_backendSDL);
                if (pfnwxCreateSoundBackendSDL)
                {
                    ms_backend = (*pfnwxCreateSoundBackendSDL)();
                }
            }
#endif
            if (ms_backend && !ms_backend->IsAvailable())
            {
                wxDELETE(ms_backend);
            }
        }
#endif

        if (!ms_backend)
            ms_backend = new wxSoundBackendNull();

        wxLogTrace(_T("sound"),
                   _T("using backend '%s'"), ms_backend->GetName().c_str());
    }
}

/*static*/ void wxSound::UnloadBackend()
{
    if (ms_backend)
    {
        wxLogTrace(_T("sound"), _T("unloading backend"));
        delete ms_backend;
        ms_backend = NULL;
#if wxUSE_LIBSDL && wxUSE_PLUGINS
        delete ms_backendSDL;
#endif
    }
}

bool wxSound::DoPlay(unsigned flags)
{
    wxCHECK_MSG( IsOk(), false, _T("Attempt to play invalid wave data") );

    EnsureBackend();

    if ((flags & wxSOUND_ASYNC) && !ms_backend->HasNativeAsyncPlayback())
    {
#if wxUSE_THREADS
        wxMutexLocker locker(gs_soundMutex);
        m_data->IncRef();
        wxThread *th = new wxSoundAsyncPlaybackThread(ms_backend, m_data, flags);
        th->Create();
        th->Run();
        wxLogTrace(_T("sound"), _T("launched async playback thread"));
#else
        wxLogError(_("Unable to play sound asynchronously."));
        return false;
#endif
    }
    else
    {
        ms_backend->Play(m_data, flags);
    }
    return true;
}

void wxSound::Free()
{
#if wxUSE_THREADS
    wxMutexLocker locker(gs_soundMutex);
#endif
    if (m_data)
        m_data->DecRef();
}

typedef struct
{ 
    wxUint32      uiSize;
    wxUint16      uiFormatTag;
    wxUint16      uiChannels;
    wxUint32      ulSamplesPerSec;
    wxUint32      ulAvgBytesPerSec;
    wxUint16      uiBlockAlign;
    wxUint16      uiBitsPerSample;
} WAVEFORMAT;    

#define MONO             1  // and stereo is 2 by wav format
#define WAVE_FORMAT_PCM  1
#define WAVE_INDEX       8
#define FMT_INDEX       12

bool wxSound::LoadWAV(const wxUint8 *data, size_t length, bool copyData)
{
    WAVEFORMAT waveformat;
    wxUint32 ul;

    if (length < 32 + sizeof(WAVEFORMAT))
        return false;

    memcpy(&waveformat, &data[FMT_INDEX + 4], sizeof(WAVEFORMAT));
    waveformat.uiSize = wxUINT32_SWAP_ON_BE(waveformat.uiSize);
    waveformat.uiFormatTag = wxUINT16_SWAP_ON_BE(waveformat.uiFormatTag);
    waveformat.uiChannels = wxUINT16_SWAP_ON_BE(waveformat.uiChannels);
    waveformat.ulSamplesPerSec = wxUINT32_SWAP_ON_BE(waveformat.ulSamplesPerSec);
    waveformat.ulAvgBytesPerSec = wxUINT32_SWAP_ON_BE(waveformat.ulAvgBytesPerSec);
    waveformat.uiBlockAlign = wxUINT16_SWAP_ON_BE(waveformat.uiBlockAlign);
    waveformat.uiBitsPerSample = wxUINT16_SWAP_ON_BE(waveformat.uiBitsPerSample);

    if (memcmp(data, "RIFF", 4) != 0)
        return false;
    if (memcmp(&data[WAVE_INDEX], "WAVE", 4) != 0)
        return false;
    if (memcmp(&data[FMT_INDEX], "fmt ", 4) != 0)
        return false;
    if (memcmp(&data[FMT_INDEX + waveformat.uiSize + 8], "data", 4) != 0)
        return false;
    memcpy(&ul,&data[FMT_INDEX + waveformat.uiSize + 12], 4);
    ul = wxUINT32_SWAP_ON_BE(ul);
    
    //WAS: if (ul + FMT_INDEX + waveformat.uiSize + 16 != length)
    if (ul + FMT_INDEX + waveformat.uiSize + 16 > length)
        return false;
  
    if (waveformat.uiFormatTag != WAVE_FORMAT_PCM)
        return false;
  
    if (waveformat.ulSamplesPerSec != 
        waveformat.ulAvgBytesPerSec / waveformat.uiBlockAlign)
        return false;
    
    m_data = new wxSoundData;
    m_data->m_channels = waveformat.uiChannels;
    m_data->m_samplingRate = waveformat.ulSamplesPerSec;
    m_data->m_bitsPerSample = waveformat.uiBitsPerSample;
    m_data->m_samples = ul / (m_data->m_channels * m_data->m_bitsPerSample / 8);
    m_data->m_dataBytes = ul;

    if (copyData)
    {
        m_data->m_dataWithHeader = new wxUint8[length];
        memcpy(m_data->m_dataWithHeader, data, length);
    }
    else
        m_data->m_dataWithHeader = (wxUint8*)data;

    m_data->m_data = 
        (&m_data->m_dataWithHeader[FMT_INDEX + waveformat.uiSize + 8]);

    return true;
}


// ----------------------------------------------------------------------------
// wxSoundCleanupModule
// ----------------------------------------------------------------------------

class wxSoundCleanupModule: public wxModule
{
public:
    bool OnInit() { return true; }
    void OnExit() { wxSound::UnloadBackend(); }
    DECLARE_DYNAMIC_CLASS(wxSoundCleanupModule)
};

IMPLEMENT_DYNAMIC_CLASS(wxSoundCleanupModule, wxModule)

#endif
Commit	Line	Data
9be32e8f VS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: sound.cpp
	3	// Purpose: wxSound
	4	// Author: Marcel Rasche, Vaclav Slavik
	5	// Modified by:
	6	// Created: 25/10/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart, Vaclav Slavik
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
	13	#pragma implementation "sound.h"
	14	#pragma implementation "soundbase.h"
	15	#endif
	16
	17	// for compilers that support precompilation, includes "wx.h".
	18	#include "wx/wxprec.h"
	19
	20	#include "wx/setup.h"
	21
	22	#if defined(__BORLANDC__)
	23	#pragma hdrstop
	24	#endif
	25
	26	#if wxUSE_WAVE
	27
	28	#include <stdio.h>
	29	#include <unistd.h>
	30	#include <fcntl.h>
	31	#include <sys/ioctl.h>
	32
	33	#if HAVE_SYS_SOUNDCARD_H
	34	#include <sys/soundcard.h>
	35	#endif
	36
	37	#ifndef WX_PRECOMP
	38	#include "wx/event.h"
	39	#include "wx/intl.h"
	40	#include "wx/log.h"
	41	#endif
	42
	43	#include "wx/thread.h"
	44	#include "wx/file.h"
	45	#include "wx/module.h"
	46	#include "wx/sound.h"
	47	#include "wx/dynlib.h"
	48
	49	// ----------------------------------------------------------------------------
	50	// wxSoundBackendNull, used in absence of audio API or card
	51	// ----------------------------------------------------------------------------
	52
	53	class wxSoundBackendNull : public wxSoundBackend
	54	{
	55	public:
	56	wxString GetName() const { return _("No sound"); }
	57	int GetPriority() const { return 0; }
	58	bool IsAvailable() const { return true; }
	59	bool HasNativeAsyncPlayback() const { return true; }
	60	bool Play(wxSoundData *WXUNUSED(data), unsigned WXUNUSED(flags))
	61	{ return true; }
	62	};
	63
	64
65	// ----------------------------------------------------------------------------
66	// wxSoundBackendOSS, for Linux
67	// ----------------------------------------------------------------------------
68
69	#ifdef HAVE_SYS_SOUNDCARD_H
70
71	#ifndef AUDIODEV
72	#define AUDIODEV "/dev/dsp" // Default path for audio device
73	#endif
74
75	class wxSoundBackendOSS : public wxSoundBackend
76	{
77	public:
78	wxString GetName() const { return _T("Open Sound System"); }
79	int GetPriority() const { return 10; }
80	bool IsAvailable() const;
81	bool HasNativeAsyncPlayback() const { return false; }
82	bool Play(wxSoundData *data, unsigned flags);
83
84	private:
85	int OpenDSP(const wxSoundData *data);
86	bool InitDSP(int dev, int iDataBits, int iChannel,
87	unsigned long ulSamplingRate);
88
89	int m_DSPblkSize; // Size of the DSP buffer
90	};
91
92	bool wxSoundBackendOSS::IsAvailable() const
93	{
94	int fd;
95	fd = open(AUDIODEV, O_WRONLY \| O_NONBLOCK);
96	if (fd < 0)
97	return false;
98	close(fd);
99	return true;
100	}
101
102	bool wxSoundBackendOSS::Play(wxSoundData *data, unsigned flags)
103	{
104	int dev = OpenDSP(data);
105
106	if (dev < 0)
107	return false;
108
109	ioctl(dev, SNDCTL_DSP_SYNC, 0);
110
111	do
112	{
113	bool play = true;
114	int i;
115	unsigned l = 0;
116	size_t datasize = data->m_dataBytes;
117
118	do
119	{
120	i= (int)((l + m_DSPblkSize) < datasize ?
121	m_DSPblkSize : (datasize - l));
122	if (write(dev, &data->m_data[l], i) != i)
123	{
124	play = false;
125	}
126	l += i;
127	} while (play && l < datasize);
128	} while (flags & wxSOUND_LOOP);
129
130	close(dev);
131	return true;
132	}
133
134	int wxSoundBackendOSS::OpenDSP(const wxSoundData *data)
135	{
136	int dev = -1;
137
138	if ((dev = open(AUDIODEV, O_WRONLY, 0)) <0)
139	return -1;
140
141	if (!InitDSP(dev,
142	(int)data->m_bitsPerSample,
143	data->m_channels == 1 ? 0 : 1,
144	data->m_samplingRate))
145	{
146	close(dev);
147	return -1;
148	}
149
150	return dev;
151	}
152
153	bool wxSoundBackendOSS::InitDSP(int dev, int iDataBits, int iChannel,
154	unsigned long ulSamplingRate)
155	{
156	if (ioctl(dev, SNDCTL_DSP_GETBLKSIZE, &m_DSPblkSize) < 0)
157	return false;
158	if (m_DSPblkSize < 4096 \|\| m_DSPblkSize > 65536)
159	return false;
160	if (ioctl(dev, SNDCTL_DSP_SAMPLESIZE, &iDataBits) < 0)
161	return false;
162	if (ioctl(dev, SNDCTL_DSP_STEREO, &iChannel) < 0)
163	return false;
164	if (ioctl(dev, SNDCTL_DSP_SPEED, &ulSamplingRate) < 0)
165	return false;
166	return true;
167	}
168
169	#endif // HAVE_SYS_SOUNDCARD_H
170
171
172	// ----------------------------------------------------------------------------
173	// wxSoundData
174	// ----------------------------------------------------------------------------
175
176	void wxSoundData::IncRef()
177	{
178	m_refCnt++;
179	}
180
181	void wxSoundData::DecRef()
182	{
183	if (--m_refCnt == 0)
184	delete this;
185	}
186
187	wxSoundData::~wxSoundData()
188	{
189	delete[] m_dataWithHeader;
190	}
191
192
193	// ----------------------------------------------------------------------------
194	// wxSoundAsyncPlaybackThread
195	// ----------------------------------------------------------------------------
196
197	#if wxUSE_THREADS
198
199	// mutex for all wxSound's synchronization
200	static wxMutex gs_soundMutex;
201
202	// this class manages asynchronous playback of audio if the backend doesn't
203	// support it natively (e.g. OSS backend)
204	class wxSoundAsyncPlaybackThread : public wxThread
205	{
206	public:
207	wxSoundAsyncPlaybackThread(wxSoundBackend *backend,
208	wxSoundData *data, unsigned flags)
209	: wxThread(), m_backend(backend), m_data(data), m_flags(flags) {}
210	virtual ExitCode Entry()
211	{
212	m_backend->Play(m_data, m_flags & ~wxSOUND_ASYNC);
213	wxMutexLocker locker(gs_soundMutex);
214	m_data->DecRef();
215	wxLogTrace(_T("sound"), _T("terminated async playback thread"));
216	return 0;
217	}
218
219	protected:
220	wxSoundBackend *m_backend;
221	wxSoundData *m_data;
222	unsigned m_flags;
223	};
224
225	#endif // wxUSE_THREADS
226
227	// ----------------------------------------------------------------------------
228	// wxSound
229	// ----------------------------------------------------------------------------
230
231	wxSoundBackend *wxSound::ms_backend = NULL;
232
233	// FIXME - temporary, until we have plugins architecture
234	#if wxUSE_LIBSDL
235	#if wxUSE_PLUGINS
236	wxDynamicLibrary *wxSound::ms_backendSDL = NULL;
237	#else
238	extern "C" wxSoundBackend *wxCreateSoundBackendSDL();
239	#endif
240	#endif
241
242	wxSound::wxSound() : m_data(NULL)
243	{
244	}
245
246	wxSound::wxSound(const wxString& sFileName, bool isResource) : m_data(NULL)
247	{
248	Create(sFileName, isResource);
249	}
250
251	wxSound::wxSound(int size, const wxByte* data) : m_data(NULL)
252	{
253	Create(size, data);
254	}
255
256	wxSound::~wxSound()
257	{
258	Free();
259	}
260
261	bool wxSound::Create(const wxString& fileName, bool isResource)
262	{
263	wxASSERT_MSG( !isResource,
264	_T("Loading sound from resources is only supported on Windows") );
265
266	Free();
267
268	wxFile fileWave;
269	if (!fileWave.Open(fileName, wxFile::read))
270	{
271	return false;
272	}
273
274	size_t len = fileWave.Length();
275	wxUint8 *data = new wxUint8[len];
276	if (fileWave.Read(data, len) != len)
277	{
278	wxLogError(_("Couldn't load sound data from '%s'."), fileName.c_str());
279	return false;
280	}
281
282	if (!LoadWAV(data, len, false))
283	{
284	wxLogError(_("Sound file '%s' is in unsupported format."),
285	fileName.c_str());
286	return false;
287	}
288
289	return true;
290	}
291
292	bool wxSound::Create(int size, const wxByte* data)
293	{
294	wxASSERT( data != NULL );
295
296	Free();
297	if (!LoadWAV(data, size, true))
298	{
299	wxLogError(_("Sound data are in unsupported format."));
300	return false;
301	}
302	return true;
303	}
304
305	/static/ void wxSound::EnsureBackend()
306	{
307	if (!ms_backend)
308	{
309	// FIXME -- make this fully dynamic when plugins architecture is in
310	// place
311	#ifdef HAVE_SYS_SOUNDCARD_H
312	ms_backend = new wxSoundBackendOSS();
313	if (!ms_backend->IsAvailable())
314	{
315	wxDELETE(ms_backend);
316	}
317	#endif
318
319	#if wxUSE_LIBSDL
320	if (!ms_backend)
321	{
322	#if !wxUSE_PLUGINS
323	ms_backend = wxCreateSoundBackendSDL();
324	#else
325	wxString dllname;
326	dllname.Printf(_T("%s/%s"),
327	wxDynamicLibrary::GetPluginsDirectory().c_str(),
328	wxDynamicLibrary::CanonicalizePluginName(
329	_T("sound_sdl"), wxDL_PLUGIN_BASE).c_str());
330	wxLogTrace(_T("sound"),
331	_T("trying to load SDL plugin from '%s'..."),
332	dllname.c_str());
333	wxLogNull null;
334	ms_backendSDL = new wxDynamicLibrary(dllname, wxDL_NOW);
335	if (!ms_backendSDL->IsLoaded())
336	{
337	wxDELETE(ms_backendSDL);
338	}
339	else
340	{
341	typedef wxSoundBackend (wxCreateSoundBackend_t)();
342	wxDYNLIB_FUNCTION(wxCreateSoundBackend_t,
343	wxCreateSoundBackendSDL, *ms_backendSDL);
344	if (pfnwxCreateSoundBackendSDL)
345	{
346	ms_backend = (*pfnwxCreateSoundBackendSDL)();
347	}
348	}
349	#endif
350	if (ms_backend && !ms_backend->IsAvailable())
351	{
352	wxDELETE(ms_backend);
353	}
354	}
355	#endif
356
357	if (!ms_backend)
358	ms_backend = new wxSoundBackendNull();
359
360	wxLogTrace(_T("sound"),
361	_T("using backend '%s'"), ms_backend->GetName().c_str());
362	}
363	}
364
365	/static/ void wxSound::UnloadBackend()
366	{
367	if (ms_backend)
368	{
369	wxLogTrace(_T("sound"), _T("unloading backend"));
370	delete ms_backend;
371	ms_backend = NULL;
372	#if wxUSE_LIBSDL && wxUSE_PLUGINS
373	delete ms_backendSDL;
374	#endif
375	}
376	}
377
378	bool wxSound::DoPlay(unsigned flags)
379	{
380	wxCHECK_MSG( IsOk(), false, _T("Attempt to play invalid wave data") );
381
382	EnsureBackend();
383
384	if ((flags & wxSOUND_ASYNC) && !ms_backend->HasNativeAsyncPlayback())
385	{
386	#if wxUSE_THREADS
387	wxMutexLocker locker(gs_soundMutex);
388	m_data->IncRef();
389	wxThread *th = new wxSoundAsyncPlaybackThread(ms_backend, m_data, flags);
390	th->Create();
391	th->Run();
392	wxLogTrace(_T("sound"), _T("launched async playback thread"));
393	#else
394	wxLogError(_("Unable to play sound asynchronously."));
395	return false;
396	#endif
397	}
398	else
399	{
400	ms_backend->Play(m_data, flags);
401	}
402	return true;
403	}
404
405	void wxSound::Free()
406	{
407	#if wxUSE_THREADS
408	wxMutexLocker locker(gs_soundMutex);
409	#endif
410	if (m_data)
411	m_data->DecRef();
412	}
413
414	typedef struct
415	{
416	wxUint32 uiSize;
417	wxUint16 uiFormatTag;
418	wxUint16 uiChannels;
419	wxUint32 ulSamplesPerSec;
420	wxUint32 ulAvgBytesPerSec;
421	wxUint16 uiBlockAlign;
422	wxUint16 uiBitsPerSample;
423	} WAVEFORMAT;
424
425	#define MONO 1 // and stereo is 2 by wav format
426	#define WAVE_FORMAT_PCM 1
427	#define WAVE_INDEX 8
428	#define FMT_INDEX 12
429
430	bool wxSound::LoadWAV(const wxUint8 *data, size_t length, bool copyData)
431	{
432	WAVEFORMAT waveformat;
433	wxUint32 ul;
434
435	if (length < 32 + sizeof(WAVEFORMAT))
436	return false;
437
438	memcpy(&waveformat, &data[FMT_INDEX + 4], sizeof(WAVEFORMAT));
439	waveformat.uiSize = wxUINT32_SWAP_ON_BE(waveformat.uiSize);
440	waveformat.uiFormatTag = wxUINT16_SWAP_ON_BE(waveformat.uiFormatTag);
441	waveformat.uiChannels = wxUINT16_SWAP_ON_BE(waveformat.uiChannels);
442	waveformat.ulSamplesPerSec = wxUINT32_SWAP_ON_BE(waveformat.ulSamplesPerSec);
443	waveformat.ulAvgBytesPerSec = wxUINT32_SWAP_ON_BE(waveformat.ulAvgBytesPerSec);
444	waveformat.uiBlockAlign = wxUINT16_SWAP_ON_BE(waveformat.uiBlockAlign);
445	waveformat.uiBitsPerSample = wxUINT16_SWAP_ON_BE(waveformat.uiBitsPerSample);
446
447	if (memcmp(data, "RIFF", 4) != 0)
448	return false;
449	if (memcmp(&data[WAVE_INDEX], "WAVE", 4) != 0)
450	return false;
451	if (memcmp(&data[FMT_INDEX], "fmt ", 4) != 0)
452	return false;
453	if (memcmp(&data[FMT_INDEX + waveformat.uiSize + 8], "data", 4) != 0)
454	return false;
455	memcpy(&ul,&data[FMT_INDEX + waveformat.uiSize + 12], 4);
456	ul = wxUINT32_SWAP_ON_BE(ul);
457
458	//WAS: if (ul + FMT_INDEX + waveformat.uiSize + 16 != length)
459	if (ul + FMT_INDEX + waveformat.uiSize + 16 > length)
460	return false;
461
462	if (waveformat.uiFormatTag != WAVE_FORMAT_PCM)
463	return false;
464
465	if (waveformat.ulSamplesPerSec !=
466	waveformat.ulAvgBytesPerSec / waveformat.uiBlockAlign)
467	return false;
468
469	m_data = new wxSoundData;
470	m_data->m_channels = waveformat.uiChannels;
471	m_data->m_samplingRate = waveformat.ulSamplesPerSec;
472	m_data->m_bitsPerSample = waveformat.uiBitsPerSample;
473	m_data->m_samples = ul / (m_data->m_channels * m_data->m_bitsPerSample / 8);
474	m_data->m_dataBytes = ul;
475
476	if (copyData)
477	{
478	m_data->m_dataWithHeader = new wxUint8[length];
479	memcpy(m_data->m_dataWithHeader, data, length);
480	}
481	else
482	m_data->m_dataWithHeader = (wxUint8*)data;
483
484	m_data->m_data =
485	(&m_data->m_dataWithHeader[FMT_INDEX + waveformat.uiSize + 8]);
486
487	return true;
488	}
489
490
491	// ----------------------------------------------------------------------------
492	// wxSoundCleanupModule
493	// ----------------------------------------------------------------------------
494
495	class wxSoundCleanupModule: public wxModule
496	{
497	public:
498	bool OnInit() { return true; }
499	void OnExit() { wxSound::UnloadBackend(); }
500	DECLARE_DYNAMIC_CLASS(wxSoundCleanupModule)
501	};
502
503	IMPLEMENT_DYNAMIC_CLASS(wxSoundCleanupModule, wxModule)
504
505	#endif