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, Open Source Applications Foundation
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#include "wx/setup.h"

#if defined(__BORLANDC__)
#pragma hdrstop
#endif

#if wxUSE_SOUND

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

#ifdef 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"


#if wxUSE_THREADS
// mutex for all wxSound's synchronization
static wxMutex gs_soundMutex;
#endif

// ----------------------------------------------------------------------------
// wxSoundData
// ----------------------------------------------------------------------------

void wxSoundData::IncRef()
{
#if wxUSE_THREADS
    wxMutexLocker locker(gs_soundMutex);
#endif
    m_refCnt++;
}

void wxSoundData::DecRef()
{
#if wxUSE_THREADS
    wxMutexLocker locker(gs_soundMutex);
#endif
    if (--m_refCnt == 0)
        delete this;
}

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


// ----------------------------------------------------------------------------
// 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),
              volatile wxSoundPlaybackStatus *WXUNUSED(status))
        { return true; }
    void Stop() {}
    bool IsPlaying() const { return false; }
};


// ----------------------------------------------------------------------------
// 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,
              volatile wxSoundPlaybackStatus *status);
    void Stop() {}
    bool IsPlaying() const { return false; }

private:
    int OpenDSP(const wxSoundData *data);
    bool InitDSP(int dev, const wxSoundData *data);

    int m_DSPblkSize;        // Size of the DSP buffer
    bool m_needConversion;
};

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,
                             volatile wxSoundPlaybackStatus *status)
{
    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
        {
            if (status->m_stopRequested)
            {
                wxLogTrace(_T("sound"), _T("playback stopped"));
                close(dev);
                return true;
            }

            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, data) || m_needConversion)
    {
        close(dev);
        return -1;
    }

    return dev;
}


bool wxSoundBackendOSS::InitDSP(int dev, const wxSoundData *data)
{
    unsigned tmp;

    // Reset the dsp
    if (ioctl(dev, SNDCTL_DSP_RESET, 0) < 0)
    {
        wxLogTrace(_T("sound"), _T("unable to reset dsp"));
        return false;
    }

    m_needConversion = false;

    tmp = data->m_bitsPerSample;
    if (ioctl(dev, SNDCTL_DSP_SAMPLESIZE, &tmp) < 0)
    {
        wxLogTrace(_T("sound"), _T("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)"),
                   data->m_bitsPerSample, tmp);
        m_needConversion = true;
    }

    unsigned stereo = data->m_channels == 1 ? 0 : 1;
    tmp = stereo;
    if (ioctl(dev, SNDCTL_DSP_STEREO, &tmp) < 0)
    {
        wxLogTrace(_T("sound"), _T("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"));
        m_needConversion = true;
    }

    tmp = data->m_samplingRate;
    if (ioctl(dev, SNDCTL_DSP_SPEED, &tmp) < 0)
    {
        wxLogTrace(_T("sound"), _T("IOCTL failure (SNDCTL_DSP_SPEED)"));
       return false;
    }
    if (tmp != data->m_samplingRate)
    {
        // If the rate the sound card is using is not within 1% of what the
        // data specified then override the data setting.  The only reason not
        // to always override this is because of clock-rounding
        // problems. Sound cards will sometimes use things like 44101 when you
        // ask for 44100.  No need overriding this and having strange output
        // 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)"),
                       data->m_samplingRate, tmp);
            m_needConversion = true;
        }
    }

    // Do this last because some drivers can adjust the buffer sized based on
    // the sampling rate, etc.
    if (ioctl(dev, SNDCTL_DSP_GETBLKSIZE, &m_DSPblkSize) < 0)
    {
        wxLogTrace(_T("sound"), _T("IOCTL failure (SNDCTL_DSP_GETBLKSIZE)"));
        return false;
    }
    return true;
}

#endif // HAVE_SYS_SOUNDCARD_H

// ----------------------------------------------------------------------------
// wxSoundSyncOnlyAdaptor
// ----------------------------------------------------------------------------

#if wxUSE_THREADS

class wxSoundSyncOnlyAdaptor;

// 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(wxSoundSyncOnlyAdaptor *adaptor,
                              wxSoundData *data, unsigned flags)
        : wxThread(), m_adapt(adaptor), m_data(data), m_flags(flags) {}
    virtual ExitCode Entry();

protected:
    wxSoundSyncOnlyAdaptor *m_adapt;
    wxSoundData *m_data;
    unsigned m_flags;
};

#endif // wxUSE_THREADS

// This class turns wxSoundBackend that doesn't support asynchronous playback
// into one that does
class wxSoundSyncOnlyAdaptor : public wxSoundBackend
{
public:
    wxSoundSyncOnlyAdaptor(wxSoundBackend *backend)
        : m_backend(backend), m_playing(false) {}
    ~wxSoundSyncOnlyAdaptor()
    {
        delete m_backend;
    }
    wxString GetName() const
    {
        return m_backend->GetName();
    }
    int GetPriority() const
    {
        return m_backend->GetPriority();
    }
    bool IsAvailable() const
    {
        return m_backend->IsAvailable();
    }
    bool HasNativeAsyncPlayback() const
    {
        return true;
    }
    bool Play(wxSoundData *data, unsigned flags,
              volatile wxSoundPlaybackStatus *status);
    void Stop();
    bool IsPlaying() const;

private:
    friend class wxSoundAsyncPlaybackThread;

    wxSoundBackend *m_backend;
    bool m_playing;
#if wxUSE_THREADS
    // player thread holds this mutex and releases it after it finishes
    // playing, so that the main thread knows when it can play sound
    wxMutex m_mutexRightToPlay;
    wxSoundPlaybackStatus m_status;
#endif
};


#if wxUSE_THREADS
wxThread::ExitCode wxSoundAsyncPlaybackThread::Entry()
{
    m_adapt->m_backend->Play(m_data, m_flags & ~wxSOUND_ASYNC,
                             &m_adapt->m_status);

    m_data->DecRef();
    m_adapt->m_playing = false;
    m_adapt->m_mutexRightToPlay.Unlock();
    wxLogTrace(_T("sound"), _T("terminated async playback thread"));
    return 0;
}
#endif

bool wxSoundSyncOnlyAdaptor::Play(wxSoundData *data, unsigned flags,
                                  volatile wxSoundPlaybackStatus *status)
{
    Stop();
    if (flags & wxSOUND_ASYNC)
    {
#if wxUSE_THREADS
        m_mutexRightToPlay.Lock();
        m_status.m_playing = true;
        m_status.m_stopRequested = false;
        data->IncRef();
        wxThread *th = new wxSoundAsyncPlaybackThread(this, data, flags);
        th->Create();
        th->Run();
        wxLogTrace(_T("sound"), _T("launched async playback thread"));
        return true;
#else
        wxLogError(_("Unable to play sound asynchronously."));
        return false;
#endif
    }
    else
    {
#if wxUSE_THREADS
        m_mutexRightToPlay.Lock();
#endif
        bool rv = m_backend->Play(data, flags, status);
#if wxUSE_THREADS
        m_mutexRightToPlay.Unlock();
#endif
        return rv;
    }
}

void wxSoundSyncOnlyAdaptor::Stop()
{
    wxLogTrace(_T("sound"), _T("asking audio to stop"));

#if wxUSE_THREADS
    // tell the player thread (if running) to stop playback ASAP:
    m_status.m_stopRequested = true;

    // acquire the mutex to be sure no sound is being played, then
    // release it because we don't need it for anything (the effect of this
    // is that calling thread will wait until playback thread reacts to
    // our request to interrupt playback):
    m_mutexRightToPlay.Lock();
    m_mutexRightToPlay.Unlock();
    wxLogTrace(_T("sound"), _T("audio was stopped"));
#endif
}

bool wxSoundSyncOnlyAdaptor::IsPlaying() const
{
#if wxUSE_THREADS
    return m_status.m_playing;
#else
    return false;
#endif
}


// ----------------------------------------------------------------------------
// 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 WXUNUSED_UNLESS_DEBUG(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;
    }

    wxFileOffset lenOrig = fileWave.Length();
    if ( lenOrig == wxInvalidOffset )
        return false;

    size_t len = wx_truncate_cast(size_t, lenOrig);
    wxUint8 *data = new wxUint8[len];
    if ( fileWave.Read(data, len) != lenOrig )
    {
        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
#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

#ifdef HAVE_SYS_SOUNDCARD_H
        if (!ms_backend)
        {
            ms_backend = new wxSoundBackendOSS();
            if (!ms_backend->IsAvailable())
            {
                wxDELETE(ms_backend);
            }
        }
#endif

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

        if (!ms_backend->HasNativeAsyncPlayback())
            ms_backend = new wxSoundSyncOnlyAdaptor(ms_backend);

        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"));

        Stop();

        delete ms_backend;
        ms_backend = NULL;
#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") );

    EnsureBackend();
    wxSoundPlaybackStatus status;
    status.m_playing = true;
    status.m_stopRequested = false;
    return ms_backend->Play(m_data, flags, &status);
}

/*static*/ void wxSound::Stop()
{
    if (ms_backend)
        ms_backend->Stop();
}

/*static*/ bool wxSound::IsPlaying()
{
    if (ms_backend)
        return ms_backend->IsPlaying();
    else
        return false;
}

void wxSound::Free()
{
    if (m_data)
        m_data->DecRef();
}

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

#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
	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, Open Source Applications Foundation
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// for compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#include "wx/setup.h"
	16
	17	#if defined(__BORLANDC__)
	18	#pragma hdrstop
	19	#endif
	20
	21	#if wxUSE_SOUND
	22
	23	#include <stdio.h>
	24	#include <unistd.h>
	25	#include <fcntl.h>
	26	#include <sys/ioctl.h>
	27
	28	#ifdef HAVE_SYS_SOUNDCARD_H
	29	#include <sys/soundcard.h>
	30	#endif
	31
	32	#ifndef WX_PRECOMP
	33	#include "wx/event.h"
	34	#include "wx/intl.h"
	35	#include "wx/log.h"
	36	#endif
	37
	38	#include "wx/thread.h"
	39	#include "wx/file.h"
	40	#include "wx/module.h"
	41	#include "wx/sound.h"
	42	#include "wx/dynlib.h"
	43
	44
	45	#if wxUSE_THREADS
	46	// mutex for all wxSound's synchronization
	47	static wxMutex gs_soundMutex;
	48	#endif
	49
	50	// ----------------------------------------------------------------------------
	51	// wxSoundData
	52	// ----------------------------------------------------------------------------
	53
	54	void wxSoundData::IncRef()
	55	{
	56	#if wxUSE_THREADS
	57	wxMutexLocker locker(gs_soundMutex);
	58	#endif
	59	m_refCnt++;
	60	}
	61
	62	void wxSoundData::DecRef()
	63	{
	64	#if wxUSE_THREADS
	65	wxMutexLocker locker(gs_soundMutex);
	66	#endif
	67	if (--m_refCnt == 0)
	68	delete this;
	69	}
	70
	71	wxSoundData::~wxSoundData()
	72	{
	73	delete[] m_dataWithHeader;
	74	}
	75
	76
	77	// ----------------------------------------------------------------------------
	78	// wxSoundBackendNull, used in absence of audio API or card
	79	// ----------------------------------------------------------------------------
	80
	81	class wxSoundBackendNull : public wxSoundBackend
	82	{
	83	public:
	84	wxString GetName() const { return _("No sound"); }
	85	int GetPriority() const { return 0; }
	86	bool IsAvailable() const { return true; }
	87	bool HasNativeAsyncPlayback() const { return true; }
	88	bool Play(wxSoundData *WXUNUSED(data), unsigned WXUNUSED(flags),
	89	volatile wxSoundPlaybackStatus *WXUNUSED(status))
	90	{ return true; }
	91	void Stop() {}
	92	bool IsPlaying() const { return false; }
	93	};
	94
	95
	96	// ----------------------------------------------------------------------------
	97	// wxSoundBackendOSS, for Linux
	98	// ----------------------------------------------------------------------------
	99
	100	#ifdef HAVE_SYS_SOUNDCARD_H
	101
	102	#ifndef AUDIODEV
	103	#define AUDIODEV "/dev/dsp" // Default path for audio device
	104	#endif
	105
	106	class wxSoundBackendOSS : public wxSoundBackend
	107	{
	108	public:
	109	wxString GetName() const { return _T("Open Sound System"); }
	110	int GetPriority() const { return 10; }
	111	bool IsAvailable() const;
	112	bool HasNativeAsyncPlayback() const { return false; }
	113	bool Play(wxSoundData *data, unsigned flags,
	114	volatile wxSoundPlaybackStatus *status);
	115	void Stop() {}
	116	bool IsPlaying() const { return false; }
	117
	118	private:
	119	int OpenDSP(const wxSoundData *data);
	120	bool InitDSP(int dev, const wxSoundData *data);
	121
	122	int m_DSPblkSize; // Size of the DSP buffer
	123	bool m_needConversion;
	124	};
	125
	126	bool wxSoundBackendOSS::IsAvailable() const
	127	{
	128	int fd;
	129	fd = open(AUDIODEV, O_WRONLY \| O_NONBLOCK);
	130	if (fd < 0)
	131	return false;
	132	close(fd);
	133	return true;
	134	}
	135
	136	bool wxSoundBackendOSS::Play(wxSoundData *data, unsigned flags,
	137	volatile wxSoundPlaybackStatus *status)
	138	{
	139	int dev = OpenDSP(data);
	140
	141	if (dev < 0)
	142	return false;
	143
	144	ioctl(dev, SNDCTL_DSP_SYNC, 0);
	145
	146	do
	147	{
	148	bool play = true;
	149	int i;
	150	unsigned l = 0;
	151	size_t datasize = data->m_dataBytes;
	152
	153	do
	154	{
	155	if (status->m_stopRequested)
	156	{
	157	wxLogTrace(_T("sound"), _T("playback stopped"));
	158	close(dev);
	159	return true;
	160	}
	161
	162	i= (int)((l + m_DSPblkSize) < datasize ?
	163	m_DSPblkSize : (datasize - l));
	164	if (write(dev, &data->m_data[l], i) != i)
	165	{
	166	play = false;
	167	}
	168	l += i;
	169	} while (play && l < datasize);
	170	} while (flags & wxSOUND_LOOP);
	171
	172	close(dev);
	173	return true;
	174	}
	175
	176	int wxSoundBackendOSS::OpenDSP(const wxSoundData *data)
	177	{
	178	int dev = -1;
	179
	180	if ((dev = open(AUDIODEV, O_WRONLY, 0)) <0)
	181	return -1;
	182
	183	if (!InitDSP(dev, data) \|\| m_needConversion)
	184	{
	185	close(dev);
	186	return -1;
	187	}
	188
	189	return dev;
	190	}
	191
	192
	193	bool wxSoundBackendOSS::InitDSP(int dev, const wxSoundData *data)
	194	{
	195	unsigned tmp;
	196
	197	// Reset the dsp
	198	if (ioctl(dev, SNDCTL_DSP_RESET, 0) < 0)
	199	{
	200	wxLogTrace(_T("sound"), _T("unable to reset dsp"));
	201	return false;
	202	}
	203
	204	m_needConversion = false;
	205
	206	tmp = data->m_bitsPerSample;
	207	if (ioctl(dev, SNDCTL_DSP_SAMPLESIZE, &tmp) < 0)
	208	{
	209	wxLogTrace(_T("sound"), _T("IOCTL failure (SNDCTL_DSP_SAMPLESIZE)"));
	210	return false;
	211	}
	212	if (tmp != data->m_bitsPerSample)
	213	{
	214	wxLogTrace(_T("sound"),
	215	_T("Unable to set DSP sample size to %d (wants %d)"),
	216	data->m_bitsPerSample, tmp);
	217	m_needConversion = true;
	218	}
	219
	220	unsigned stereo = data->m_channels == 1 ? 0 : 1;
	221	tmp = stereo;
	222	if (ioctl(dev, SNDCTL_DSP_STEREO, &tmp) < 0)
	223	{
	224	wxLogTrace(_T("sound"), _T("IOCTL failure (SNDCTL_DSP_STEREO)"));
	225	return false;
	226	}
	227	if (tmp != stereo)
	228	{
	229	wxLogTrace(_T("sound"), _T("Unable to set DSP to %s."), stereo? _T("stereo"):_T("mono"));
	230	m_needConversion = true;
	231	}
	232
	233	tmp = data->m_samplingRate;
	234	if (ioctl(dev, SNDCTL_DSP_SPEED, &tmp) < 0)
	235	{
	236	wxLogTrace(_T("sound"), _T("IOCTL failure (SNDCTL_DSP_SPEED)"));
	237	return false;
	238	}
	239	if (tmp != data->m_samplingRate)
	240	{
	241	// If the rate the sound card is using is not within 1% of what the
	242	// data specified then override the data setting. The only reason not
	243	// to always override this is because of clock-rounding
	244	// problems. Sound cards will sometimes use things like 44101 when you
	245	// ask for 44100. No need overriding this and having strange output
	246	// file rates for something that we can't hear anyways.
	247	if (data->m_samplingRate - tmp > (tmp * .01) \|\|
	248	tmp - data->m_samplingRate > (tmp * .01)) {
	249	wxLogTrace(_T("sound"),
	250	_T("Unable to set DSP sampling rate to %d (wants %d)"),
	251	data->m_samplingRate, tmp);
	252	m_needConversion = true;
	253	}
	254	}
	255
	256	// Do this last because some drivers can adjust the buffer sized based on
	257	// the sampling rate, etc.
	258	if (ioctl(dev, SNDCTL_DSP_GETBLKSIZE, &m_DSPblkSize) < 0)
	259	{
	260	wxLogTrace(_T("sound"), _T("IOCTL failure (SNDCTL_DSP_GETBLKSIZE)"));
	261	return false;
	262	}
	263	return true;
	264	}
	265
	266	#endif // HAVE_SYS_SOUNDCARD_H
	267
	268	// ----------------------------------------------------------------------------
	269	// wxSoundSyncOnlyAdaptor
	270	// ----------------------------------------------------------------------------
	271
	272	#if wxUSE_THREADS
	273
	274	class wxSoundSyncOnlyAdaptor;
	275
	276	// this class manages asynchronous playback of audio if the backend doesn't
	277	// support it natively (e.g. OSS backend)
	278	class wxSoundAsyncPlaybackThread : public wxThread
	279	{
	280	public:
	281	wxSoundAsyncPlaybackThread(wxSoundSyncOnlyAdaptor *adaptor,
	282	wxSoundData *data, unsigned flags)
	283	: wxThread(), m_adapt(adaptor), m_data(data), m_flags(flags) {}
	284	virtual ExitCode Entry();
	285
	286	protected:
	287	wxSoundSyncOnlyAdaptor *m_adapt;
	288	wxSoundData *m_data;
	289	unsigned m_flags;
	290	};
	291
	292	#endif // wxUSE_THREADS
	293
	294	// This class turns wxSoundBackend that doesn't support asynchronous playback
	295	// into one that does
	296	class wxSoundSyncOnlyAdaptor : public wxSoundBackend
	297	{
	298	public:
	299	wxSoundSyncOnlyAdaptor(wxSoundBackend *backend)
	300	: m_backend(backend), m_playing(false) {}
	301	~wxSoundSyncOnlyAdaptor()
	302	{
	303	delete m_backend;
	304	}
	305	wxString GetName() const
	306	{
	307	return m_backend->GetName();
	308	}
	309	int GetPriority() const
	310	{
	311	return m_backend->GetPriority();
	312	}
	313	bool IsAvailable() const
	314	{
	315	return m_backend->IsAvailable();
	316	}
	317	bool HasNativeAsyncPlayback() const
	318	{
	319	return true;
	320	}
	321	bool Play(wxSoundData *data, unsigned flags,
	322	volatile wxSoundPlaybackStatus *status);
	323	void Stop();
	324	bool IsPlaying() const;
	325
	326	private:
	327	friend class wxSoundAsyncPlaybackThread;
	328
	329	wxSoundBackend *m_backend;
	330	bool m_playing;
	331	#if wxUSE_THREADS
	332	// player thread holds this mutex and releases it after it finishes
	333	// playing, so that the main thread knows when it can play sound
	334	wxMutex m_mutexRightToPlay;
	335	wxSoundPlaybackStatus m_status;
	336	#endif
	337	};
	338
	339
	340	#if wxUSE_THREADS
	341	wxThread::ExitCode wxSoundAsyncPlaybackThread::Entry()
	342	{
	343	m_adapt->m_backend->Play(m_data, m_flags & ~wxSOUND_ASYNC,
	344	&m_adapt->m_status);
	345
	346	m_data->DecRef();
	347	m_adapt->m_playing = false;
	348	m_adapt->m_mutexRightToPlay.Unlock();
	349	wxLogTrace(_T("sound"), _T("terminated async playback thread"));
	350	return 0;
	351	}
	352	#endif
	353
	354	bool wxSoundSyncOnlyAdaptor::Play(wxSoundData *data, unsigned flags,
	355	volatile wxSoundPlaybackStatus *status)
	356	{
	357	Stop();
	358	if (flags & wxSOUND_ASYNC)
	359	{
	360	#if wxUSE_THREADS
	361	m_mutexRightToPlay.Lock();
	362	m_status.m_playing = true;
	363	m_status.m_stopRequested = false;
	364	data->IncRef();
	365	wxThread *th = new wxSoundAsyncPlaybackThread(this, data, flags);
	366	th->Create();
	367	th->Run();
	368	wxLogTrace(_T("sound"), _T("launched async playback thread"));
	369	return true;
	370	#else
	371	wxLogError(_("Unable to play sound asynchronously."));
	372	return false;
	373	#endif
	374	}
	375	else
	376	{
	377	#if wxUSE_THREADS
	378	m_mutexRightToPlay.Lock();
	379	#endif
	380	bool rv = m_backend->Play(data, flags, status);
	381	#if wxUSE_THREADS
	382	m_mutexRightToPlay.Unlock();
	383	#endif
	384	return rv;
	385	}
	386	}
	387
	388	void wxSoundSyncOnlyAdaptor::Stop()
	389	{
	390	wxLogTrace(_T("sound"), _T("asking audio to stop"));
	391
	392	#if wxUSE_THREADS
	393	// tell the player thread (if running) to stop playback ASAP:
	394	m_status.m_stopRequested = true;
	395
	396	// acquire the mutex to be sure no sound is being played, then
	397	// release it because we don't need it for anything (the effect of this
	398	// is that calling thread will wait until playback thread reacts to
	399	// our request to interrupt playback):
	400	m_mutexRightToPlay.Lock();
	401	m_mutexRightToPlay.Unlock();
	402	wxLogTrace(_T("sound"), _T("audio was stopped"));
	403	#endif
	404	}
	405
	406	bool wxSoundSyncOnlyAdaptor::IsPlaying() const
	407	{
	408	#if wxUSE_THREADS
	409	return m_status.m_playing;
	410	#else
	411	return false;
	412	#endif
	413	}
	414
	415
	416	// ----------------------------------------------------------------------------
	417	// wxSound
	418	// ----------------------------------------------------------------------------
	419
	420	wxSoundBackend *wxSound::ms_backend = NULL;
	421
	422	// FIXME - temporary, until we have plugins architecture
	423	#if wxUSE_LIBSDL
	424	#if wxUSE_PLUGINS
	425	wxDynamicLibrary *wxSound::ms_backendSDL = NULL;
	426	#else
	427	extern "C" wxSoundBackend *wxCreateSoundBackendSDL();
	428	#endif
	429	#endif
	430
	431	wxSound::wxSound() : m_data(NULL)
	432	{
	433	}
	434
	435	wxSound::wxSound(const wxString& sFileName, bool isResource) : m_data(NULL)
	436	{
	437	Create(sFileName, isResource);
	438	}
	439
	440	wxSound::wxSound(int size, const wxByte* data) : m_data(NULL)
	441	{
	442	Create(size, data);
	443	}
	444
	445	wxSound::~wxSound()
	446	{
	447	Free();
	448	}
	449
	450	bool wxSound::Create(const wxString& fileName,
	451	bool WXUNUSED_UNLESS_DEBUG(isResource))
	452	{
	453	wxASSERT_MSG( !isResource,
	454	_T("Loading sound from resources is only supported on Windows") );
	455
	456	Free();
	457
	458	wxFile fileWave;
	459	if (!fileWave.Open(fileName, wxFile::read))
	460	{
	461	return false;
	462	}
	463
	464	wxFileOffset lenOrig = fileWave.Length();
	465	if ( lenOrig == wxInvalidOffset )
	466	return false;
	467
	468	size_t len = wx_truncate_cast(size_t, lenOrig);
	469	wxUint8 *data = new wxUint8[len];
	470	if ( fileWave.Read(data, len) != lenOrig )
	471	{
	472	wxLogError(_("Couldn't load sound data from '%s'."), fileName.c_str());
	473	return false;
	474	}
	475
	476	if (!LoadWAV(data, len, false))
	477	{
	478	wxLogError(_("Sound file '%s' is in unsupported format."),
	479	fileName.c_str());
	480	return false;
	481	}
	482
	483	return true;
	484	}
	485
	486	bool wxSound::Create(int size, const wxByte* data)
	487	{
	488	wxASSERT( data != NULL );
	489
	490	Free();
	491	if (!LoadWAV(data, size, true))
	492	{
	493	wxLogError(_("Sound data are in unsupported format."));
	494	return false;
	495	}
	496	return true;
	497	}
	498
	499	/static/ void wxSound::EnsureBackend()
	500	{
	501	if (!ms_backend)
	502	{
	503	// FIXME -- make this fully dynamic when plugins architecture is in
	504	// place
	505	#if wxUSE_LIBSDL
	506	//if (!ms_backend)
	507	{
	508	#if !wxUSE_PLUGINS
	509	ms_backend = wxCreateSoundBackendSDL();
	510	#else
	511	wxString dllname;
	512	dllname.Printf(_T("%s/%s"),
	513	wxDynamicLibrary::GetPluginsDirectory().c_str(),
	514	wxDynamicLibrary::CanonicalizePluginName(
	515	_T("sound_sdl"), wxDL_PLUGIN_BASE).c_str());
	516	wxLogTrace(_T("sound"),
	517	_T("trying to load SDL plugin from '%s'..."),
	518	dllname.c_str());
	519	wxLogNull null;
	520	ms_backendSDL = new wxDynamicLibrary(dllname, wxDL_NOW);
	521	if (!ms_backendSDL->IsLoaded())
	522	{
	523	wxDELETE(ms_backendSDL);
	524	}
	525	else
	526	{
	527	typedef wxSoundBackend (wxCreateSoundBackend_t)();
	528	wxDYNLIB_FUNCTION(wxCreateSoundBackend_t,
	529	wxCreateSoundBackendSDL, *ms_backendSDL);
	530	if (pfnwxCreateSoundBackendSDL)
	531	{
	532	ms_backend = (*pfnwxCreateSoundBackendSDL)();
	533	}
	534	}
	535	#endif
	536	if (ms_backend && !ms_backend->IsAvailable())
	537	{
	538	wxDELETE(ms_backend);
	539	}
	540	}
	541	#endif
	542
	543	#ifdef HAVE_SYS_SOUNDCARD_H
	544	if (!ms_backend)
	545	{
	546	ms_backend = new wxSoundBackendOSS();
	547	if (!ms_backend->IsAvailable())
	548	{
	549	wxDELETE(ms_backend);
	550	}
	551	}
	552	#endif
	553
	554	if (!ms_backend)
	555	ms_backend = new wxSoundBackendNull();
	556
	557	if (!ms_backend->HasNativeAsyncPlayback())
	558	ms_backend = new wxSoundSyncOnlyAdaptor(ms_backend);
	559
	560	wxLogTrace(_T("sound"),
	561	_T("using backend '%s'"), ms_backend->GetName().c_str());
	562	}
	563	}
	564
	565	/static/ void wxSound::UnloadBackend()
	566	{
	567	if (ms_backend)
	568	{
	569	wxLogTrace(_T("sound"), _T("unloading backend"));
	570
	571	Stop();
	572
	573	delete ms_backend;
	574	ms_backend = NULL;
	575	#if wxUSE_LIBSDL && wxUSE_PLUGINS
	576	delete ms_backendSDL;
	577	#endif
	578	}
	579	}
	580
	581	bool wxSound::DoPlay(unsigned flags) const
	582	{
	583	wxCHECK_MSG( IsOk(), false, _T("Attempt to play invalid wave data") );
	584
	585	EnsureBackend();
	586	wxSoundPlaybackStatus status;
	587	status.m_playing = true;
	588	status.m_stopRequested = false;
	589	return ms_backend->Play(m_data, flags, &status);
	590	}
	591
	592	/static/ void wxSound::Stop()
	593	{
	594	if (ms_backend)
	595	ms_backend->Stop();
	596	}
	597
	598	/static/ bool wxSound::IsPlaying()
	599	{
	600	if (ms_backend)
	601	return ms_backend->IsPlaying();
	602	else
	603	return false;
	604	}
	605
	606	void wxSound::Free()
	607	{
	608	if (m_data)
	609	m_data->DecRef();
	610	}
	611
	612	typedef struct
	613	{
	614	wxUint32 uiSize;
	615	wxUint16 uiFormatTag;
	616	wxUint16 uiChannels;
	617	wxUint32 ulSamplesPerSec;
	618	wxUint32 ulAvgBytesPerSec;
	619	wxUint16 uiBlockAlign;
	620	wxUint16 uiBitsPerSample;
	621	} WAVEFORMAT;
	622
	623	#define WAVE_FORMAT_PCM 1
	624	#define WAVE_INDEX 8
	625	#define FMT_INDEX 12
	626
	627	bool wxSound::LoadWAV(const wxUint8 *data, size_t length, bool copyData)
	628	{
	629	WAVEFORMAT waveformat;
	630	wxUint32 ul;
	631
	632	if (length < 32 + sizeof(WAVEFORMAT))
	633	return false;
	634
	635	memcpy(&waveformat, &data[FMT_INDEX + 4], sizeof(WAVEFORMAT));
	636	waveformat.uiSize = wxUINT32_SWAP_ON_BE(waveformat.uiSize);
	637	waveformat.uiFormatTag = wxUINT16_SWAP_ON_BE(waveformat.uiFormatTag);
	638	waveformat.uiChannels = wxUINT16_SWAP_ON_BE(waveformat.uiChannels);
	639	waveformat.ulSamplesPerSec = wxUINT32_SWAP_ON_BE(waveformat.ulSamplesPerSec);
	640	waveformat.ulAvgBytesPerSec = wxUINT32_SWAP_ON_BE(waveformat.ulAvgBytesPerSec);
	641	waveformat.uiBlockAlign = wxUINT16_SWAP_ON_BE(waveformat.uiBlockAlign);
	642	waveformat.uiBitsPerSample = wxUINT16_SWAP_ON_BE(waveformat.uiBitsPerSample);
	643
	644	if (memcmp(data, "RIFF", 4) != 0)
	645	return false;
	646	if (memcmp(&data[WAVE_INDEX], "WAVE", 4) != 0)
	647	return false;
	648	if (memcmp(&data[FMT_INDEX], "fmt ", 4) != 0)
	649	return false;
	650	if (memcmp(&data[FMT_INDEX + waveformat.uiSize + 8], "data", 4) != 0)
	651	return false;
	652	memcpy(&ul,&data[FMT_INDEX + waveformat.uiSize + 12], 4);
	653	ul = wxUINT32_SWAP_ON_BE(ul);
	654
	655	//WAS: if (ul + FMT_INDEX + waveformat.uiSize + 16 != length)
	656	if (ul + FMT_INDEX + waveformat.uiSize + 16 > length)
	657	return false;
	658
	659	if (waveformat.uiFormatTag != WAVE_FORMAT_PCM)
	660	return false;
	661
	662	if (waveformat.ulSamplesPerSec !=
	663	waveformat.ulAvgBytesPerSec / waveformat.uiBlockAlign)
	664	return false;
	665
	666	m_data = new wxSoundData;
	667	m_data->m_channels = waveformat.uiChannels;
	668	m_data->m_samplingRate = waveformat.ulSamplesPerSec;
	669	m_data->m_bitsPerSample = waveformat.uiBitsPerSample;
	670	m_data->m_samples = ul / (m_data->m_channels * m_data->m_bitsPerSample / 8);
	671	m_data->m_dataBytes = ul;
	672
	673	if (copyData)
	674	{
	675	m_data->m_dataWithHeader = new wxUint8[length];
	676	memcpy(m_data->m_dataWithHeader, data, length);
	677	}
	678	else
	679	m_data->m_dataWithHeader = (wxUint8*)data;
	680
	681	m_data->m_data =
	682	(&m_data->m_dataWithHeader[FMT_INDEX + waveformat.uiSize + 8]);
	683
	684	return true;
	685	}
	686
	687
	688	// ----------------------------------------------------------------------------
	689	// wxSoundCleanupModule
	690	// ----------------------------------------------------------------------------
	691
	692	class wxSoundCleanupModule: public wxModule
	693	{
	694	public:
	695	bool OnInit() { return true; }
	696	void OnExit() { wxSound::UnloadBackend(); }
	697	DECLARE_DYNAMIC_CLASS(wxSoundCleanupModule)
	698	};
	699
	700	IMPLEMENT_DYNAMIC_CLASS(wxSoundCleanupModule, wxModule)
	701
	702	#endif