]> git.saurik.com Git - wxWidgets.git/blob - src/osx/carbon/sound.cpp
minor fixes; replace references to Windows95 with references to wxMSW where possible
[wxWidgets.git] / src / osx / carbon / sound.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/osx/carbon/sound.cpp
3 // Purpose: wxSound class implementation: optional
4 // Author: Ryan Norton
5 // Modified by: Stefan Csomor
6 // Created: 1998-01-01
7 // RCS-ID: $Id$
8 // Copyright: (c) Ryan Norton
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #if wxUSE_SOUND
16
17 #include "wx/sound.h"
18
19 #ifndef WX_PRECOMP
20 #include "wx/object.h"
21 #include "wx/string.h"
22 #include "wx/intl.h"
23 #include "wx/log.h"
24 #include "wx/timer.h"
25 #endif
26
27 #include "wx/file.h"
28
29 // Carbon QT Implementation Details -
30 //
31 // Memory:
32 // 1) OpenDefaultComponent(MovieImportType, kQTFileTypeWave);
33 // 2) NewMovie(0);
34 // 3) MovieImportDataRef() //Pass Memory Location to this
35 // 4) PlayMovie();
36 // 5) IsMovieDone(), MoviesTask() //2nd param is minimum wait time to allocate to quicktime
37 //
38 // File:
39 // 1) Path as CFString
40 // 2) Call QTNewDataReferenceFromFullPathCFString
41 // 3) Call NewMovieFromDataRef
42 // 4) Call CloseMovieFile
43 // 4) PlayMovie();
44 // 5) IsMovieDone(), MoviesTask() //2nd param is minimum wait time to allocate to quicktime
45 //
46
47 #ifdef __WXMAC__
48 #include "wx/osx/uma.h"
49 #ifndef __DARWIN__
50 #include <Movies.h>
51 #include <Gestalt.h>
52 #endif
53 #endif
54
55 #include <Carbon/Carbon.h>
56
57 //quicktime media layer only required for mac emulation on pc
58 #ifndef __WXMAC__
59 #include <qtml.h>
60 #endif
61
62 #ifndef __DARWIN__
63 #include <QuickTimeComponents.h>
64 #else
65 #include <QuickTime/QuickTimeComponents.h>
66 #endif
67
68 //Time between timer calls
69 #define MOVIE_DELAY 100
70
71 static wxTimer* lastSoundTimer=NULL;
72 static bool lastSoundIsPlaying=false;
73
74 #if !defined(__LP64__)
75 #define USE_QUICKTIME 1
76 #else
77 #define USE_QUICKTIME 0
78 #endif
79
80 #if USE_QUICKTIME
81 // ------------------------------------------------------------------
82 // wxQTTimer - Handle Asyncronous Playing
83 // ------------------------------------------------------------------
84 class wxQTTimer : public wxTimer
85 {
86 public:
87 wxQTTimer(Movie movie, bool bLoop, bool* playing) :
88 m_movie(movie), m_bLoop(bLoop), m_pbPlaying(playing)
89 {
90 }
91
92 virtual ~wxQTTimer()
93 {
94 if(m_pbPlaying)
95 *m_pbPlaying = false;
96
97 StopMovie(m_movie);
98 DisposeMovie(m_movie);
99 Stop();
100
101 //Note that ExitMovies() is not necessary, but
102 //the docs are fuzzy on whether or not TerminateQTML is
103 ExitMovies();
104
105 #ifndef __WXMAC__
106 TerminateQTML();
107 #endif
108 }
109
110 void Shutdown()
111 {
112 delete this;
113 }
114
115 void Notify()
116 {
117 if (m_pbPlaying && !*m_pbPlaying)
118 {
119 Shutdown();
120 }
121
122 if(IsMovieDone(m_movie))
123 {
124 if (!m_bLoop)
125 Shutdown();
126 else
127 {
128 StopMovie(m_movie);
129 GoToBeginningOfMovie(m_movie);
130 StartMovie(m_movie);
131 }
132 }
133 else
134 MoviesTask(m_movie, MOVIE_DELAY); //Give QT time to play movie
135 }
136
137
138 Movie& GetMovie() {return m_movie;}
139
140 protected:
141 Movie m_movie;
142 bool m_bLoop;
143
144 public:
145 bool* m_pbPlaying;
146
147 };
148
149
150 class wxSMTimer : public wxTimer
151 {
152 public:
153 wxSMTimer(void* hSnd, void* pSndChannel, bool bLoop, bool* playing)
154 : m_hSnd(hSnd), m_pSndChannel(pSndChannel), m_bLoop(bLoop), m_pbPlaying(playing)
155 {
156 }
157
158 virtual ~wxSMTimer()
159 {
160 if(m_pbPlaying)
161 *m_pbPlaying = false;
162 SndDisposeChannel((SndChannelPtr)m_pSndChannel, TRUE);
163 Stop();
164 }
165
166 void Notify()
167 {
168 if (m_pbPlaying && !*m_pbPlaying)
169 {
170 Shutdown();
171 }
172
173 SCStatus stat;
174
175 if (SndChannelStatus((SndChannelPtr)m_pSndChannel, sizeof(SCStatus), &stat) != 0)
176 Shutdown();
177
178 //if the sound isn't playing anymore, see if it's looped,
179 //and if so play it again, otherwise close things up
180 if (stat.scChannelBusy == FALSE)
181 {
182 if (m_bLoop)
183 {
184 if(SndPlay((SndChannelPtr)m_pSndChannel, (SndListHandle) m_hSnd, true) != noErr)
185 Shutdown();
186 }
187 else
188 Shutdown();
189 }
190 }
191
192 void Shutdown()
193 {
194 delete this;
195 }
196
197 void* GetChannel() {return m_pSndChannel;}
198
199 protected:
200 void* m_hSnd;
201 void* m_pSndChannel;
202 bool m_bLoop;
203
204 public:
205 bool* m_pbPlaying;
206 };
207
208 // ------------------------------------------------------------------
209 // wxSound
210 // ------------------------------------------------------------------
211
212 //Determines whether version 4 of QT is installed
213 Boolean wxIsQuickTime4Installed (void)
214 {
215 #ifdef __WXMAC__
216 short error;
217 long result;
218
219 error = Gestalt (gestaltQuickTime, &result);
220 return (error == noErr) && (((result >> 16) & 0xffff) >= 0x0400);
221 #else
222 return true;
223 #endif
224 }
225
226 inline bool wxInitQT ()
227 {
228 if (wxIsQuickTime4Installed())
229 {
230 #ifndef __WXMAC__
231 int nError;
232 //-2093 no dll
233 if ((nError = InitializeQTML(0)) != noErr)
234 wxLogSysError(wxString::Format(wxT("Couldn't Initialize Quicktime-%i"), nError));
235 #endif
236 EnterMovies();
237 return true;
238 }
239 else
240 {
241 wxLogSysError(wxT("Quicktime is not installed, or Your Version of Quicktime is <= 4."));
242 return false;
243 }
244 }
245
246 #endif
247
248 wxSound::wxSound()
249 : m_hSnd(NULL), m_waveLength(0), m_pTimer(NULL), m_type(wxSound_NONE)
250 {
251 }
252
253 wxSound::wxSound(const wxString& sFileName, bool isResource)
254 : m_hSnd(NULL), m_waveLength(0), m_pTimer(NULL), m_type(wxSound_NONE)
255 {
256 Create(sFileName, isResource);
257 }
258
259 wxSound::wxSound(int size, const wxByte* data)
260 : m_hSnd((char*)data), m_waveLength(size), m_pTimer(NULL), m_type(wxSound_MEMORY)
261 {
262 }
263
264 wxSound::~wxSound()
265 {
266 }
267
268 bool wxSound::Create(const wxString& fileName, bool isResource)
269 {
270 Stop();
271
272 if (isResource)
273 {
274 #ifdef __WXMAC__
275 m_type = wxSound_RESOURCE;
276
277 Str255 lpSnd ;
278
279 wxMacStringToPascal( fileName , lpSnd ) ;
280
281 m_sndname = fileName;
282 m_hSnd = (char*) GetNamedResource('snd ', (const unsigned char *) lpSnd);
283 #else
284 return false;
285 #endif
286 }
287 else
288 {
289 m_type = wxSound_FILE;
290 m_sndname = fileName;
291 }
292
293 return true;
294 }
295
296 bool wxSound::DoPlay(unsigned flags) const
297 {
298 Stop();
299
300 #if USE_QUICKTIME
301
302 Movie movie;
303
304 switch(m_type)
305 {
306 case wxSound_MEMORY:
307 {
308 if (!wxInitQT())
309 return false;
310 Handle myHandle, dataRef = nil;
311 MovieImportComponent miComponent;
312 Track targetTrack = nil;
313 TimeValue addedDuration = 0;
314 long outFlags = 0;
315 OSErr err;
316 ComponentResult result;
317
318 myHandle = NewHandleClear((Size)m_waveLength);
319
320 BlockMove(m_hSnd, *myHandle, m_waveLength);
321
322 err = PtrToHand(&myHandle, &dataRef, sizeof(Handle));
323
324 if (memcmp(&m_hSnd[8], "WAVE", 4) == 0)
325 miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeWave);
326 else if (memcmp(&m_hSnd[8], "AIFF", 4) == 0)
327 miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeAIFF);
328 else if (memcmp(&m_hSnd[8], "AIFC", 4) == 0)
329 miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeAIFC);
330 else
331 {
332 wxLogSysError(wxT("wxSound - Location in memory does not contain valid data"));
333 return false;
334 }
335
336 movie = NewMovie(0);
337
338 result = MovieImportDataRef(miComponent, dataRef,
339 HandleDataHandlerSubType, movie,
340 nil, &targetTrack,
341 nil, &addedDuration,
342 movieImportCreateTrack, &outFlags);
343
344 if (result != noErr)
345 {
346 wxLogSysError(wxString::Format(wxT("Couldn't import movie data\nError:%i"), (int)result));
347 }
348
349 SetMovieVolume(movie, kFullVolume);
350 GoToBeginningOfMovie(movie);
351
352 DisposeHandle(myHandle);
353 }
354 break;
355 case wxSound_RESOURCE:
356 {
357 SoundComponentData data;
358 unsigned long numframes, offset;
359
360 ParseSndHeader((SndListHandle)m_hSnd, &data, &numframes, &offset);
361 //m_waveLength = numFrames * data.numChannels;
362
363 SndChannelPtr pSndChannel;
364 SndNewChannel(&pSndChannel, sampledSynth,
365 initNoInterp
366 + (data.numChannels == 1 ? initMono : initStereo), NULL);
367
368 if(SndPlay(pSndChannel, (SndListHandle) m_hSnd, flags & wxSOUND_ASYNC ? 1 : 0) != noErr)
369 return false;
370
371 if (flags & wxSOUND_ASYNC)
372 {
373 lastSoundTimer = ((wxSMTimer*&)m_pTimer)
374 = new wxSMTimer(pSndChannel, m_hSnd, flags & wxSOUND_LOOP ? 1 : 0,
375 &lastSoundIsPlaying);
376 lastSoundIsPlaying = true;
377
378 ((wxTimer*)m_pTimer)->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
379 }
380 else
381 SndDisposeChannel(pSndChannel, TRUE);
382
383 return true;
384 }
385 break;
386 case wxSound_FILE:
387 {
388 if (!wxInitQT())
389 return false;
390
391 OSErr err = noErr ;
392
393 Handle dataRef = NULL;
394 OSType dataRefType;
395
396 err = QTNewDataReferenceFromFullPathCFString(wxCFStringRef(m_sndname,wxLocale::GetSystemEncoding()),
397 (UInt32)kQTNativeDefaultPathStyle, 0, &dataRef, &dataRefType);
398
399 wxASSERT(err == noErr);
400
401 if (NULL != dataRef || err != noErr)
402 {
403 err = NewMovieFromDataRef( &movie, newMovieDontAskUnresolvedDataRefs , NULL, dataRef, dataRefType );
404 wxASSERT(err == noErr);
405 DisposeHandle(dataRef);
406 }
407
408 if (err != noErr)
409 {
410 wxLogSysError(
411 wxString::Format(wxT("wxSound - Could not open file: %s\nError:%i"), m_sndname.c_str(), err )
412 );
413 return false;
414 }
415 }
416 break;
417 default:
418 return false;
419 }//end switch(m_type)
420
421 //Start the movie!
422 StartMovie(movie);
423
424 if (flags & wxSOUND_ASYNC)
425 {
426 //Start timer and play movie asyncronously
427 lastSoundTimer = ((wxQTTimer*&)m_pTimer) =
428 new wxQTTimer(movie, flags & wxSOUND_LOOP ? 1 : 0,
429 &lastSoundIsPlaying);
430 lastSoundIsPlaying = true;
431 ((wxQTTimer*)m_pTimer)->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
432 }
433 else
434 {
435 wxASSERT_MSG(!(flags & wxSOUND_LOOP), wxT("Can't loop and play syncronously at the same time"));
436
437 //Play movie until it ends, then exit
438 //Note that due to quicktime caching this may not always
439 //work 100% correctly
440 while (!IsMovieDone(movie))
441 MoviesTask(movie, 1);
442
443 DisposeMovie(movie);
444 }
445 #endif
446
447 return true;
448 }
449
450 bool wxSound::IsPlaying()
451 {
452 return lastSoundIsPlaying;
453 }
454
455 void wxSound::Stop()
456 {
457 if (lastSoundIsPlaying)
458 {
459 delete (wxTimer*&) lastSoundTimer;
460 lastSoundIsPlaying = false;
461 lastSoundTimer = NULL;
462 }
463 }
464
465 void* wxSound::GetHandle()
466 {
467 #if USE_QUICKTIME
468 if(m_type == wxSound_RESOURCE)
469 return (void*) ((wxSMTimer*)m_pTimer)->GetChannel();
470
471 return (void*) ((wxQTTimer*) m_pTimer)->GetMovie();
472 #endif
473 return NULL;
474 }
475
476 #endif //wxUSE_SOUND