]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/mac/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/mac/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(wxMacCFStringHolder(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 |