/////////////////////////////////////////////////////////////////////////////
-// Name: sound.cpp
+// Name: src/unix/sound.cpp
// Purpose: wxSound
// Author: Marcel Rasche, Vaclav Slavik
// Modified by:
// 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
+ #pragma hdrstop
#endif
#if wxUSE_SOUND
#include "wx/event.h"
#include "wx/intl.h"
#include "wx/log.h"
+ #include "wx/module.h"
#endif
#include "wx/thread.h"
#include "wx/file.h"
-#include "wx/module.h"
#include "wx/sound.h"
#include "wx/dynlib.h"
class wxSoundBackendOSS : public wxSoundBackend
{
public:
- wxString GetName() const { return _T("Open Sound System"); }
+ wxString GetName() const { return wxT("Open Sound System"); }
int GetPriority() const { return 10; }
bool IsAvailable() const;
bool HasNativeAsyncPlayback() const { return false; }
{
if (status->m_stopRequested)
{
- wxLogTrace(_T("sound"), _T("playback stopped"));
+ wxLogTrace(wxT("sound"), wxT("playback stopped"));
close(dev);
return true;
}
// Reset the dsp
if (ioctl(dev, SNDCTL_DSP_RESET, 0) < 0)
{
- wxLogTrace(_T("sound"), _T("unable to reset dsp"));
+ wxLogTrace(wxT("sound"), wxT("unable to reset dsp"));
return false;
}
tmp = data->m_bitsPerSample;
if (ioctl(dev, SNDCTL_DSP_SAMPLESIZE, &tmp) < 0)
{
- wxLogTrace(_T("sound"), _T("IOCTL failure (SNDCTL_DSP_SAMPLESIZE)"));
+ wxLogTrace(wxT("sound"), wxT("IOCTL failure (SNDCTL_DSP_SAMPLESIZE)"));
return false;
}
if (tmp != data->m_bitsPerSample)
{
- wxLogTrace(_T("sound"),
- _T("Unable to set DSP sample size to %d (wants %d)"),
+ wxLogTrace(wxT("sound"),
+ wxT("Unable to set DSP sample size to %d (wants %d)"),
data->m_bitsPerSample, tmp);
m_needConversion = true;
}
tmp = stereo;
if (ioctl(dev, SNDCTL_DSP_STEREO, &tmp) < 0)
{
- wxLogTrace(_T("sound"), _T("IOCTL failure (SNDCTL_DSP_STEREO)"));
+ wxLogTrace(wxT("sound"), wxT("IOCTL failure (SNDCTL_DSP_STEREO)"));
return false;
}
if (tmp != stereo)
{
- wxLogTrace(_T("sound"), _T("Unable to set DSP to %s."), stereo? _T("stereo"):_T("mono"));
+ wxLogTrace(wxT("sound"), wxT("Unable to set DSP to %s."), stereo? wxT("stereo"):wxT("mono"));
m_needConversion = true;
}
tmp = data->m_samplingRate;
if (ioctl(dev, SNDCTL_DSP_SPEED, &tmp) < 0)
{
- wxLogTrace(_T("sound"), _T("IOCTL failure (SNDCTL_DSP_SPEED)"));
+ wxLogTrace(wxT("sound"), wxT("IOCTL failure (SNDCTL_DSP_SPEED)"));
return false;
}
if (tmp != data->m_samplingRate)
// file rates for something that we can't hear anyways.
if (data->m_samplingRate - tmp > (tmp * .01) ||
tmp - data->m_samplingRate > (tmp * .01)) {
- wxLogTrace(_T("sound"),
- _T("Unable to set DSP sampling rate to %d (wants %d)"),
+ wxLogTrace(wxT("sound"),
+ wxT("Unable to set DSP sampling rate to %d (wants %d)"),
data->m_samplingRate, tmp);
m_needConversion = true;
}
// the sampling rate, etc.
if (ioctl(dev, SNDCTL_DSP_GETBLKSIZE, &m_DSPblkSize) < 0)
{
- wxLogTrace(_T("sound"), _T("IOCTL failure (SNDCTL_DSP_GETBLKSIZE)"));
+ wxLogTrace(wxT("sound"), wxT("IOCTL failure (SNDCTL_DSP_GETBLKSIZE)"));
return false;
}
return true;
public:
wxSoundSyncOnlyAdaptor(wxSoundBackend *backend)
: m_backend(backend), m_playing(false) {}
- ~wxSoundSyncOnlyAdaptor()
+ virtual ~wxSoundSyncOnlyAdaptor()
{
delete m_backend;
}
m_data->DecRef();
m_adapt->m_playing = false;
m_adapt->m_mutexRightToPlay.Unlock();
- wxLogTrace(_T("sound"), _T("terminated async playback thread"));
+ wxLogTrace(wxT("sound"), wxT("terminated async playback thread"));
return 0;
}
#endif
wxThread *th = new wxSoundAsyncPlaybackThread(this, data, flags);
th->Create();
th->Run();
- wxLogTrace(_T("sound"), _T("launched async playback thread"));
+ wxLogTrace(wxT("sound"), wxT("launched async playback thread"));
return true;
#else
wxLogError(_("Unable to play sound asynchronously."));
void wxSoundSyncOnlyAdaptor::Stop()
{
- wxLogTrace(_T("sound"), _T("asking audio to stop"));
+ wxLogTrace(wxT("sound"), wxT("asking audio to stop"));
#if wxUSE_THREADS
// tell the player thread (if running) to stop playback ASAP:
// our request to interrupt playback):
m_mutexRightToPlay.Lock();
m_mutexRightToPlay.Unlock();
- wxLogTrace(_T("sound"), _T("audio was stopped"));
+ wxLogTrace(wxT("sound"), wxT("audio was stopped"));
#endif
}
Create(sFileName, isResource);
}
-wxSound::wxSound(int size, const wxByte* data) : m_data(NULL)
+wxSound::wxSound(size_t size, const void* data) : m_data(NULL)
{
Create(size, data);
}
Free();
}
-bool wxSound::Create(const wxString& fileName, bool isResource)
+bool wxSound::Create(const wxString& fileName,
+ bool WXUNUSED_UNLESS_DEBUG(isResource))
{
wxASSERT_MSG( !isResource,
- _T("Loading sound from resources is only supported on Windows") );
+ wxT("Loading sound from resources is only supported on Windows") );
Free();
size_t len = wx_truncate_cast(size_t, lenOrig);
wxUint8 *data = new wxUint8[len];
- if (fileWave.Read(data, len) != len)
+ if ( fileWave.Read(data, len) != lenOrig )
{
+ delete [] data;
wxLogError(_("Couldn't load sound data from '%s'."), fileName.c_str());
return false;
}
if (!LoadWAV(data, len, false))
{
+ delete [] data;
wxLogError(_("Sound file '%s' is in unsupported format."),
fileName.c_str());
return false;
return true;
}
-bool wxSound::Create(int size, const wxByte* data)
+bool wxSound::Create(size_t size, const void* data)
{
wxASSERT( data != NULL );
ms_backend = wxCreateSoundBackendSDL();
#else
wxString dllname;
- dllname.Printf(_T("%s/%s"),
+ dllname.Printf(wxT("%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'..."),
+ wxT("sound_sdl"), wxDL_PLUGIN_BASE).c_str());
+ wxLogTrace(wxT("sound"),
+ wxT("trying to load SDL plugin from '%s'..."),
dllname.c_str());
wxLogNull null;
ms_backendSDL = new wxDynamicLibrary(dllname, wxDL_NOW);
if (!ms_backend->HasNativeAsyncPlayback())
ms_backend = new wxSoundSyncOnlyAdaptor(ms_backend);
- wxLogTrace(_T("sound"),
- _T("using backend '%s'"), ms_backend->GetName().c_str());
+ wxLogTrace(wxT("sound"),
+ wxT("using backend '%s'"), ms_backend->GetName().c_str());
}
}
{
if (ms_backend)
{
- wxLogTrace(_T("sound"), _T("unloading backend"));
+ wxLogTrace(wxT("sound"), wxT("unloading backend"));
Stop();
- delete ms_backend;
- ms_backend = NULL;
+ wxDELETE(ms_backend);
#if wxUSE_LIBSDL && wxUSE_PLUGINS
delete ms_backendSDL;
#endif
bool wxSound::DoPlay(unsigned flags) const
{
- wxCHECK_MSG( IsOk(), false, _T("Attempt to play invalid wave data") );
+ wxCHECK_MSG( IsOk(), false, wxT("Attempt to play invalid wave data") );
EnsureBackend();
wxSoundPlaybackStatus status;
#define WAVE_INDEX 8
#define FMT_INDEX 12
-bool wxSound::LoadWAV(const wxUint8 *data, size_t length, bool copyData)
+bool wxSound::LoadWAV(const void* data_, size_t length, bool copyData)
{
- WAVEFORMAT waveformat;
- wxUint32 ul;
-
- if (length < 32 + sizeof(WAVEFORMAT))
+ // the simplest wave file header consists of 44 bytes:
+ //
+ // 0 "RIFF"
+ // 4 file size - 8
+ // 8 "WAVE"
+ //
+ // 12 "fmt "
+ // 16 chunk size |
+ // 20 format tag |
+ // 22 number of channels |
+ // 24 sample rate | WAVEFORMAT
+ // 28 average bytes per second |
+ // 32 bytes per frame |
+ // 34 bits per sample |
+ //
+ // 36 "data"
+ // 40 number of data bytes
+ // 44 (wave signal) data
+ //
+ // so check that we have at least as much
+ if ( length < 44 )
return false;
+ const wxUint8* data = static_cast<const wxUint8*>(data_);
+
+ WAVEFORMAT waveformat;
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.uiBlockAlign = wxUINT16_SWAP_ON_BE(waveformat.uiBlockAlign);
waveformat.uiBitsPerSample = wxUINT16_SWAP_ON_BE(waveformat.uiBitsPerSample);
+ // get the sound data size
+ wxUint32 ul;
+ memcpy(&ul, &data[FMT_INDEX + waveformat.uiSize + 12], 4);
+ ul = wxUINT32_SWAP_ON_BE(ul);
+
+ if ( length < ul + FMT_INDEX + waveformat.uiSize + 16 )
+ return false;
+
if (memcmp(data, "RIFF", 4) != 0)
return false;
if (memcmp(&data[WAVE_INDEX], "WAVE", 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;
projects / wxWidgets.git / blobdiff