src/mac/carbon/sound.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/mac/carbon/sound.cpp
// Purpose:     wxSound class implementation: optional
// Author:      Ryan Norton
// Modified by: Stefan Csomor
// Created:     1998-01-01
// RCS-ID:      $Id$
// Copyright:   (c) Ryan Norton
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#if wxUSE_SOUND

#include "wx/sound.h"

#ifndef WX_PRECOMP
    #include "wx/object.h"
    #include "wx/string.h"
    #include "wx/intl.h"
    #include "wx/log.h"
#endif

#include "wx/file.h"
#include "wx/timer.h"

// Carbon QT Implementation Details -
//
// Memory:
// 1) OpenDefaultComponent(MovieImportType, kQTFileTypeWave);
// 2) NewMovie(0);
// 3) MovieImportDataRef() //Pass Memory Location to this
// 4) PlayMovie();
// 5) IsMovieDone(), MoviesTask() //2nd param is minimum wait time to allocate to quicktime
//
// File:
// 1) Obtain FSSpec
// 2) Call OpenMovieFile
// 3) Call NewMovieFromFile
// 4) Call CloseMovieFile
// 4) PlayMovie();
// 5) IsMovieDone(), MoviesTask() //2nd param is minimum wait time to allocate to quicktime
//

#ifdef __WXMAC__
#include "wx/mac/uma.h"
#ifndef __DARWIN__
#include <Movies.h>
#include <Gestalt.h>
#endif
#endif

#if defined __WXMAC__ && defined __DARWIN__/*TARGET_CARBON*/
#ifdef __APPLE_CC__
#include <Carbon/Carbon.h>
#else
#include <Carbon.h>
#endif
#else
#include <Sound.h>
#endif

//quicktime media layer only required for mac emulation on pc
#ifndef __WXMAC__
#include <qtml.h>
#endif

#ifndef __DARWIN__
#include <QuickTimeComponents.h>
#else
#include <QuickTime/QuickTimeComponents.h>
#endif

//Time between timer calls
#define MOVIE_DELAY 100

static wxTimer* lastSoundTimer=NULL;
static bool lastSoundIsPlaying=false;

// ------------------------------------------------------------------
//          wxQTTimer - Handle Asyncronous Playing
// ------------------------------------------------------------------
class wxQTTimer : public wxTimer
{
public:
    wxQTTimer(Movie movie, bool bLoop, bool* playing) :
        m_movie(movie), m_bLoop(bLoop), m_pbPlaying(playing)
    {
    }

    ~wxQTTimer()
    {
        if(m_pbPlaying)
            *m_pbPlaying = false;

        StopMovie(m_movie);
        DisposeMovie(m_movie);
        Stop();

        //Note that ExitMovies() is not necessary, but
        //the docs are fuzzy on whether or not TerminateQTML is
        ExitMovies();

#ifndef __WXMAC__
        TerminateQTML();
#endif
    }

    void Shutdown()
    {
        delete this;
    }

    void Notify()
    {
        if (m_pbPlaying && !*m_pbPlaying)
        {
            Shutdown();
        }

        if(IsMovieDone(m_movie))
        {
            if (!m_bLoop)
                Shutdown();
            else
            {
                StopMovie(m_movie);
                GoToBeginningOfMovie(m_movie);
                StartMovie(m_movie);
            }
        }
        else
            MoviesTask(m_movie, MOVIE_DELAY); //Give QT time to play movie
    }


    Movie& GetMovie() {return m_movie;}

protected:
    Movie m_movie;
    bool m_bLoop;

public:
    bool* m_pbPlaying;

};


class wxSMTimer : public wxTimer
{
public:
    wxSMTimer(void* hSnd, void* pSndChannel, bool bLoop, bool* playing)
        : m_hSnd(hSnd), m_pSndChannel(pSndChannel), m_bLoop(bLoop), m_pbPlaying(playing)
    {
    }

    ~wxSMTimer()
    {
        if(m_pbPlaying)
            *m_pbPlaying = false;
        SndDisposeChannel((SndChannelPtr)m_pSndChannel, TRUE);
        Stop();
    }

    void Notify()
    {
        if (m_pbPlaying && !*m_pbPlaying)
        {
            Shutdown();
        }

        SCStatus stat;

        if (SndChannelStatus((SndChannelPtr)m_pSndChannel, sizeof(SCStatus), &stat) != 0)
            Shutdown();

        //if the sound isn't playing anymore, see if it's looped,
        //and if so play it again, otherwise close things up
        if (stat.scChannelBusy == FALSE)
        {
            if (m_bLoop)
            {
                if(SndPlay((SndChannelPtr)m_pSndChannel, (SndListHandle) m_hSnd, true) != noErr)
                    Shutdown();
            }
            else
                Shutdown();
        }
    }

    void Shutdown()
    {
        delete this;
    }

    void* GetChannel() {return m_pSndChannel;}

protected:
    void* m_hSnd;
    void* m_pSndChannel;
    bool m_bLoop;

public:
    bool* m_pbPlaying;
};

// ------------------------------------------------------------------
//          wxSound
// ------------------------------------------------------------------

//Determines whether version 4 of QT is installed
Boolean wxIsQuickTime4Installed (void)
{
#ifdef __WXMAC__
    short error;
    long result;

    error = Gestalt (gestaltQuickTime, &result);
    return (error == noErr) && (((result >> 16) & 0xffff) >= 0x0400);
#else
    return true;
#endif
}

inline bool wxInitQT ()
{
    if (wxIsQuickTime4Installed())
    {
        #ifndef __WXMAC__
        int nError;
        //-2093 no dll
            if ((nError = InitializeQTML(0)) != noErr)
                wxLogSysError(wxString::Format(wxT("Couldn't Initialize Quicktime-%i"), nError));
        #endif
        EnterMovies();
        return true;
    }
    else
    {
        wxLogSysError(wxT("Quicktime is not installed, or Your Version of Quicktime is <= 4."));
        return false;
    }
}

wxSound::wxSound()
: m_hSnd(NULL), m_waveLength(0), m_pTimer(NULL), m_type(wxSound_NONE)
{
}

wxSound::wxSound(const wxString& sFileName, bool isResource)
: m_hSnd(NULL), m_waveLength(0), m_pTimer(NULL), m_type(wxSound_NONE)
{
    Create(sFileName, isResource);
}

wxSound::wxSound(int size, const wxByte* data)
: m_hSnd((char*)data), m_waveLength(size), m_pTimer(NULL), m_type(wxSound_MEMORY)
{
}

wxSound::~wxSound()
{
}

bool wxSound::Create(const wxString& fileName, bool isResource)
{
    Stop();

    if (isResource)
    {
#ifdef __WXMAC__
        m_type = wxSound_RESOURCE;

        Str255 lpSnd ;

        wxMacStringToPascal( fileName , lpSnd ) ;

        m_sndname = fileName;
        m_hSnd = (char*) GetNamedResource('snd ', (const unsigned char *) lpSnd);
#else
        return false;
#endif
    }
    else
    {
        m_type = wxSound_FILE;
        m_sndname = fileName;
    }

    return true;
}

bool wxSound::DoPlay(unsigned flags) const
{
    Stop();

    Movie movie;

    switch(m_type)
    {
    case wxSound_MEMORY:
        {
            if (!wxInitQT())
                return false;
            Handle myHandle, dataRef = nil;
            MovieImportComponent miComponent;
            Track targetTrack = nil;
            TimeValue addedDuration = 0;
            long outFlags = 0;
            OSErr err;
            ComponentResult result;

            myHandle = NewHandleClear((Size)m_waveLength);

            BlockMove(m_hSnd, *myHandle, m_waveLength);

            err = PtrToHand(&myHandle, &dataRef, sizeof(Handle));

            if (memcmp(&m_hSnd[8], "WAVE", 4) == 0)
                miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeWave);
            else if (memcmp(&m_hSnd[8], "AIFF", 4) == 0)
                miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeAIFF);
            else if (memcmp(&m_hSnd[8], "AIFC", 4) == 0)
                miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeAIFC);
            else
            {
                wxLogSysError(wxT("wxSound - Location in memory does not contain valid data"));
                return false;
            }

            movie = NewMovie(0);

            result = MovieImportDataRef(miComponent,                dataRef,
                                        HandleDataHandlerSubType,   movie,
                                        nil,                        &targetTrack,
                                        nil,                        &addedDuration,
                                        movieImportCreateTrack,     &outFlags);

            if (result != noErr)
            {
                wxLogSysError(wxString::Format(wxT("Couldn't import movie data\nError:%i"), (int)result));
            }

            SetMovieVolume(movie, kFullVolume);
            GoToBeginningOfMovie(movie);

            DisposeHandle(myHandle);
        }
        break;
    case wxSound_RESOURCE:
        {
            SoundComponentData data;
            unsigned long numframes, offset;

            ParseSndHeader((SndListHandle)m_hSnd, &data, &numframes, &offset);
            //m_waveLength = numFrames * data.numChannels;

            SndChannelPtr pSndChannel;
            SndNewChannel(&pSndChannel, sampledSynth,
                initNoInterp
                + (data.numChannels == 1 ? initMono : initStereo), NULL);

            if(SndPlay(pSndChannel, (SndListHandle) m_hSnd, flags & wxSOUND_ASYNC ? 1 : 0) != noErr)
                return false;

            if (flags & wxSOUND_ASYNC)
            {
                lastSoundTimer = ((wxSMTimer*&)m_pTimer)
                    = new wxSMTimer(pSndChannel, m_hSnd, flags & wxSOUND_LOOP ? 1 : 0,
                                    &lastSoundIsPlaying);
                lastSoundIsPlaying = true;

                ((wxTimer*)m_pTimer)->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
            }
            else
                SndDisposeChannel(pSndChannel, TRUE);

            return true;
        }
        break;
    case wxSound_FILE:
        {
            if (!wxInitQT())
                return false;

            OSErr err = noErr ;
//NB:  RN: Stefan - I think the 10.3 path functions are broken if kQTNativeDefaultPathStyle is
//going to trigger a warning every time it is used - where its _supposed to be used_!!
//(kQTNativePathStyle is negative but the function argument is unsigned!)
//../src/mac/carbon/sound.cpp: In member function `virtual bool
//   wxSound::DoPlay(unsigned int) const':
//../src/mac/carbon/sound.cpp:387: warning: passing negative value `
//   kQTNativeDefaultPathStyle' for argument passing 2 of `OSErr
//   QTNewDataReferenceFromFullPathCFString(const __CFString*, long unsigned int,
//   long unsigned int, char***, OSType*)'
//../src/mac/carbon/sound.cpp:387: warning: argument of negative value `
//   kQTNativeDefaultPathStyle' to `long unsigned int'
#if defined( __WXMAC__ ) && TARGET_API_MAC_OSX && ( MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2 )
            if ( UMAGetSystemVersion() >= 0x1030 )
            {
                Handle dataRef = NULL;
                OSType dataRefType;

                err = QTNewDataReferenceFromFullPathCFString(wxMacCFStringHolder(m_sndname,wxLocale::GetSystemEncoding()),
                    //FIXME: Why does this have to be casted?
                    (unsigned int)kQTNativeDefaultPathStyle,
                    //FIXME: End
                    0, &dataRef, &dataRefType);

                wxASSERT(err == noErr);

                if (NULL != dataRef || err != noErr)
                {
                    err = NewMovieFromDataRef( &movie, newMovieDontAskUnresolvedDataRefs , NULL, dataRef, dataRefType );
                    wxASSERT(err == noErr);
                    DisposeHandle(dataRef);
                }
            }
            else
#endif
            {
                short movieResFile;
                FSSpec sfFile;
#ifdef __WXMAC__
                wxMacFilename2FSSpec( m_sndname , &sfFile ) ;
#else
                int nError;
                if ((nError = NativePathNameToFSSpec ((char*) m_sndname.c_str(), &sfFile, 0)) != noErr)
                {
/*
                    wxLogSysError(wxString::Format(wxT("File:%s does not exist\nError:%i"),
                                    m_sndname.c_str(), nError));
*/
                    return false;
                }
#endif
                if (OpenMovieFile (&sfFile, &movieResFile, fsRdPerm) != noErr)
                {
                    wxLogSysError(wxT("Quicktime couldn't open the file"));
                    return false;
                }
                short movieResID = 0;
                Str255 movieName;

                err = NewMovieFromFile (
                &movie,
                movieResFile,
                &movieResID,
                movieName,
                newMovieActive,
                NULL); //wasChanged

                CloseMovieFile (movieResFile);
            }

            if (err != noErr)
            {
                wxLogSysError(
                    wxString::Format(wxT("wxSound - Could not open file: %s\nError:%i"), m_sndname.c_str(), err )
                    );
                return false;
            }
        }
        break;
    default:
        return false;
    }//end switch(m_type)

    //Start the movie!
    StartMovie(movie);

    if (flags & wxSOUND_ASYNC)
    {
        //Start timer and play movie asyncronously
        lastSoundTimer = ((wxQTTimer*&)m_pTimer) =
            new wxQTTimer(movie, flags & wxSOUND_LOOP ? 1 : 0,
                          &lastSoundIsPlaying);
        lastSoundIsPlaying = true;
        ((wxQTTimer*)m_pTimer)->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
    }
    else
    {
        wxASSERT_MSG(!(flags & wxSOUND_LOOP), wxT("Can't loop and play syncronously at the same time"));

        //Play movie until it ends, then exit
        //Note that due to quicktime caching this may not always
        //work 100% correctly
        while (!IsMovieDone(movie))
            MoviesTask(movie, 1);

        DisposeMovie(movie);
    }

    return true;
}

bool wxSound::IsPlaying()
{
    return lastSoundIsPlaying;
}

void wxSound::Stop()
{
    if (lastSoundIsPlaying)
    {
        delete (wxTimer*&) lastSoundTimer;
        lastSoundIsPlaying = false;
        lastSoundTimer = NULL;
    }
}

void* wxSound::GetHandle()
{
    if(m_type == wxSound_RESOURCE)
        return (void*)  ((wxSMTimer*)m_pTimer)->GetChannel();

    return (void*) ((wxQTTimer*) m_pTimer)->GetMovie();
}

#endif //wxUSE_SOUND
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	#endif
	25
	26	#include "wx/file.h"
	27	#include "wx/timer.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) Obtain FSSpec
	40	// 2) Call OpenMovieFile
	41	// 3) Call NewMovieFromFile
	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	#if defined __WXMAC__ && defined __DARWIN__/TARGET_CARBON/
	56	#ifdef __APPLE_CC__
	57	#include <Carbon/Carbon.h>
	58	#else
	59	#include <Carbon.h>
	60	#endif
	61	#else
	62	#include <Sound.h>
	63	#endif
	64
	65	//quicktime media layer only required for mac emulation on pc
	66	#ifndef __WXMAC__
	67	#include <qtml.h>
	68	#endif
	69
	70	#ifndef __DARWIN__
	71	#include <QuickTimeComponents.h>
	72	#else
	73	#include <QuickTime/QuickTimeComponents.h>
	74	#endif
	75
	76	//Time between timer calls
	77	#define MOVIE_DELAY 100
	78
	79	static wxTimer* lastSoundTimer=NULL;
	80	static bool lastSoundIsPlaying=false;
	81
	82	// ------------------------------------------------------------------
	83	// wxQTTimer - Handle Asyncronous Playing
	84	// ------------------------------------------------------------------
	85	class wxQTTimer : public wxTimer
	86	{
	87	public:
	88	wxQTTimer(Movie movie, bool bLoop, bool* playing) :
	89	m_movie(movie), m_bLoop(bLoop), m_pbPlaying(playing)
	90	{
	91	}
	92
	93	~wxQTTimer()
	94	{
	95	if(m_pbPlaying)
	96	*m_pbPlaying = false;
	97
	98	StopMovie(m_movie);
	99	DisposeMovie(m_movie);
	100	Stop();
	101
	102	//Note that ExitMovies() is not necessary, but
	103	//the docs are fuzzy on whether or not TerminateQTML is
	104	ExitMovies();
	105
	106	#ifndef __WXMAC__
	107	TerminateQTML();
	108	#endif
	109	}
	110
	111	void Shutdown()
	112	{
	113	delete this;
	114	}
	115
	116	void Notify()
	117	{
	118	if (m_pbPlaying && !*m_pbPlaying)
	119	{
	120	Shutdown();
	121	}
	122
	123	if(IsMovieDone(m_movie))
	124	{
	125	if (!m_bLoop)
	126	Shutdown();
	127	else
	128	{
	129	StopMovie(m_movie);
	130	GoToBeginningOfMovie(m_movie);
	131	StartMovie(m_movie);
	132	}
	133	}
	134	else
	135	MoviesTask(m_movie, MOVIE_DELAY); //Give QT time to play movie
	136	}
	137
	138
	139	Movie& GetMovie() {return m_movie;}
	140
	141	protected:
	142	Movie m_movie;
	143	bool m_bLoop;
	144
	145	public:
	146	bool* m_pbPlaying;
	147
	148	};
	149
	150
	151	class wxSMTimer : public wxTimer
	152	{
	153	public:
	154	wxSMTimer(void* hSnd, void* pSndChannel, bool bLoop, bool* playing)
	155	: m_hSnd(hSnd), m_pSndChannel(pSndChannel), m_bLoop(bLoop), m_pbPlaying(playing)
	156	{
	157	}
	158
	159	~wxSMTimer()
	160	{
	161	if(m_pbPlaying)
	162	*m_pbPlaying = false;
	163	SndDisposeChannel((SndChannelPtr)m_pSndChannel, TRUE);
	164	Stop();
	165	}
	166
	167	void Notify()
	168	{
	169	if (m_pbPlaying && !*m_pbPlaying)
	170	{
	171	Shutdown();
	172	}
	173
	174	SCStatus stat;
	175
	176	if (SndChannelStatus((SndChannelPtr)m_pSndChannel, sizeof(SCStatus), &stat) != 0)
	177	Shutdown();
	178
	179	//if the sound isn't playing anymore, see if it's looped,
	180	//and if so play it again, otherwise close things up
	181	if (stat.scChannelBusy == FALSE)
	182	{
	183	if (m_bLoop)
	184	{
	185	if(SndPlay((SndChannelPtr)m_pSndChannel, (SndListHandle) m_hSnd, true) != noErr)
	186	Shutdown();
	187	}
	188	else
	189	Shutdown();
	190	}
	191	}
	192
	193	void Shutdown()
	194	{
	195	delete this;
	196	}
	197
	198	void* GetChannel() {return m_pSndChannel;}
	199
	200	protected:
	201	void* m_hSnd;
	202	void* m_pSndChannel;
	203	bool m_bLoop;
	204
	205	public:
	206	bool* m_pbPlaying;
	207	};
	208
	209	// ------------------------------------------------------------------
	210	// wxSound
	211	// ------------------------------------------------------------------
	212
	213	//Determines whether version 4 of QT is installed
	214	Boolean wxIsQuickTime4Installed (void)
	215	{
	216	#ifdef __WXMAC__
	217	short error;
	218	long result;
	219
	220	error = Gestalt (gestaltQuickTime, &result);
	221	return (error == noErr) && (((result >> 16) & 0xffff) >= 0x0400);
	222	#else
	223	return true;
	224	#endif
	225	}
	226
	227	inline bool wxInitQT ()
	228	{
	229	if (wxIsQuickTime4Installed())
	230	{
	231	#ifndef __WXMAC__
	232	int nError;
	233	//-2093 no dll
	234	if ((nError = InitializeQTML(0)) != noErr)
	235	wxLogSysError(wxString::Format(wxT("Couldn't Initialize Quicktime-%i"), nError));
	236	#endif
	237	EnterMovies();
	238	return true;
	239	}
	240	else
	241	{
	242	wxLogSysError(wxT("Quicktime is not installed, or Your Version of Quicktime is <= 4."));
	243	return false;
	244	}
	245	}
	246
	247	wxSound::wxSound()
	248	: m_hSnd(NULL), m_waveLength(0), m_pTimer(NULL), m_type(wxSound_NONE)
	249	{
	250	}
	251
	252	wxSound::wxSound(const wxString& sFileName, bool isResource)
	253	: m_hSnd(NULL), m_waveLength(0), m_pTimer(NULL), m_type(wxSound_NONE)
	254	{
	255	Create(sFileName, isResource);
	256	}
	257
	258	wxSound::wxSound(int size, const wxByte* data)
	259	: m_hSnd((char*)data), m_waveLength(size), m_pTimer(NULL), m_type(wxSound_MEMORY)
	260	{
	261	}
	262
	263	wxSound::~wxSound()
	264	{
	265	}
	266
	267	bool wxSound::Create(const wxString& fileName, bool isResource)
	268	{
	269	Stop();
	270
	271	if (isResource)
	272	{
	273	#ifdef __WXMAC__
	274	m_type = wxSound_RESOURCE;
	275
	276	Str255 lpSnd ;
	277
	278	wxMacStringToPascal( fileName , lpSnd ) ;
	279
	280	m_sndname = fileName;
	281	m_hSnd = (char) GetNamedResource('snd ', (const unsigned char ) lpSnd);
	282	#else
	283	return false;
	284	#endif
	285	}
	286	else
	287	{
	288	m_type = wxSound_FILE;
	289	m_sndname = fileName;
	290	}
	291
	292	return true;
	293	}
	294
	295	bool wxSound::DoPlay(unsigned flags) const
	296	{
	297	Stop();
	298
	299	Movie movie;
	300
	301	switch(m_type)
	302	{
	303	case wxSound_MEMORY:
	304	{
	305	if (!wxInitQT())
	306	return false;
	307	Handle myHandle, dataRef = nil;
	308	MovieImportComponent miComponent;
	309	Track targetTrack = nil;
	310	TimeValue addedDuration = 0;
	311	long outFlags = 0;
	312	OSErr err;
	313	ComponentResult result;
	314
	315	myHandle = NewHandleClear((Size)m_waveLength);
	316
	317	BlockMove(m_hSnd, *myHandle, m_waveLength);
	318
	319	err = PtrToHand(&myHandle, &dataRef, sizeof(Handle));
	320
	321	if (memcmp(&m_hSnd[8], "WAVE", 4) == 0)
	322	miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeWave);
	323	else if (memcmp(&m_hSnd[8], "AIFF", 4) == 0)
	324	miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeAIFF);
	325	else if (memcmp(&m_hSnd[8], "AIFC", 4) == 0)
	326	miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeAIFC);
	327	else
	328	{
	329	wxLogSysError(wxT("wxSound - Location in memory does not contain valid data"));
	330	return false;
	331	}
	332
	333	movie = NewMovie(0);
	334
	335	result = MovieImportDataRef(miComponent, dataRef,
	336	HandleDataHandlerSubType, movie,
	337	nil, &targetTrack,
	338	nil, &addedDuration,
	339	movieImportCreateTrack, &outFlags);
	340
	341	if (result != noErr)
	342	{
	343	wxLogSysError(wxString::Format(wxT("Couldn't import movie data\nError:%i"), (int)result));
	344	}
	345
	346	SetMovieVolume(movie, kFullVolume);
	347	GoToBeginningOfMovie(movie);
	348
	349	DisposeHandle(myHandle);
	350	}
	351	break;
	352	case wxSound_RESOURCE:
	353	{
	354	SoundComponentData data;
	355	unsigned long numframes, offset;
	356
	357	ParseSndHeader((SndListHandle)m_hSnd, &data, &numframes, &offset);
	358	//m_waveLength = numFrames * data.numChannels;
	359
	360	SndChannelPtr pSndChannel;
	361	SndNewChannel(&pSndChannel, sampledSynth,
	362	initNoInterp
	363	+ (data.numChannels == 1 ? initMono : initStereo), NULL);
	364
	365	if(SndPlay(pSndChannel, (SndListHandle) m_hSnd, flags & wxSOUND_ASYNC ? 1 : 0) != noErr)
	366	return false;
	367
	368	if (flags & wxSOUND_ASYNC)
	369	{
	370	lastSoundTimer = ((wxSMTimer*&)m_pTimer)
	371	= new wxSMTimer(pSndChannel, m_hSnd, flags & wxSOUND_LOOP ? 1 : 0,
	372	&lastSoundIsPlaying);
	373	lastSoundIsPlaying = true;
	374
	375	((wxTimer*)m_pTimer)->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
	376	}
	377	else
	378	SndDisposeChannel(pSndChannel, TRUE);
	379
	380	return true;
	381	}
	382	break;
	383	case wxSound_FILE:
	384	{
	385	if (!wxInitQT())
	386	return false;
	387
	388	OSErr err = noErr ;
	389	//NB: RN: Stefan - I think the 10.3 path functions are broken if kQTNativeDefaultPathStyle is
	390	//going to trigger a warning every time it is used - where its _supposed to be used_!!
	391	//(kQTNativePathStyle is negative but the function argument is unsigned!)
	392	//../src/mac/carbon/sound.cpp: In member function `virtual bool
	393	// wxSound::DoPlay(unsigned int) const':
	394	//../src/mac/carbon/sound.cpp:387: warning: passing negative value `
	395	// kQTNativeDefaultPathStyle' for argument passing 2 of `OSErr
	396	// QTNewDataReferenceFromFullPathCFString(const __CFString*, long unsigned int,
	397	// long unsigned int, char**, OSType)'
	398	//../src/mac/carbon/sound.cpp:387: warning: argument of negative value `
	399	// kQTNativeDefaultPathStyle' to `long unsigned int'
	400	#if defined( __WXMAC__ ) && TARGET_API_MAC_OSX && ( MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2 )
	401	if ( UMAGetSystemVersion() >= 0x1030 )
	402	{
	403	Handle dataRef = NULL;
	404	OSType dataRefType;
	405
	406	err = QTNewDataReferenceFromFullPathCFString(wxMacCFStringHolder(m_sndname,wxLocale::GetSystemEncoding()),
	407	//FIXME: Why does this have to be casted?
	408	(unsigned int)kQTNativeDefaultPathStyle,
	409	//FIXME: End
	410	0, &dataRef, &dataRefType);
	411
	412	wxASSERT(err == noErr);
	413
	414	if (NULL != dataRef \|\| err != noErr)
	415	{
	416	err = NewMovieFromDataRef( &movie, newMovieDontAskUnresolvedDataRefs , NULL, dataRef, dataRefType );
	417	wxASSERT(err == noErr);
	418	DisposeHandle(dataRef);
	419	}
	420	}
	421	else
	422	#endif
	423	{
	424	short movieResFile;
	425	FSSpec sfFile;
	426	#ifdef __WXMAC__
	427	wxMacFilename2FSSpec( m_sndname , &sfFile ) ;
	428	#else
	429	int nError;
	430	if ((nError = NativePathNameToFSSpec ((char*) m_sndname.c_str(), &sfFile, 0)) != noErr)
	431	{
	432	/*
	433	wxLogSysError(wxString::Format(wxT("File:%s does not exist\nError:%i"),
	434	m_sndname.c_str(), nError));
	435	*/
	436	return false;
	437	}
	438	#endif
	439	if (OpenMovieFile (&sfFile, &movieResFile, fsRdPerm) != noErr)
	440	{
	441	wxLogSysError(wxT("Quicktime couldn't open the file"));
	442	return false;
	443	}
	444	short movieResID = 0;
	445	Str255 movieName;
	446
	447	err = NewMovieFromFile (
	448	&movie,
	449	movieResFile,
	450	&movieResID,
	451	movieName,
	452	newMovieActive,
	453	NULL); //wasChanged
	454
	455	CloseMovieFile (movieResFile);
	456	}
	457
	458	if (err != noErr)
	459	{
	460	wxLogSysError(
	461	wxString::Format(wxT("wxSound - Could not open file: %s\nError:%i"), m_sndname.c_str(), err )
	462	);
	463	return false;
	464	}
	465	}
	466	break;
	467	default:
	468	return false;
	469	}//end switch(m_type)
	470
	471	//Start the movie!
	472	StartMovie(movie);
	473
	474	if (flags & wxSOUND_ASYNC)
	475	{
	476	//Start timer and play movie asyncronously
	477	lastSoundTimer = ((wxQTTimer*&)m_pTimer) =
	478	new wxQTTimer(movie, flags & wxSOUND_LOOP ? 1 : 0,
	479	&lastSoundIsPlaying);
	480	lastSoundIsPlaying = true;
	481	((wxQTTimer*)m_pTimer)->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
	482	}
	483	else
	484	{
	485	wxASSERT_MSG(!(flags & wxSOUND_LOOP), wxT("Can't loop and play syncronously at the same time"));
	486
	487	//Play movie until it ends, then exit
	488	//Note that due to quicktime caching this may not always
	489	//work 100% correctly
	490	while (!IsMovieDone(movie))
	491	MoviesTask(movie, 1);
	492
	493	DisposeMovie(movie);
	494	}
	495
	496	return true;
	497	}
	498
	499	bool wxSound::IsPlaying()
	500	{
	501	return lastSoundIsPlaying;
	502	}
	503
	504	void wxSound::Stop()
	505	{
	506	if (lastSoundIsPlaying)
	507	{
	508	delete (wxTimer*&) lastSoundTimer;
	509	lastSoundIsPlaying = false;
	510	lastSoundTimer = NULL;
	511	}
	512	}
	513
	514	void* wxSound::GetHandle()
	515	{
	516	if(m_type == wxSound_RESOURCE)
	517	return (void) ((wxSMTimer)m_pTimer)->GetChannel();
	518
	519	return (void) ((wxQTTimer) m_pTimer)->GetMovie();
	520	}
	521
	522	#endif //wxUSE_SOUND