src/unix/sound_sdl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/unix/sound_sdl.cpp
   3 // Purpose:     wxSound backend using SDL
   4 // Author:      Vaclav Slavik
   5 // Modified by:
   6 // Created:     2004/01/31
   7 // Copyright:   (c) 2004, Open Source Applications Foundation
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // for compilers that support precompilation, includes "wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #if defined(__BORLANDC__)
  15     #pragma hdrstop
  16 #endif
  17
  18 #if wxUSE_SOUND && wxUSE_LIBSDL
  19
  20 #include <SDL.h>
  21
  22 #ifndef WX_PRECOMP
  23     #include "wx/event.h"
  24     #include "wx/intl.h"
  25     #include "wx/log.h"
  26     #include "wx/utils.h"
  27     #include "wx/module.h"
  28 #endif
  29
  30 #include "wx/thread.h"
  31 #include "wx/sound.h"
  32
  33 // ----------------------------------------------------------------------------
  34 // wxSoundBackendSDL, for Unix with libSDL
  35 // ----------------------------------------------------------------------------
  36
  37 class wxSoundBackendSDLNotification : public wxEvent
  38 {
  39 public:
  40     DECLARE_DYNAMIC_CLASS(wxSoundBackendSDLNotification)
  41     wxSoundBackendSDLNotification();
  42     wxEvent *Clone() const { return new wxSoundBackendSDLNotification(*this); }
  43 };
  44
  45 typedef void (wxEvtHandler::*wxSoundBackendSDLNotificationFunction)
  46              (wxSoundBackendSDLNotification&);
  47
  48 wxDECLARE_EVENT(wxEVT_SOUND_BACKEND_SDL_NOTIFICATION, wxSoundBackendSDLNotification);
  49
  50 #define EVT_SOUND_BACKEND_SDL_NOTIFICATON(func) \
  51     DECLARE_EVENT_TABLE_ENTRY(wxEVT_SOUND_BACKEND_SDL_NOTIFICATION, \
  52                               -1,                       \
  53                               -1,                       \
  54                               wxEVENT_HANDLER_CAST( wxSoundBackendSDLNotificationFunction, func ), \
  55                               NULL ),
  56
  57 IMPLEMENT_DYNAMIC_CLASS(wxSoundBackendSDLNotification, wxEvtHandler)
  58 wxDEFINE_EVENT( wxEVT_SOUND_BACKEND_SDL_NOTIFICATION, wxSoundBackendSDLNotification );
  59
  60 wxSoundBackendSDLNotification::wxSoundBackendSDLNotification()
  61 {
  62     SetEventType(wxEVT_SOUND_BACKEND_SDL_NOTIFICATION);
  63 }
  64
  65 class wxSoundBackendSDLEvtHandler;
  66
  67 class wxSoundBackendSDL : public wxSoundBackend
  68 {
  69 public:
  70     wxSoundBackendSDL()
  71         : m_initialized(false), m_playing(false), m_audioOpen(false),
  72           m_data(NULL), m_evtHandler(NULL) {}
  73     virtual ~wxSoundBackendSDL();
  74
  75     wxString GetName() const { return wxT("Simple DirectMedia Layer"); }
  76     int GetPriority() const { return 9; }
  77     bool IsAvailable() const;
  78     bool HasNativeAsyncPlayback() const { return true; }
  79     bool Play(wxSoundData *data, unsigned flags,
  80               volatile wxSoundPlaybackStatus *status);
  81
  82     void FillAudioBuffer(Uint8 *stream, int len);
  83     void FinishedPlayback();
  84
  85     void Stop();
  86     bool IsPlaying() const { return m_playing; }
  87
  88 private:
  89     bool OpenAudio();
  90     void CloseAudio();
  91
  92     bool                        m_initialized;
  93     bool                        m_playing, m_audioOpen;
  94     // playback information:
  95     wxSoundData                 *m_data;
  96     unsigned                     m_pos;
  97     SDL_AudioSpec                m_spec;
  98     bool                         m_loop;
  99
 100     wxSoundBackendSDLEvtHandler *m_evtHandler;
 101 };
 102
 103 class wxSoundBackendSDLEvtHandler : public wxEvtHandler
 104 {
 105 public:
 106     wxSoundBackendSDLEvtHandler(wxSoundBackendSDL *bk) : m_backend(bk) {}
 107
 108 private:
 109     void OnNotify(wxSoundBackendSDLNotification& WXUNUSED(event))
 110     {
 111         wxLogTrace(wxT("sound"),
 112                    wxT("received playback status change notification"));
 113         m_backend->FinishedPlayback();
 114     }
 115     wxSoundBackendSDL *m_backend;
 116
 117     DECLARE_EVENT_TABLE()
 118 };
 119
 120 BEGIN_EVENT_TABLE(wxSoundBackendSDLEvtHandler, wxEvtHandler)
 121     EVT_SOUND_BACKEND_SDL_NOTIFICATON(wxSoundBackendSDLEvtHandler::OnNotify)
 122 END_EVENT_TABLE()
 123
 124 wxSoundBackendSDL::~wxSoundBackendSDL()
 125 {
 126     Stop();
 127     CloseAudio();
 128     delete m_evtHandler;
 129 }
 130
 131 bool wxSoundBackendSDL::IsAvailable() const
 132 {
 133     if (m_initialized)
 134         return true;
 135     if (SDL_WasInit(SDL_INIT_AUDIO) != SDL_INIT_AUDIO)
 136     {
 137         if (SDL_Init(SDL_INIT_AUDIO | SDL_INIT_NOPARACHUTE) == -1)
 138             return false;
 139     }
 140     wxConstCast(this, wxSoundBackendSDL)->m_initialized = true;
 141     wxLogTrace(wxT("sound"), wxT("initialized SDL audio subsystem"));
 142     return true;
 143 }
 144
 145 extern "C" void wx_sdl_audio_callback(void *userdata, Uint8 *stream, int len)
 146 {
 147     wxSoundBackendSDL *bk = (wxSoundBackendSDL*)userdata;
 148     bk->FillAudioBuffer(stream, len);
 149 }
 150
 151 void wxSoundBackendSDL::FillAudioBuffer(Uint8 *stream, int len)
 152 {
 153     if (m_playing)
 154     {
 155         // finished playing the sample
 156         if (m_pos == m_data->m_dataBytes)
 157         {
 158             m_playing = false;
 159             wxSoundBackendSDLNotification event;
 160             m_evtHandler->AddPendingEvent(event);
 161         }
 162         // still something to play
 163         else
 164         {
 165             unsigned size = ((len + m_pos) < m_data->m_dataBytes) ?
 166                             len :
 167                             (m_data->m_dataBytes - m_pos);
 168             memcpy(stream, m_data->m_data + m_pos, size);
 169             m_pos += size;
 170             len -= size;
 171             stream += size;
 172         }
 173     }
 174     // the sample doesn't play, fill the buffer with silence and wait for
 175     // the main thread to shut the playback down:
 176     if (len > 0)
 177     {
 178         if (m_loop)
 179         {
 180             m_pos = 0;
 181             FillAudioBuffer(stream, len);
 182             return;
 183         }
 184         else
 185         {
 186             memset(stream, m_spec.silence, len);
 187         }
 188     }
 189 }
 190
 191 void wxSoundBackendSDL::FinishedPlayback()
 192 {
 193     if (!m_playing)
 194         Stop();
 195 }
 196
 197 bool wxSoundBackendSDL::OpenAudio()
 198 {
 199     if (!m_audioOpen)
 200     {
 201         if (!m_evtHandler)
 202             m_evtHandler = new wxSoundBackendSDLEvtHandler(this);
 203
 204         m_spec.silence = 0;
 205         m_spec.samples = 4096;
 206         m_spec.size = 0;
 207         m_spec.callback = wx_sdl_audio_callback;
 208         m_spec.userdata = (void*)this;
 209
 210         wxLogTrace(wxT("sound"), wxT("opening SDL audio..."));
 211         if (SDL_OpenAudio(&m_spec, NULL) >= 0)
 212         {
 213 #if wxUSE_LOG_DEBUG
 214             char driver[256];
 215 #if SDL_MAJOR_VERSION == 1
 216             SDL_AudioDriverName(driver, 256);
 217 #elif SDL_MAJOR_VERSION > 1
 218             strncpy(driver, SDL_GetCurrentAudioDriver(), 256);
 219 #endif
 220             wxLogTrace(wxT("sound"), wxT("opened audio, driver '%s'"),
 221                        wxString(driver, wxConvLocal).c_str());
 222 #endif
 223             m_audioOpen = true;
 224             return true;
 225         }
 226         else
 227         {
 228             wxString err(SDL_GetError(), wxConvLocal);
 229             wxLogError(_("Couldn't open audio: %s"), err.c_str());
 230             return false;
 231         }
 232     }
 233     return true;
 234 }
 235
 236 void wxSoundBackendSDL::CloseAudio()
 237 {
 238     if (m_audioOpen)
 239     {
 240         SDL_CloseAudio();
 241         wxLogTrace(wxT("sound"), wxT("closed audio"));
 242         m_audioOpen = false;
 243     }
 244 }
 245
 246 bool wxSoundBackendSDL::Play(wxSoundData *data, unsigned flags,
 247                              volatile wxSoundPlaybackStatus *WXUNUSED(status))
 248 {
 249     Stop();
 250
 251     int format;
 252     if (data->m_bitsPerSample == 8)
 253         format = AUDIO_U8;
 254     else if (data->m_bitsPerSample == 16)
 255         format = AUDIO_S16LSB;
 256     else
 257         return false;
 258
 259     bool needsOpen = true;
 260     if (m_audioOpen)
 261     {
 262         if (format == m_spec.format &&
 263             m_spec.freq == (int)data->m_samplingRate &&
 264             m_spec.channels == data->m_channels)
 265         {
 266             needsOpen = false;
 267         }
 268         else
 269         {
 270             CloseAudio();
 271         }
 272     }
 273
 274     if (needsOpen)
 275     {
 276         m_spec.format = format;
 277         m_spec.freq = data->m_samplingRate;
 278         m_spec.channels = data->m_channels;
 279         if (!OpenAudio())
 280             return false;
 281     }
 282
 283     SDL_LockAudio();
 284     wxLogTrace(wxT("sound"), wxT("playing new sound"));
 285     m_playing = true;
 286     m_pos = 0;
 287     m_loop = (flags & wxSOUND_LOOP);
 288     m_data = data;
 289     data->IncRef();
 290     SDL_UnlockAudio();
 291
 292     SDL_PauseAudio(0);
 293
 294     // wait until playback finishes if called in sync mode:
 295     if (!(flags & wxSOUND_ASYNC))
 296     {
 297         wxLogTrace(wxT("sound"), wxT("waiting for sample to finish"));
 298         while (m_playing && m_data == data)
 299         {
 300 #if wxUSE_THREADS
 301             // give the playback thread a chance to add event to pending
 302             // events queue, release GUI lock temporarily:
 303             if (wxThread::IsMain())
 304                 wxMutexGuiLeave();
 305 #endif
 306             wxMilliSleep(10);
 307 #if wxUSE_THREADS
 308             if (wxThread::IsMain())
 309                 wxMutexGuiEnter();
 310 #endif
 311         }
 312         wxLogTrace(wxT("sound"), wxT("sample finished"));
 313     }
 314
 315     return true;
 316 }
 317
 318 void wxSoundBackendSDL::Stop()
 319 {
 320     SDL_LockAudio();
 321     SDL_PauseAudio(1);
 322     m_playing = false;
 323     if (m_data)
 324     {
 325         m_data->DecRef();
 326         m_data = NULL;
 327     }
 328     SDL_UnlockAudio();
 329 }
 330
 331 extern "C" wxSoundBackend *wxCreateSoundBackendSDL()
 332 {
 333     return new wxSoundBackendSDL();
 334 }
 335
 336 #endif // wxUSE_SOUND && wxUSE_LIBSDL