/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 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

    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public

    License along with this library; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

/* Allow access to a raw mixing buffer */

#include <nds.h>

#include "SDL.h"

#include "SDL_endian.h"

#include "SDL_timer.h"

#include "SDL_audio.h"

#include "../SDL_audiomem.h"

#include "../SDL_audio_c.h"

#include "SDL_ndsaudio.h"

#include "soundcommon.h"

/* Audio driver functions */

static int NDS_OpenAudio(_THIS, SDL_AudioSpec *spec);

static void NDS_WaitAudio(_THIS);

static void NDS_PlayAudio(_THIS);

static Uint8 *NDS_GetAudioBuf(_THIS);

static void NDS_CloseAudio(_THIS);

/* Audio driver bootstrap functions */

u32 framecounter = 0,soundoffset = 0;

static SDL_AudioDevice *sdl_nds_audiodevice; 

//void SoundMixCallback(void *stream,u32 size)

//{

//	//printf("SoundMixCallback\n");

//	

//	Uint8 *buffer;

//	 

// 	buffer = sdl_nds_audiodevice->hidden->mixbuf;

//	memset(buffer, sdl_nds_audiodevice->spec.silence, size);

//	

//	if (!sdl_nds_audiodevice->paused){ 

//		 

//

//	//if (sdl_nds_audiodevice->convert.needed) {

//	//	int silence;

//

//	//	if (sdl_nds_audiodevice->convert.src_format == AUDIO_U8 ) { 

//	//		silence = 0x80;

//	//	} else {

//	//		silence =  0; 

//	//	}

//	//	memset(sdl_nds_audiodevice->convert.buf, silence, sdl_nds_audiodevice->convert.len);

//	//	sdl_nds_audiodevice->spec.callback(sdl_nds_audiodevice->spec.userdata,

//	//		(Uint8 *)sdl_nds_audiodevice->convert.buf,sdl_nds_audiodevice->convert.len);

//	//	SDL_ConvertAudio(&sdl_nds_audiodevice->convert);

//	//	memcpy(buffer, sdl_nds_audiodevice->convert.buf, sdl_nds_audiodevice->convert.len_cvt);

//	//} else 

//	{

//		sdl_nds_audiodevice->spec.callback(sdl_nds_audiodevice->spec.userdata, buffer, size);

//		//memcpy((Sint16 *)stream,buffer, size);

//	}

//

//	}

//

//	if(soundsystem->format == 8)

//	{

//		int i;

//		s32 *buffer32 = (s32 *)buffer; 

//		s32 *stream32 = (s32 *)stream;

//		for(i=0;i<size/4;i++){ *stream32++ = buffer32[i] ^ 0x80808080;}

//		//for(i = 0; i < size; i++)

//		//	((s8*)stream)[i]=(buffer[i]^0x80);

//	}

//	else

//	{

//		int i;

//		for(i = 0; i < size; i++){

//			//((short*)stream)[i] =(short)buffer[i] << 8;				// sound 8bit ---> buffer 16bit

//			//if (buffer[i] &0x80)

//				//((Sint16*)stream)[i] = 0xff00 | buffer[i];

//			((Sint16*)stream)[i] = (buffer[i] - 128) << 8;

//

//			//else

//			//	((Sint16*)stream)[i] = buffer[i];

//		}

//		//register signed char *pSrc =buffer;

//		//register short *pDest =stream;

//		//int x;

//		//			for (x=size; x>0; x--)

//		//			{

//		//				register short temp = (((short)*pSrc)-128)<<8;

//		//				pSrc++;

//		//				*pDest++ = temp;

//		//			}

//

//		//memcpy((Sint16 *)stream,buffer, size);

//	}

//}

void SoundMixCallback(void *stream,u32 len)

{

	SDL_AudioDevice *audio = (SDL_AudioDevice *)sdl_nds_audiodevice;

	/* Silence the buffer, since it's ours */

	SDL_memset(stream, audio->spec.silence, len);

	/* Only do soemthing if audio is enabled */

	if ( ! audio->enabled )

		return;

	if ( ! audio->paused ) {

		if ( audio->convert.needed ) {

			//fprintf(stderr,"converting audio\n");

			SDL_mutexP(audio->mixer_lock);

			(*audio->spec.callback)(audio->spec.userdata,

				(Uint8 *)audio->convert.buf,audio->convert.len);

			SDL_mutexV(audio->mixer_lock);

			SDL_ConvertAudio(&audio->convert);

			SDL_memcpy(stream,audio->convert.buf,audio->convert.len_cvt);

		} else {

			SDL_mutexP(audio->mixer_lock);

			(*audio->spec.callback)(audio->spec.userdata,

						(Uint8 *)stream, len);

			SDL_mutexV(audio->mixer_lock);

		}

	}

	return;

}

void MixSound(void)

{

	int remain;

	if(soundsystem->format == 8)

	{

		if((soundsystem->soundcursor + soundsystem->numsamples) > soundsystem->buffersize)

		{

			SoundMixCallback(&soundsystem->mixbuffer[soundsystem->soundcursor],soundsystem->buffersize - soundsystem->soundcursor);

			remain = soundsystem->numsamples - (soundsystem->buffersize - soundsystem->soundcursor);

			SoundMixCallback(soundsystem->mixbuffer,remain);

		}

		else

		{

			SoundMixCallback(&soundsystem->mixbuffer[soundsystem->soundcursor],soundsystem->numsamples);

		}

	}

	else

	{

		if((soundsystem->soundcursor + soundsystem->numsamples) > (soundsystem->buffersize >> 1))

		{

			SoundMixCallback(&soundsystem->mixbuffer[soundsystem->soundcursor << 1],(soundsystem->buffersize >> 1) - soundsystem->soundcursor);

			remain = soundsystem->numsamples - ((soundsystem->buffersize >> 1) - soundsystem->soundcursor);

			SoundMixCallback(soundsystem->mixbuffer,remain);

		}

		else

		{

			SoundMixCallback(&soundsystem->mixbuffer[soundsystem->soundcursor << 1],soundsystem->numsamples);

		}

	}

}

void InterruptHandler(void)

{

	framecounter++;

}

void FiFoHandler(void)

{

	u32 command;

	while ( !(REG_IPC_FIFO_CR & (IPC_FIFO_RECV_EMPTY)) ) 

	{

		command = REG_IPC_FIFO_RX;

		switch(command)

		{

		case FIFO_NONE:

			break;

		case UPDATEON_ARM9:

			REG_IME = 0;

			MixSound();

			REG_IME = 1;

			SendCommandToArm7(MIXCOMPLETE_ONARM9);

			break;

		}

	}

}

static int Audio_Available(void)

{

	return(1);

}

static void Audio_DeleteDevice(SDL_AudioDevice *device)

{

}

static SDL_AudioDevice *Audio_CreateDevice(int devindex)

{

	SDL_AudioDevice *this;

	/* Initialize all variables that we clean on shutdown */

	this = (SDL_AudioDevice *)malloc(sizeof(SDL_AudioDevice));

	if ( this ) {

		SDL_memset(this, 0, (sizeof *this));

		this->hidden = (struct SDL_PrivateAudioData *)

				SDL_malloc((sizeof *this->hidden));

	}

	if ( (this == NULL) || (this->hidden == NULL) ) {

		SDL_OutOfMemory();

		if ( this ) {

			SDL_free(this);

		}

		return(0);

	}

	SDL_memset(this->hidden, 0, (sizeof *this->hidden));

	/* Set the function pointers */

	this->OpenAudio = NDS_OpenAudio;

	this->WaitAudio = NDS_WaitAudio;

	this->PlayAudio = NDS_PlayAudio;

	this->GetAudioBuf = NDS_GetAudioBuf;

	this->CloseAudio = NDS_CloseAudio;

	this->free = Audio_DeleteDevice;

//fprintf(stderr,"Audio_CreateDevice\n");

	return this;

}

AudioBootStrap NDSAUD_bootstrap = {

	"nds", "NDS audio",

	Audio_Available, Audio_CreateDevice

};

void static NDS_WaitAudio(_THIS)

{

	//printf("NDS_WaitAudio\n");

}

static void NDS_PlayAudio(_THIS)

{

	//printf("playing audio\n");

	if (this->paused)

		return;

}

static Uint8 *NDS_GetAudioBuf(_THIS)

{

	return NULL;//(this->hidden->mixbuf); 

}

static void NDS_CloseAudio(_THIS)

{

/*	if ( this->hidden->mixbuf != NULL ) {

		SDL_FreeAudioMem(this->hidden->mixbuf);

		this->hidden->mixbuf = NULL;

	}*/ 

}

static int NDS_OpenAudio(_THIS, SDL_AudioSpec *spec)

{

	//printf("NDS_OpenAudio\n");

	int format = 0;

	//switch(spec->format&0xff) {

	//case  8: spec->format = AUDIO_S8;format=8; break;

	//case 16: spec->format = AUDIO_S16LSB;format=16; break;

	//default:

	//	SDL_SetError("Unsupported audio format");

	//	return(-1);

	//}

	switch (spec->format&~0x1000) {

		case AUDIO_S8:

			/* Signed 8-bit audio supported */

			format=8;

			break;

		case AUDIO_U8:

			spec->format ^= 0x80;format=8;

			break;

		case AUDIO_U16:

			/* Unsigned 16-bit audio unsupported, convert to S16 */

			spec->format ^=0x8000;format=16;

		case AUDIO_S16:

			/* Signed 16-bit audio supported */

			format=16;

			break;

	}

	/* Update the fragment size as size in bytes */

	SDL_CalculateAudioSpec(spec);

	/* Allocate mixing buffer */

	//this->hidden->mixlen = spec->size;

	//this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);

	//if ( this->hidden->mixbuf == NULL ) {

	//	SDL_SetError("Out of Memory");

	//	return(-1);

	//} 

	SDL_NDSAudio_mutex = 0; 

	sdl_nds_audiodevice=this;

	irqInit();

	irqSet(IRQ_VBLANK,&InterruptHandler);

	irqSet(IRQ_FIFO_NOT_EMPTY,&FiFoHandler);

	irqEnable(IRQ_FIFO_NOT_EMPTY);

	REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_SEND_CLEAR | IPC_FIFO_RECV_IRQ;

	SoundSystemInit(spec->freq,spec->size,0,format);

	SoundStartMixer();

	return(1);

}