/*
   XMMS-SID - SIDPlay input plugin for X MultiMedia System (XMMS)

   libSIDPlay v1 support

   Programmed and designed by Matti 'ccr' Hamalainen <ccr@tnsp.org>
   (C) Copyright 1999-2005 Tecnic Software productions (TNSP)

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

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "xmms-sid.h"

#ifdef HAVE_SIDPLAY1

#include "xs_sidplay1.h"
#include <stdio.h>
#include "xs_config.h"
#include "xs_length.h"
#include "xs_title.h"

#include <sidplay/player.h>
#include <sidplay/myendian.h>
#include <sidplay/fformat.h>

/* Maximum audio frequency supported by libSIDPlay v1 */
#define SIDPLAY1_MAX_FREQ	(48000)

typedef struct
{
	emuEngine *currEng;
	emuConfig currConfig;
	sidTune *currTune;
} t_xs_sidplay1;


/* We need to 'export' all this pseudo-C++ crap */
extern "C"
{


/* Check if we can play the given file
 */
	gboolean xs_sidplay1_isourfile(gchar * pcFilename)
	{
		sidTune *testTune = new sidTune(pcFilename);

		if (!testTune)
			 return FALSE;
		if (!testTune->getStatus())
		{
			delete testTune;
			 return FALSE;
		}

		delete testTune;
		return TRUE;
	}


/* Initialize SIDPlay1
 */
	gboolean xs_sidplay1_init(t_xs_status * myStatus)
	{
		gint tmpFreq;
		t_xs_sidplay1 *myEngine;
		assert(myStatus);

		/* Allocate internal structures */
		myEngine = (t_xs_sidplay1 *) g_malloc0(sizeof(t_xs_sidplay1));
		if (!myEngine)
			return FALSE;

		/* Initialize engine */
		myEngine->currEng = new emuEngine();
		if (!myEngine->currEng) {
			XSERR("Could not initialize libSIDPlay1 emulation engine\n");
			g_free(myEngine);
			return FALSE;
		}

		/* Verify endianess */
		if (!myEngine->currEng->verifyEndianess()) {
			XSERR("Endianess verification failed\n");
			delete myEngine->currEng;
			g_free(myEngine);
			return FALSE;
		}

		myStatus->sidEngine = myEngine;

		/* Get current configuration */
		myEngine->currEng->getConfig(myEngine->currConfig);

		/* Configure channel parameters */
		switch (myStatus->audioChannels) {

		case XS_CHN_AUTOPAN:
			myEngine->currConfig.channels = SIDEMU_STEREO;
			myEngine->currConfig.autoPanning = SIDEMU_CENTEREDAUTOPANNING;
			myEngine->currConfig.volumeControl = SIDEMU_FULLPANNING;
			break;

		case XS_CHN_STEREO:
			myEngine->currConfig.channels = SIDEMU_STEREO;
			myEngine->currConfig.autoPanning = SIDEMU_NONE;
			myEngine->currConfig.volumeControl = SIDEMU_NONE;
			break;

		case XS_CHN_MONO:
		default:
			myEngine->currConfig.channels = SIDEMU_MONO;
			myEngine->currConfig.autoPanning = SIDEMU_NONE;
			myEngine->currConfig.volumeControl = SIDEMU_NONE;
			myStatus->audioChannels = XS_CHN_MONO;
			break;
		}


		/* Memory mode settings */
		switch (xs_cfg.memoryMode) {
		case XS_MPU_TRANSPARENT_ROM:
			myEngine->currConfig.memoryMode = MPU_TRANSPARENT_ROM;
			break;

		case XS_MPU_PLAYSID_ENVIRONMENT:
			myEngine->currConfig.memoryMode = MPU_PLAYSID_ENVIRONMENT;
			break;

		case XS_MPU_BANK_SWITCHING:
		default:
			myEngine->currConfig.memoryMode = MPU_BANK_SWITCHING;
			xs_cfg.memoryMode = XS_MPU_BANK_SWITCHING;
			break;
		}


		/* Clockspeed settings */
		switch (xs_cfg.clockSpeed) {
		case XS_CLOCK_NTSC:
			myEngine->currConfig.clockSpeed = SIDTUNE_CLOCK_NTSC;
			break;

		case XS_CLOCK_PAL:
		default:
			myEngine->currConfig.clockSpeed = SIDTUNE_CLOCK_PAL;
			xs_cfg.clockSpeed = XS_CLOCK_PAL;
			break;
		}


		/* Configure rest of the emulation */
		myEngine->currConfig.mos8580 = xs_cfg.mos8580;
		myEngine->currConfig.emulateFilter = xs_cfg.emulateFilters;
		myEngine->currConfig.filterFs = xs_cfg.filterFs;
		myEngine->currConfig.filterFm = xs_cfg.filterFm;
		myEngine->currConfig.filterFt = xs_cfg.filterFt;


		/* Audio parameters sanity checking and setup */
		myEngine->currConfig.bitsPerSample = myStatus->audioBitsPerSample;
		tmpFreq = myStatus->audioFrequency;

		if (myStatus->oversampleEnable) {
			if ((tmpFreq * myStatus->oversampleFactor) > SIDPLAY1_MAX_FREQ) {
				myStatus->oversampleEnable = FALSE;
			} else {
				tmpFreq = (tmpFreq * myStatus->oversampleFactor);
			}
		} else {
			if (tmpFreq > SIDPLAY1_MAX_FREQ)
				tmpFreq = SIDPLAY1_MAX_FREQ;
		}

		myEngine->currConfig.frequency = tmpFreq;

		switch (myStatus->audioBitsPerSample) {
		case XS_RES_8BIT:
			switch (myStatus->audioFormat) {
			case FMT_S8:
				myStatus->audioFormat = FMT_S8;
				myEngine->currConfig.sampleFormat = SIDEMU_SIGNED_PCM;
				break;

			case FMT_U8:
			default:
				myStatus->audioFormat = FMT_U8;
				myEngine->currConfig.sampleFormat = SIDEMU_UNSIGNED_PCM;
				break;
			}
			break;

		case XS_RES_16BIT:
		default:
			switch (myStatus->audioFormat) {
			case FMT_U16_NE:
			case FMT_U16_LE:
			case FMT_U16_BE:
				myStatus->audioFormat = FMT_U16_NE;
				myEngine->currConfig.sampleFormat = SIDEMU_UNSIGNED_PCM;
				break;

			case FMT_S16_NE:
			case FMT_S16_LE:
			case FMT_S16_BE:
			default:
				myStatus->audioFormat = FMT_S16_NE;
				myEngine->currConfig.sampleFormat = SIDEMU_SIGNED_PCM;
				break;
			}
			break;
		}

		/* Now set the emulator configuration */
		if (!myEngine->currEng->setConfig(myEngine->currConfig)) {
			XSERR("Emulator engine configuration failed!\n");
			return FALSE;
		}

		return TRUE;
	}


/* Close SIDPlay1 engine
 */
	void xs_sidplay1_close(t_xs_status * myStatus)
	{
		t_xs_sidplay1 *myEngine;
		assert(myStatus);

		myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;

		/* Free internals */
		if (myEngine->currEng) {
			delete myEngine->currEng;
			myEngine->currEng = NULL;
		}

		g_free(myEngine);
		myStatus->sidEngine = NULL;
	}


/* Initialize current song and sub-tune
 */
	gboolean xs_sidplay1_initsong(t_xs_status * myStatus)
	{
		t_xs_sidplay1 *myEngine;
		assert(myStatus);

		myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
		if (!myEngine)
			return FALSE;

		if (!myEngine->currTune) {
			XSERR("Tune was NULL\n");
			return FALSE;
		}

		if (!myEngine->currTune->getStatus()) {
			XSERR("Tune status check failed\n");
			return FALSE;
		}

		return sidEmuInitializeSong(*myEngine->currEng, *myEngine->currTune, myStatus->currSong);
	}


/* Emulate and render audio data to given buffer
 */
	guint xs_sidplay1_fillbuffer(t_xs_status * myStatus, gchar * audioBuffer, guint audioBufSize)
	{
		t_xs_sidplay1 *myEngine;
		assert(myStatus);

		myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
		if (!myEngine)
			return 0;

		sidEmuFillBuffer(*myEngine->currEng, *myEngine->currTune, audioBuffer, audioBufSize);

		return audioBufSize;
	}


/* Load a given SID-tune file
 */
	gboolean xs_sidplay1_loadsid(t_xs_status * myStatus, gchar * pcFilename)
	{
		t_xs_sidplay1 *myEngine;
		sidTune *newTune;
		assert(myStatus);

		myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;

		/* Try to get the tune */
		if (!pcFilename)
			return FALSE;

		newTune = new sidTune(pcFilename);
		if (!newTune)
			return FALSE;

		myEngine->currTune = newTune;

		return TRUE;
	}


/* Delete INTERNAL information
 */
	void xs_sidplay1_deletesid(t_xs_status * myStatus)
	{
		t_xs_sidplay1 *myEngine;
		assert(myStatus);

		myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
		if (!myEngine)
			return;

		if (myEngine->currTune) {
			delete myEngine->currTune;
			myEngine->currTune = NULL;
		}
	}


/* Return song information
 */
#define TFUNCTION	xs_sidplay1_getsidinfo
#define TTUNEINFO	sidTuneInfo
#define TTUNE		sidTune
#include "xs_sidplay.h"

}				/* extern "C" */
#endif				/* HAVE_SIDPLAY1 */