/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            soundplayer.cc
 *
 *  Fri Sep  5 17:31:28 CEST 2014
 *  Copyright 2014 Bent Bisballe Nyeng
 *  deva@aasimon.org
 ****************************************************************************/

/*
 *  This file is part of Kaiman.
 *
 *  Kaiman 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.
 *
 *  Kaiman 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 Kaiman; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */
#include "soundplayer.h"

#include <ao/ao.h>
#include <sndfile.h>
#include <samplerate.h>
#include <cmath>

#define BUFSZ 512

SoundPlayer::SoundPlayer()
{
	start();
}

SoundPlayer::~SoundPlayer()
{
	running = false;
	wait();
}

void SoundPlayer::run()
{
	printf("SoundPlayer running\n");

	ao_initialize();

	ao_sample_format sf;
	memset(&sf, 0, sizeof(sf));
	sf.bits = 16;
	sf.rate = 48000;
	sf.channels = 2;
	sf.byte_format = AO_FMT_NATIVE;

	ao_device *dev = ao_open_live(ao_default_driver_id(), &sf, 0);

	running = true;

	short s[BUFSZ];
	float _sf[BUFSZ];
	double scale = 1.0;
	while(running)
	{
		{ // Check for new Selection.
			QMutexLocker lock(&mutex);
			while(queue.size())
			{
				active.append(queue.front());
				queue.pop_front();
			}
		}

		memset(s, 0, BUFSZ * sizeof(short));
		memset(_sf, 0, BUFSZ * sizeof(float));

		QList<QueueItem>::iterator it = active.begin();
		while(it != active.end())
		{
			QueueItem &item = *it;

			for(size_t i = 0; i < BUFSZ; i++)
			{
				if(item.pos >= item.size)
				{
					it = active.erase(it);
					goto nextitem;
				}

				scale = std::min(scale, 1.0 / active.size());
				_sf[i] += item.samples[item.pos] * scale;

				item.pos++;
				scale += 0.00000001;
				if(scale > 1.0)
				{
					scale = 1.0;
				}
			}

			it++;

		nextitem:
			int a = 1;(void)a;
		}

		for(size_t i = 0; i < BUFSZ; i++)
		{
			s[i] = _sf[i] * 32000.0;
		}
		ao_play(dev, (char*)s, BUFSZ * sizeof(short));
	}

	ao_close(dev);
	ao_shutdown();
}

SoundPlayer::Samples SoundPlayer::getSampleData(QString file)
{
	// Not yet in cache. Read it from file
	if(!cache.contains(file))
	{
		printf("Insert '%s' into cache\n", file.toStdString().data());
		SNDFILE *fh;
		SF_INFO sf_info{};

		fh = sf_open(file.toStdString().c_str(), SFM_READ, &sf_info);
		if(!fh)
		{
			printf("Load error '%s'\n", file.toStdString().c_str());
			return {};
		}

		size_t size = sf_info.frames * sf_info.channels;
		float *data = new float[size];
		sf_read_float(fh, data, size);
		sf_close(fh);

		if(sf_info.channels != 2)
		{
			printf("channel convert %d => 2\n", (int)sf_info.channels);
			float* stereo_data = new float[sf_info.frames * 2];
			for(int i = 0; i < sf_info.frames; ++i)
			{
				int c = 0;
				for(;c < sf_info.channels && c < 2; ++c)
				{
					stereo_data[i * 2 + c] = data[i * sf_info.channels + c];
				}
				int last = c - 1;
				for(;c < 2; ++c)
				{
					stereo_data[i * 2 + c] = data[i * sf_info.channels + last];
				}
			}
			delete[] data;
			data = stereo_data;
			size = sf_info.frames * 2;
		}

		if(sf_info.samplerate != 48000)
		{
			printf("resample %d => 48000\n", (int)sf_info.samplerate);
			double ratio = 48000.0 / sf_info.samplerate;
			std::size_t resampled_frames = sf_info.frames * ratio;
			float *resampled_data = new float[resampled_frames * 2];

			SRC_DATA s{};
			s.data_in = data;
			s.input_frames = sf_info.frames;

			s.data_out = resampled_data;
			s.output_frames = resampled_frames;

			s.src_ratio = ratio;

			int err = src_simple(&s, SRC_SINC_BEST_QUALITY, 2);
			if(err)
			{
				printf("SRC error: %s\n", src_strerror(err));
			}
			delete[] data;
			data = resampled_data;
			size = s.output_frames_gen * 2;
			printf("size: %d\n", (int)size);
		}

		Samples s;
		s.data = data;
		s.size = size;
		printf(" - %p %d\n", (void*)s.data, (int)s.size);
		cache.insert(file, s);
	}

	return cache[file];
}

void SoundPlayer::playFile(QString file)
{
	auto samples = getSampleData(file);

	printf(" - playFile(%s) [%p %d]\n", file.toStdString().c_str(),
	       (void*)samples.data, (int)samples.size);

	QueueItem qi;
	qi.samples = samples.data;
	qi.pos = 0;
	qi.size = samples.size;

	{
		QMutexLocker lock(&mutex);
		queue.append(qi);
	}
}