[sdl_omap.git] / src / audio / symbian / SDL_epocaudio.cpp

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga
    slouken@devolution.com
*/

/*
    SDL_epocaudio.cpp
    Epoc based SDL audio driver implementation
    
    Markus Mertama
*/

#ifdef SAVE_RCSID
static char rcsid =
 "@(#) $Id: SDL_epocaudio.c,v 0.0.0.0 2001/06/19 17:19:56 hercules Exp $";
#endif


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <sys/stat.h>

#include "epoc_sdl.h"

#include <e32hal.h>


extern "C" {
#include "SDL_audio.h"
#include "SDL_error.h"
#include "SDL_audiomem.h"
#include "SDL_audio_c.h"
#include "SDL_timer.h"
#include "SDL_audiodev_c.h"
}

#include "SDL_epocaudio.h"

#include "streamplayer.h"


//#define DEBUG_AUDIO


/* Audio driver functions */

static int EPOC_OpenAudio(SDL_AudioDevice *thisdevice, SDL_AudioSpec *spec);
static void EPOC_WaitAudio(SDL_AudioDevice *thisdevice);
static void EPOC_PlayAudio(SDL_AudioDevice *thisdevice);
static Uint8 *EPOC_GetAudioBuf(SDL_AudioDevice *thisdevice);
static void EPOC_CloseAudio(SDL_AudioDevice *thisdevice);
static void EPOC_ThreadInit(SDL_AudioDevice *thisdevice);

static int Audio_Available(void);
static SDL_AudioDevice *Audio_CreateDevice(int devindex);
static void Audio_DeleteDevice(SDL_AudioDevice *device);


//void sos_adump(SDL_AudioDevice* thisdevice, void* data, int len);

#ifdef __WINS__
#define DODUMP
#endif

#ifdef DODUMP
NONSHARABLE_CLASS(TDump)
	{
	public:
	TInt Open();
	void Close();
	void Dump(const TDesC8& aDes);
	private:
		RFile iFile;
    	RFs iFs; 
	};
	
TInt TDump::Open()
	{
	TInt err = iFs.Connect();
	if(err == KErrNone)
		{
#ifdef __WINS__
_LIT(target, "C:\\sdlau.raw");
#else
_LIT(target, "E:\\sdlau.raw");
#endif 
		err = iFile.Replace(iFs, target, EFileWrite);
		}
	return err;
	}
void TDump::Close()
	{
	iFile.Close();
	iFs.Close();
	}
void TDump::Dump(const TDesC8& aDes)
	{
	iFile.Write(aDes);
	}
#endif


NONSHARABLE_CLASS(CSimpleWait) : public CTimer
	{
	public:
		void Wait(TTimeIntervalMicroSeconds32 aWait);
		static CSimpleWait* NewL();
	private:
		CSimpleWait();
		void RunL();
	};


CSimpleWait* CSimpleWait::NewL()
	{
	CSimpleWait* wait = new (ELeave) CSimpleWait();
	CleanupStack::PushL(wait);
	wait->ConstructL();
	CleanupStack::Pop();
	return wait;
	}

void CSimpleWait::Wait(TTimeIntervalMicroSeconds32 aWait)
	{
	After(aWait);
	CActiveScheduler::Start();
	}
	
CSimpleWait::CSimpleWait() : CTimer(CActive::EPriorityStandard)	
	{
	CActiveScheduler::Add(this);
	}

void CSimpleWait::RunL()
	{
	CActiveScheduler::Stop();
	}

const TInt KAudioBuffers(2);
	

NONSHARABLE_CLASS(CEpocAudio) : public CBase, public MStreamObs, public MStreamProvider
    {
    public:
    	static void* NewL(TInt BufferSize, TInt aFill);
    	inline static CEpocAudio& Current(SDL_AudioDevice* thisdevice);
    	
    	static void Free(SDL_AudioDevice* thisdevice);
 		
    	void Wait();
    	void Play();
    //	void SetBuffer(const TDesC8& aBuffer);
    	void ThreadInitL(TAny* aDevice);
    	void Open(TInt iRate, TInt iChannels, TUint32 aType, TInt aBytes);
    	~CEpocAudio();
    	TUint8* Buffer();
    	TBool SetPause(TBool aPause);
    #ifdef DODUMP
    	void Dump(const TDesC8& aBuf) {iDump.Dump(aBuf);}
    #endif
    private:
    	CEpocAudio(TInt aBufferSize);
    	void Complete(TInt aState, TInt aError);
    	TPtrC8 Data();
    	void ConstructL(TInt aFill);
    private:
    	TInt iBufferSize;
    	CStreamPlayer* iPlayer;
    	TInt iBufferRate;
    	TInt iRate;
    	TInt iChannels;
    	TUint32 iType;
    	TInt iPosition;
    	TThreadId iTid;
    	TUint8* iAudioPtr;
    	TUint8* iBuffer;
    //	TTimeIntervalMicroSeconds iStart;
    	TTime iStart;
    	TInt iTune;
    	CSimpleWait* iWait;
    #ifdef DODUMP
    	TDump iDump;
    #endif
    };

inline CEpocAudio& CEpocAudio::Current(SDL_AudioDevice* thisdevice)
	{
	return *static_cast<CEpocAudio*>((void*)thisdevice->hidden);
	}
	
/*

TBool EndSc(TAny*)
	{	
	CActiveScheduler::Stop();
	}
	
LOCAL_C void CleanScL()
	{
	CIdle* d = CIdle::NewLC(CActive:::EPriorityIdle);
	d->Start(TCallBack(EndSc));
	CActiveScheduler::Start();
	
	}
*/
	
void CEpocAudio::Free(SDL_AudioDevice* thisdevice)
	{
    CEpocAudio* ea = static_cast<CEpocAudio*>((void*)thisdevice->hidden);
    if(ea)
    	{
		ASSERT(ea->iTid == RThread().Id());
    	delete ea;
    	thisdevice->hidden = NULL;	
   
    	CActiveScheduler* as =  CActiveScheduler::Current();
    	ASSERT(as->StackDepth() == 0);    	
    	delete as;
    	CActiveScheduler::Install(NULL);
    	}
    ASSERT(thisdevice->hidden == NULL);
	}
	
CEpocAudio::CEpocAudio(TInt aBufferSize) : iBufferSize(aBufferSize), iPosition(-1) 
	{
	}

void* CEpocAudio::NewL(TInt aBufferSize, TInt aFill)
	{
	CEpocAudio* eAudioLib = new (ELeave) CEpocAudio(aBufferSize);
	CleanupStack::PushL(eAudioLib);
	eAudioLib->ConstructL(aFill);
	CleanupStack::Pop();
	return eAudioLib;
	}
	
void CEpocAudio::ConstructL(TInt aFill)
	{
	iBuffer = (TUint8*) User::AllocL(KAudioBuffers * iBufferSize);
	memset(iBuffer, aFill, KAudioBuffers * iBufferSize);
	iAudioPtr = iBuffer;
	}


TBool CEpocAudio::SetPause(TBool aPause)
	{
	if(aPause && iPosition >= 0)
		{
		iPosition = -1;
		if(iPlayer != NULL)
			iPlayer->Stop();
		}
	if(!aPause && iPosition < 0)
		{
		iPosition = 0;
		if(iPlayer != NULL)
			iPlayer->Start();
		}
	return iPosition < 0;
	}
	
void CEpocAudio::ThreadInitL(TAny* aDevice)
	{
	iTid = RThread().Id(); 
	CActiveScheduler* as =  new (ELeave) CActiveScheduler();
    CActiveScheduler::Install(as);
    
    EpocSdlEnv::AppendCleanupItem(TSdlCleanupItem((TSdlCleanupOperation)EPOC_CloseAudio, aDevice));
   
    iWait = CSimpleWait::NewL();
   
    iPlayer = new (ELeave) CStreamPlayer(*this, *this);
    iPlayer->ConstructL();	
    iPlayer->OpenStream(iRate, iChannels, iType);
    
    #ifdef DODUMP
    User::LeaveIfError(iDump.Open());
    #endif
	}
	
	
TUint8* CEpocAudio::Buffer()
	{
	iStart.UniversalTime();
//	iStart = iPlayer->Position();		
	return iAudioPtr;

	}
	
CEpocAudio::~CEpocAudio()
	{
	if(iWait != NULL)
		iWait->Cancel();
	delete iWait; 
	if(iPlayer != NULL)
		iPlayer->Close();
	delete iPlayer;
	delete iBuffer;
	}
	
void CEpocAudio::Complete(TInt aState, TInt aError)
	{
	if(aState == MStreamObs::EClose)
		{
		}
	if(iPlayer->Closed())
		return;
	switch(aError)
		{
		case KErrUnderflow:
		case KErrInUse:
			iPlayer->Start();
			break;
		case KErrAbort:
			iPlayer->Open();
		}
	}
	

void sos_adump(SDL_AudioDevice* thisdevice, void* data, int len)
	{
#ifdef DODUMP
	const TPtrC8 buf((TUint8*)data, len);
	CEpocAudio::Current(thisdevice).Dump(buf);
#endif
	}

const TInt KClip(256);
	
TPtrC8 CEpocAudio::Data()
	{
	if(iPosition < 0)
		return KNullDesC8();
	
	TPtrC8 data(iAudioPtr + iPosition, KClip);
	
#ifdef DODUMP
	iDump.Dump(data);
#endif
	
	iPosition += KClip;
	if(iPosition >= iBufferSize) 
		{
		
/*		if(iAudioPtr == iBuffer)
			iAudioPtr = iBuffer + iBufferSize;
		else
			iAudioPtr = iBuffer;
*/		
		iAudioPtr += iBufferSize;
		
		if((iAudioPtr - iBuffer) >= KAudioBuffers * iBufferSize)
			iAudioPtr = iBuffer;
		
		iPosition = -1;
		if(iWait->IsActive())
			{
			iWait->Cancel();
			CActiveScheduler::Stop();
			}
		}
	return data;
	}
		

void CEpocAudio::Play()
	{
	iPosition = 0;
	}

void CEpocAudio::Wait()
	{
	if(iPosition >= 0 /*&& iPlayer->Playing()*/)
		{
		const TInt64 bufMs = TInt64(iBufferSize - KClip) * TInt64(1000000);
		const TInt64 specTime =  bufMs / TInt64(iRate * iChannels * 2);
		iWait->After(specTime);
		
		CActiveScheduler::Start();
		TTime end;
		end.UniversalTime();
		const TTimeIntervalMicroSeconds delta = end.MicroSecondsFrom(iStart);
	
	
//		const TTimeIntervalMicroSeconds end = iPlayer->Position();
		
		
		const TInt diff = specTime - delta.Int64();
		
		if(diff > 0 && diff < 200000)
			{
			User::After(diff);
			}
		
		}
	else
		{
	User::After(10000); 
//	iWait->Wait(10000); //just give some time...	
		}	
	}
	
void CEpocAudio::Open(TInt aRate, TInt aChannels, TUint32 aType, TInt aBytes)	
	{
	iRate = aRate;
	iChannels = aChannels;
	iType = aType;
    iBufferRate = iRate * iChannels * aBytes; //1/x
	}
	

/* Audio driver bootstrap functions */

AudioBootStrap EPOCAudio_bootstrap = {
	"epoc\0\0\0",
	"EPOC streaming audio\0\0\0",
	Audio_Available,
	Audio_CreateDevice
};


static SDL_AudioDevice *Audio_CreateDevice(int /*devindex*/)
{
	SDL_AudioDevice *thisdevice;

	/* Initialize all variables that we clean on shutdown */
	thisdevice = (SDL_AudioDevice *)malloc(sizeof(SDL_AudioDevice));
	if ( thisdevice ) {
		memset(thisdevice, 0, (sizeof *thisdevice));
		thisdevice->hidden = NULL; /*(struct SDL_PrivateAudioData *)
			 malloc((sizeof thisdevice->hidden)); */
	}
	if ( (thisdevice == NULL) /*|| (thisdevice->hidden == NULL) */) {
		SDL_OutOfMemory();
		if ( thisdevice ) {
			free(thisdevice);
		}
		return(0);
	}
//	memset(thisdevice->hidden, 0, (sizeof *thisdevice->hidden));

	/* Set the function pointers */
	thisdevice->OpenAudio = EPOC_OpenAudio;
	thisdevice->WaitAudio = EPOC_WaitAudio;
	thisdevice->PlayAudio = EPOC_PlayAudio;
	thisdevice->GetAudioBuf = EPOC_GetAudioBuf;
	thisdevice->CloseAudio = EPOC_CloseAudio;
    thisdevice->ThreadInit = EPOC_ThreadInit;
	thisdevice->free = Audio_DeleteDevice;

	return thisdevice;
}


static void Audio_DeleteDevice(SDL_AudioDevice *device)
    {
	//free(device->hidden);
	free(device);
    }

static int Audio_Available(void)
{
	return(1); // Audio stream modules should be always there!
}


static int EPOC_OpenAudio(SDL_AudioDevice *thisdevice, SDL_AudioSpec *spec)
{
	SDL_TRACE("SDL:EPOC_OpenAudio");

	
	TUint32 type = KMMFFourCCCodePCM16;
	TInt bytes = 2;
	
	switch(spec->format)
		{
		case AUDIO_U16LSB: 
			type = KMMFFourCCCodePCMU16; 
			break;
		case AUDIO_S16LSB: 
			type = KMMFFourCCCodePCM16; 
			break;
		case AUDIO_U16MSB: 
			type = KMMFFourCCCodePCMU16B; 
			break;
		case AUDIO_S16MSB: 
			type = KMMFFourCCCodePCM16B; 
			break; 
			//8 bit not supported!
		case AUDIO_U8: 
		case AUDIO_S8:
		default:
			spec->format = AUDIO_S16LSB;
		};
	

	if(spec->channels > 2)
		spec->channels = 2;
	
	spec->freq = CStreamPlayer::ClosestSupportedRate(spec->freq);
	

	/* Allocate mixing buffer */
	const TInt buflen = spec->size;// * bytes * spec->channels;
//	audiobuf = NULL;
    
    TRAPD(err, thisdevice->hidden = static_cast<SDL_PrivateAudioData*>(CEpocAudio::NewL(buflen, spec->silence)));
    if(err != KErrNone)
        return -1;

	CEpocAudio::Current(thisdevice).Open(spec->freq, spec->channels, type, bytes);
	
	CEpocAudio::Current(thisdevice).SetPause(ETrue);
	
   // isSDLAudioPaused = 1;

    thisdevice->enabled = 0; /* enable only after audio engine has been initialized!*/

	/* We're ready to rock and roll. :-) */
	return(0);
}


static void EPOC_CloseAudio(SDL_AudioDevice* thisdevice)
    {
#ifdef DEBUG_AUDIO
    SDL_TRACE("Close audio\n");
#endif

	CEpocAudio::Free(thisdevice);
	}


static void EPOC_ThreadInit(SDL_AudioDevice *thisdevice)
    {
	SDL_TRACE("SDL:EPOC_ThreadInit");
    CEpocAudio::Current(thisdevice).ThreadInitL(thisdevice);
    RThread().SetPriority(EPriorityMore);
    thisdevice->enabled = 1;
    }

/* This function waits until it is possible to write a full sound buffer */
static void EPOC_WaitAudio(SDL_AudioDevice* thisdevice)
{
#ifdef DEBUG_AUDIO
    SDL_TRACE1("wait %d audio\n", CEpocAudio::AudioLib().StreamPlayer(KSfxChannel).SyncTime());
    TInt tics = User::TickCount();
#endif

	CEpocAudio::Current(thisdevice).Wait();

#ifdef DEBUG_AUDIO
    TInt ntics =  User::TickCount() - tics;
    SDL_TRACE1("audio waited %d\n", ntics);
    SDL_TRACE1("audio at %d\n", tics);
#endif
}


static void EPOC_PlayAudio(SDL_AudioDevice* thisdevice)
	{
 	if(CEpocAudio::Current(thisdevice).SetPause(SDL_GetAudioStatus() == SDL_AUDIO_PAUSED))
 		SDL_Delay(500); //hold on the busy loop
 	else
 		CEpocAudio::Current(thisdevice).Play();

#ifdef DEBUG_AUDIO
    SDL_TRACE("buffer has audio data\n");
#endif

	
#ifdef DEBUG_AUDIO
	SDL_TRACE1("Wrote %d bytes of audio data\n", buflen);
#endif
}

static Uint8 *EPOC_GetAudioBuf(SDL_AudioDevice* thisdevice)
	{
	return CEpocAudio::Current(thisdevice).Buffer();
	}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Library General Public
	7	License as published by the Free Software Foundation; either
	8	version 2 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Library General Public License for more details.
	14
	15	You should have received a copy of the GNU Library General Public
	16	License along with this library; if not, write to the Free
	17	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18
	19	Sam Lantinga
	20	slouken@devolution.com
	21	*/
	22
	23	/*
	24	SDL_epocaudio.cpp
	25	Epoc based SDL audio driver implementation
	26
	27	Markus Mertama
	28	*/
	29
	30	#ifdef SAVE_RCSID
	31	static char rcsid =
	32	"@(#) $Id: SDL_epocaudio.c,v 0.0.0.0 2001/06/19 17:19:56 hercules Exp $";
	33	#endif
	34
	35
	36	#include <stdlib.h>
	37	#include <stdio.h>
	38	#include <string.h>
	39	#include <errno.h>
	40	#include <unistd.h>
	41	#include <fcntl.h>
	42	#include <signal.h>
	43	#include <sys/time.h>
	44	#include <sys/ioctl.h>
	45	#include <sys/stat.h>
	46
	47	#include "epoc_sdl.h"
	48
	49	#include <e32hal.h>
	50
	51
	52	extern "C" {
	53	#include "SDL_audio.h"
	54	#include "SDL_error.h"
	55	#include "SDL_audiomem.h"
	56	#include "SDL_audio_c.h"
	57	#include "SDL_timer.h"
	58	#include "SDL_audiodev_c.h"
	59	}
	60
	61	#include "SDL_epocaudio.h"
	62
	63	#include "streamplayer.h"
	64
65
66	//#define DEBUG_AUDIO
67
68
69	/* Audio driver functions */
70
71	static int EPOC_OpenAudio(SDL_AudioDevice thisdevice, SDL_AudioSpec spec);
72	static void EPOC_WaitAudio(SDL_AudioDevice *thisdevice);
73	static void EPOC_PlayAudio(SDL_AudioDevice *thisdevice);
74	static Uint8 EPOC_GetAudioBuf(SDL_AudioDevice thisdevice);
75	static void EPOC_CloseAudio(SDL_AudioDevice *thisdevice);
76	static void EPOC_ThreadInit(SDL_AudioDevice *thisdevice);
77
78	static int Audio_Available(void);
79	static SDL_AudioDevice *Audio_CreateDevice(int devindex);
80	static void Audio_DeleteDevice(SDL_AudioDevice *device);
81
82
83	//void sos_adump(SDL_AudioDevice* thisdevice, void* data, int len);
84
85	#ifdef __WINS__
86	#define DODUMP
87	#endif
88
89	#ifdef DODUMP
90	NONSHARABLE_CLASS(TDump)
91	{
92	public:
93	TInt Open();
94	void Close();
95	void Dump(const TDesC8& aDes);
96	private:
97	RFile iFile;
98	RFs iFs;
99	};
100
101	TInt TDump::Open()
102	{
103	TInt err = iFs.Connect();
104	if(err == KErrNone)
105	{
106	#ifdef __WINS__
107	_LIT(target, "C:\\sdlau.raw");
108	#else
109	_LIT(target, "E:\\sdlau.raw");
110	#endif
111	err = iFile.Replace(iFs, target, EFileWrite);
112	}
113	return err;
114	}
115	void TDump::Close()
116	{
117	iFile.Close();
118	iFs.Close();
119	}
120	void TDump::Dump(const TDesC8& aDes)
121	{
122	iFile.Write(aDes);
123	}
124	#endif
125
126
127	NONSHARABLE_CLASS(CSimpleWait) : public CTimer
128	{
129	public:
130	void Wait(TTimeIntervalMicroSeconds32 aWait);
131	static CSimpleWait* NewL();
132	private:
133	CSimpleWait();
134	void RunL();
135	};
136
137
138	CSimpleWait* CSimpleWait::NewL()
139	{
140	CSimpleWait* wait = new (ELeave) CSimpleWait();
141	CleanupStack::PushL(wait);
142	wait->ConstructL();
143	CleanupStack::Pop();
144	return wait;
145	}
146
147	void CSimpleWait::Wait(TTimeIntervalMicroSeconds32 aWait)
148	{
149	After(aWait);
150	CActiveScheduler::Start();
151	}
152
153	CSimpleWait::CSimpleWait() : CTimer(CActive::EPriorityStandard)
154	{
155	CActiveScheduler::Add(this);
156	}
157
158	void CSimpleWait::RunL()
159	{
160	CActiveScheduler::Stop();
161	}
162
163	const TInt KAudioBuffers(2);
164
165
166	NONSHARABLE_CLASS(CEpocAudio) : public CBase, public MStreamObs, public MStreamProvider
167	{
168	public:
169	static void* NewL(TInt BufferSize, TInt aFill);
170	inline static CEpocAudio& Current(SDL_AudioDevice* thisdevice);
171
172	static void Free(SDL_AudioDevice* thisdevice);
173
174	void Wait();
175	void Play();
176	// void SetBuffer(const TDesC8& aBuffer);
177	void ThreadInitL(TAny* aDevice);
178	void Open(TInt iRate, TInt iChannels, TUint32 aType, TInt aBytes);
179	~CEpocAudio();
180	TUint8* Buffer();
181	TBool SetPause(TBool aPause);
182	#ifdef DODUMP
183	void Dump(const TDesC8& aBuf) {iDump.Dump(aBuf);}
184	#endif
185	private:
186	CEpocAudio(TInt aBufferSize);
187	void Complete(TInt aState, TInt aError);
188	TPtrC8 Data();
189	void ConstructL(TInt aFill);
190	private:
191	TInt iBufferSize;
192	CStreamPlayer* iPlayer;
193	TInt iBufferRate;
194	TInt iRate;
195	TInt iChannels;
196	TUint32 iType;
197	TInt iPosition;
198	TThreadId iTid;
199	TUint8* iAudioPtr;
200	TUint8* iBuffer;
201	// TTimeIntervalMicroSeconds iStart;
202	TTime iStart;
203	TInt iTune;
204	CSimpleWait* iWait;
205	#ifdef DODUMP
206	TDump iDump;
207	#endif
208	};
209
210	inline CEpocAudio& CEpocAudio::Current(SDL_AudioDevice* thisdevice)
211	{
212	return static_cast<CEpocAudio>((void*)thisdevice->hidden);
213	}
214
215	/*
216
217	TBool EndSc(TAny*)
218	{
219	CActiveScheduler::Stop();
220	}
221
222	LOCAL_C void CleanScL()
223	{
224	CIdle* d = CIdle::NewLC(CActive:::EPriorityIdle);
225	d->Start(TCallBack(EndSc));
226	CActiveScheduler::Start();
227
228	}
229	*/
230
231	void CEpocAudio::Free(SDL_AudioDevice* thisdevice)
232	{
233	CEpocAudio* ea = static_cast<CEpocAudio>((void)thisdevice->hidden);
234	if(ea)
235	{
236	ASSERT(ea->iTid == RThread().Id());
237	delete ea;
238	thisdevice->hidden = NULL;
239
240	CActiveScheduler* as = CActiveScheduler::Current();
241	ASSERT(as->StackDepth() == 0);
242	delete as;
243	CActiveScheduler::Install(NULL);
244	}
245	ASSERT(thisdevice->hidden == NULL);
246	}
247
248	CEpocAudio::CEpocAudio(TInt aBufferSize) : iBufferSize(aBufferSize), iPosition(-1)
249	{
250	}
251
252	void* CEpocAudio::NewL(TInt aBufferSize, TInt aFill)
253	{
254	CEpocAudio* eAudioLib = new (ELeave) CEpocAudio(aBufferSize);
255	CleanupStack::PushL(eAudioLib);
256	eAudioLib->ConstructL(aFill);
257	CleanupStack::Pop();
258	return eAudioLib;
259	}
260
261	void CEpocAudio::ConstructL(TInt aFill)
262	{
263	iBuffer = (TUint8) User::AllocL(KAudioBuffers iBufferSize);
264	memset(iBuffer, aFill, KAudioBuffers * iBufferSize);
265	iAudioPtr = iBuffer;
266	}
267
268
269	TBool CEpocAudio::SetPause(TBool aPause)
270	{
271	if(aPause && iPosition >= 0)
272	{
273	iPosition = -1;
274	if(iPlayer != NULL)
275	iPlayer->Stop();
276	}
277	if(!aPause && iPosition < 0)
278	{
279	iPosition = 0;
280	if(iPlayer != NULL)
281	iPlayer->Start();
282	}
283	return iPosition < 0;
284	}
285
286	void CEpocAudio::ThreadInitL(TAny* aDevice)
287	{
288	iTid = RThread().Id();
289	CActiveScheduler* as = new (ELeave) CActiveScheduler();
290	CActiveScheduler::Install(as);
291
292	EpocSdlEnv::AppendCleanupItem(TSdlCleanupItem((TSdlCleanupOperation)EPOC_CloseAudio, aDevice));
293
294	iWait = CSimpleWait::NewL();
295
296	iPlayer = new (ELeave) CStreamPlayer(this, this);
297	iPlayer->ConstructL();
298	iPlayer->OpenStream(iRate, iChannels, iType);
299
300	#ifdef DODUMP
301	User::LeaveIfError(iDump.Open());
302	#endif
303	}
304
305
306
307	TUint8* CEpocAudio::Buffer()
308	{
309	iStart.UniversalTime();
310	// iStart = iPlayer->Position();
311	return iAudioPtr;
312
313	}
314
315	CEpocAudio::~CEpocAudio()
316	{
317	if(iWait != NULL)
318	iWait->Cancel();
319	delete iWait;
320	if(iPlayer != NULL)
321	iPlayer->Close();
322	delete iPlayer;
323	delete iBuffer;
324	}
325
326	void CEpocAudio::Complete(TInt aState, TInt aError)
327	{
328	if(aState == MStreamObs::EClose)
329	{
330	}
331	if(iPlayer->Closed())
332	return;
333	switch(aError)
334	{
335	case KErrUnderflow:
336	case KErrInUse:
337	iPlayer->Start();
338	break;
339	case KErrAbort:
340	iPlayer->Open();
341	}
342	}
343
344
345	void sos_adump(SDL_AudioDevice* thisdevice, void* data, int len)
346	{
347	#ifdef DODUMP
348	const TPtrC8 buf((TUint8*)data, len);
349	CEpocAudio::Current(thisdevice).Dump(buf);
350	#endif
351	}
352
353	const TInt KClip(256);
354
355	TPtrC8 CEpocAudio::Data()
356	{
357	if(iPosition < 0)
358	return KNullDesC8();
359
360	TPtrC8 data(iAudioPtr + iPosition, KClip);
361
362	#ifdef DODUMP
363	iDump.Dump(data);
364	#endif
365
366	iPosition += KClip;
367	if(iPosition >= iBufferSize)
368	{
369
370	/* if(iAudioPtr == iBuffer)
371	iAudioPtr = iBuffer + iBufferSize;
372	else
373	iAudioPtr = iBuffer;
374	*/
375	iAudioPtr += iBufferSize;
376
377	if((iAudioPtr - iBuffer) >= KAudioBuffers * iBufferSize)
378	iAudioPtr = iBuffer;
379
380	iPosition = -1;
381	if(iWait->IsActive())
382	{
383	iWait->Cancel();
384	CActiveScheduler::Stop();
385	}
386	}
387	return data;
388	}
389
390
391
392
393	void CEpocAudio::Play()
394	{
395	iPosition = 0;
396	}
397
398	void CEpocAudio::Wait()
399	{
400	if(iPosition >= 0 /&& iPlayer->Playing()/)
401	{
402	const TInt64 bufMs = TInt64(iBufferSize - KClip) * TInt64(1000000);
403	const TInt64 specTime = bufMs / TInt64(iRate * iChannels * 2);
404	iWait->After(specTime);
405
406	CActiveScheduler::Start();
407	TTime end;
408	end.UniversalTime();
409	const TTimeIntervalMicroSeconds delta = end.MicroSecondsFrom(iStart);
410
411
412	// const TTimeIntervalMicroSeconds end = iPlayer->Position();
413
414
415
416
417	const TInt diff = specTime - delta.Int64();
418
419	if(diff > 0 && diff < 200000)
420	{
421	User::After(diff);
422	}
423
424	}
425	else
426	{
427	User::After(10000);
428	// iWait->Wait(10000); //just give some time...
429	}
430	}
431
432	void CEpocAudio::Open(TInt aRate, TInt aChannels, TUint32 aType, TInt aBytes)
433	{
434	iRate = aRate;
435	iChannels = aChannels;
436	iType = aType;
437	iBufferRate = iRate * iChannels * aBytes; //1/x
438	}
439
440
441	/* Audio driver bootstrap functions */
442
443	AudioBootStrap EPOCAudio_bootstrap = {
444	"epoc\0\0\0",
445	"EPOC streaming audio\0\0\0",
446	Audio_Available,
447	Audio_CreateDevice
448	};
449
450
451	static SDL_AudioDevice Audio_CreateDevice(int /devindex*/)
452	{
453	SDL_AudioDevice *thisdevice;
454
455	/* Initialize all variables that we clean on shutdown */
456	thisdevice = (SDL_AudioDevice *)malloc(sizeof(SDL_AudioDevice));
457	if ( thisdevice ) {
458	memset(thisdevice, 0, (sizeof *thisdevice));
459	thisdevice->hidden = NULL; /(struct SDL_PrivateAudioData )
460	malloc((sizeof thisdevice->hidden)); */
461	}
462	if ( (thisdevice == NULL) /\|\| (thisdevice->hidden == NULL) /) {
463	SDL_OutOfMemory();
464	if ( thisdevice ) {
465	free(thisdevice);
466	}
467	return(0);
468	}
469	// memset(thisdevice->hidden, 0, (sizeof *thisdevice->hidden));
470
471	/* Set the function pointers */
472	thisdevice->OpenAudio = EPOC_OpenAudio;
473	thisdevice->WaitAudio = EPOC_WaitAudio;
474	thisdevice->PlayAudio = EPOC_PlayAudio;
475	thisdevice->GetAudioBuf = EPOC_GetAudioBuf;
476	thisdevice->CloseAudio = EPOC_CloseAudio;
477	thisdevice->ThreadInit = EPOC_ThreadInit;
478	thisdevice->free = Audio_DeleteDevice;
479
480	return thisdevice;
481	}
482
483
484	static void Audio_DeleteDevice(SDL_AudioDevice *device)
485	{
486	//free(device->hidden);
487	free(device);
488	}
489
490	static int Audio_Available(void)
491	{
492	return(1); // Audio stream modules should be always there!
493	}
494
495
496	static int EPOC_OpenAudio(SDL_AudioDevice thisdevice, SDL_AudioSpec spec)
497	{
498	SDL_TRACE("SDL:EPOC_OpenAudio");
499
500
501	TUint32 type = KMMFFourCCCodePCM16;
502	TInt bytes = 2;
503
504	switch(spec->format)
505	{
506	case AUDIO_U16LSB:
507	type = KMMFFourCCCodePCMU16;
508	break;
509	case AUDIO_S16LSB:
510	type = KMMFFourCCCodePCM16;
511	break;
512	case AUDIO_U16MSB:
513	type = KMMFFourCCCodePCMU16B;
514	break;
515	case AUDIO_S16MSB:
516	type = KMMFFourCCCodePCM16B;
517	break;
518	//8 bit not supported!
519	case AUDIO_U8:
520	case AUDIO_S8:
521	default:
522	spec->format = AUDIO_S16LSB;
523	};
524
525
526
527	if(spec->channels > 2)
528	spec->channels = 2;
529
530	spec->freq = CStreamPlayer::ClosestSupportedRate(spec->freq);
531
532
533	/* Allocate mixing buffer */
534	const TInt buflen = spec->size;// * bytes * spec->channels;
535	// audiobuf = NULL;
536
537	TRAPD(err, thisdevice->hidden = static_cast<SDL_PrivateAudioData*>(CEpocAudio::NewL(buflen, spec->silence)));
538	if(err != KErrNone)
539	return -1;
540
541	CEpocAudio::Current(thisdevice).Open(spec->freq, spec->channels, type, bytes);
542
543	CEpocAudio::Current(thisdevice).SetPause(ETrue);
544
545	// isSDLAudioPaused = 1;
546
547	thisdevice->enabled = 0; /* enable only after audio engine has been initialized!*/
548
549	/* We're ready to rock and roll. :-) */
550	return(0);
551	}
552
553
554	static void EPOC_CloseAudio(SDL_AudioDevice* thisdevice)
555	{
556	#ifdef DEBUG_AUDIO
557	SDL_TRACE("Close audio\n");
558	#endif
559
560	CEpocAudio::Free(thisdevice);
561	}
562
563
564	static void EPOC_ThreadInit(SDL_AudioDevice *thisdevice)
565	{
566	SDL_TRACE("SDL:EPOC_ThreadInit");
567	CEpocAudio::Current(thisdevice).ThreadInitL(thisdevice);
568	RThread().SetPriority(EPriorityMore);
569	thisdevice->enabled = 1;
570	}
571
572	/* This function waits until it is possible to write a full sound buffer */
573	static void EPOC_WaitAudio(SDL_AudioDevice* thisdevice)
574	{
575	#ifdef DEBUG_AUDIO
576	SDL_TRACE1("wait %d audio\n", CEpocAudio::AudioLib().StreamPlayer(KSfxChannel).SyncTime());
577	TInt tics = User::TickCount();
578	#endif
579
580	CEpocAudio::Current(thisdevice).Wait();
581
582	#ifdef DEBUG_AUDIO
583	TInt ntics = User::TickCount() - tics;
584	SDL_TRACE1("audio waited %d\n", ntics);
585	SDL_TRACE1("audio at %d\n", tics);
586	#endif
587	}
588
589
590
591	static void EPOC_PlayAudio(SDL_AudioDevice* thisdevice)
592	{
593	if(CEpocAudio::Current(thisdevice).SetPause(SDL_GetAudioStatus() == SDL_AUDIO_PAUSED))
594	SDL_Delay(500); //hold on the busy loop
595	else
596	CEpocAudio::Current(thisdevice).Play();
597
598	#ifdef DEBUG_AUDIO
599	SDL_TRACE("buffer has audio data\n");
600	#endif
601
602
603	#ifdef DEBUG_AUDIO
604	SDL_TRACE1("Wrote %d bytes of audio data\n", buflen);
605	#endif
606	}
607
608	static Uint8 EPOC_GetAudioBuf(SDL_AudioDevice thisdevice)
609	{
610	return CEpocAudio::Current(thisdevice).Buffer();
611	}
612
613
614