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