No OneTemporary
Actions

Authored By

Unknown

Size

66 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/music-player.cpp b/util/music-player.cpp
	index 25b5d2c9..eea2f450 100644
	--- a/util/music-player.cpp
	+++ b/util/music-player.cpp
	@@ -1,649 +1,652 @@
	#ifdef USE_ALLEGRO
	#include <allegro.h>
	#endif

	#include "music-player.h"
	#include "globals.h"
	#include "util/debug.h"
	#include <iostream>
	#include "configuration.h"
	#include "sound.h"
	#include "dumb/include/dumb.h"
	#include "gme/Music_Emu.h"
	#include "exceptions/exception.h"
	#include <sstream>
	#include <stdio.h>

	#ifdef USE_ALLEGRO5
	#include <allegro5/allegro_audio.h>
	#endif

	#ifdef USE_ALLEGRO
	#include "dumb/include/aldumb.h"

	#ifdef _WIN32
	/* what do we need winalleg for?
	* reason: ...
	*/
	#include <winalleg.h>
	#endif

	#endif

	#ifdef HAVE_MP3_MPG123
	#include <mpg123.h>
	#endif

	#ifdef HAVE_MP3_MAD
	#include <mad.h>
	#endif

	#ifdef USE_SDL
	#include "sdl/mixer/SDL_mixer.h"
	#endif

	+using std::string;
	+
	namespace Util{

	class MusicException: public Exception::Base {
	public:
	MusicException(const std::string & file, int line, const std::string & reason):
	Exception::Base(file, line),
	reason(reason){
	}

	MusicException(const MusicException & copy):
	Exception::Base(copy),
	reason(copy.reason){
	}

	virtual ~MusicException() throw(){
	}

	protected:
	virtual const std::string getReason() const {
	return reason;
	}

	virtual Exception::Base * copy() const {
	return new MusicException(*this);
	}

	std::string reason;
	};

	static double scaleVolume(double start){
	return start;
	}

	/* 1 for big endian (most significant byte)
	* 0 for little endian (least significant byte)
	*/
	/* FIXME: move this to global or something and find a better #ifdef */
	int bigEndian(){
	#ifdef PS3
	return 1;
	#else
	return 0;
	#endif
	}

	#ifdef USE_ALLEGRO5
	const int DUMB_SAMPLES = 1024;
	MusicRenderer::MusicRenderer(){
	create(Sound::Info.frequency, 2);
	}

	MusicRenderer::MusicRenderer(int frequency, int channels){
	create(frequency, channels);
	}

	void MusicRenderer::create(int frequency, int channels){
	ALLEGRO_CHANNEL_CONF configuration = ALLEGRO_CHANNEL_CONF_2;
	switch (channels){
	case 1: configuration = ALLEGRO_CHANNEL_CONF_1; break;
	case 2: configuration = ALLEGRO_CHANNEL_CONF_2; break;
	case 3: configuration = ALLEGRO_CHANNEL_CONF_3; break;
	case 4: configuration = ALLEGRO_CHANNEL_CONF_4; break;
	case 5: configuration = ALLEGRO_CHANNEL_CONF_5_1; break;
	case 6: configuration = ALLEGRO_CHANNEL_CONF_6_1; break;
	case 7: configuration = ALLEGRO_CHANNEL_CONF_7_1; break;
	default: configuration = ALLEGRO_CHANNEL_CONF_2; break;
	}
	stream = al_create_audio_stream(4, DUMB_SAMPLES, frequency, ALLEGRO_AUDIO_DEPTH_INT16, configuration);
	if (!stream){
	throw MusicException(__FILE__, __LINE__, "Could not create allegro5 audio stream");
	}
	queue = al_create_event_queue();
	al_register_event_source(queue, al_get_audio_stream_event_source(stream));
	}

	void MusicRenderer::play(MusicPlayer & player){
	al_attach_audio_stream_to_mixer(stream, al_get_default_mixer());
	}

	void MusicRenderer::pause(){
	al_detach_audio_stream(stream);
	}

	MusicRenderer::~MusicRenderer(){
	al_destroy_audio_stream(stream);
	al_destroy_event_queue(queue);
	}

	void MusicRenderer::poll(MusicPlayer & player){
	ALLEGRO_EVENT event;
	while (al_get_next_event(queue, &event)){
	if (event.type == ALLEGRO_EVENT_AUDIO_STREAM_FRAGMENT) {
	ALLEGRO_AUDIO_STREAM * stream = (ALLEGRO_AUDIO_STREAM *) event.any.source;
	void * data = al_get_audio_stream_fragment(stream);
	if (data != NULL){
	player.render(data, al_get_audio_stream_length(stream));
	al_set_audio_stream_fragment(stream, data);
	}
	}
	}
	}
	#elif USE_SDL
	MusicRenderer::MusicRenderer(){
	create(Sound::Info.frequency, Sound::Info.channels);
	}

	MusicRenderer::MusicRenderer(int frequency, int channels){
	create(frequency, channels);
	}

	void MusicRenderer::create(int frequency, int channels){
	int format = AUDIO_S16;
	if (bigEndian()){
	format = AUDIO_S16MSB;
	}
	+ Global::debug(1) << "Convert between " << format << ", " << channels << ", " << frequency << " to " << Sound::Info.format << ", " << Sound::Info.channels << ", " << Sound::Info.frequency << std::endl;
	SDL_BuildAudioCVT(&convert, format, channels, frequency,
	Sound::Info.format, Sound::Info.channels,
	Sound::Info.frequency);
	data = new Uint8[1024 * 32];
	}

	void MusicRenderer::mixer(void * arg, Uint8 * stream, int bytes){
	MusicPlayer * player = (MusicPlayer*) arg;
	int size = (int)((float) bytes / player->getRenderer()->convert.len_ratio / (float) player->getRenderer()->convert.len_mult);
	- // Global::debug(0) << "Incoming " << bytes << " render " << size << std::endl;
	+ Global::debug(2) << "Incoming " << bytes << " render " << size << std::endl;
	player->getRenderer()->convert.buf = player->getRenderer()->data;
	player->getRenderer()->convert.len = size;
	// player->render(stream, bytes / 4);
	player->render(player->getRenderer()->data, size / 4);

	SDL_ConvertAudio(&player->getRenderer()->convert);
	memcpy(stream, player->getRenderer()->data, bytes);
	}

	void MusicRenderer::play(MusicPlayer & player){
	Mix_HookMusic(mixer, &player);
	}

	void MusicRenderer::pause(){
	Mix_HookMusic(NULL, NULL);
	}

	void MusicRenderer::poll(MusicPlayer & player){
	}

	MusicRenderer::~MusicRenderer(){
	Mix_HookMusic(NULL, NULL);
	delete[] data;
	}
	#elif USE_ALLEGRO
	int BUFFER_SIZE = 1 << 11;
	static int ALLEGRO_MONO = 0;
	static int ALLEGRO_STEREO = 1;
	MusicRenderer::MusicRenderer(){
	create(Sound::Info.frequency, 1);
	}

	MusicRenderer::MusicRenderer(int frequency, int channels){
	create(frequency, channels);
	}

	void MusicRenderer::create(int frequency, int channels){
	int configuration = ALLEGRO_STEREO;
	if (channels == 1){
	configuration = ALLEGRO_MONO;
	}
	stream = play_audio_stream(BUFFER_SIZE, 16, configuration, frequency, 255, 128);
	if (!stream){
	throw MusicException(__FILE__, __LINE__, "Could not create Allegro stream");
	}
	if (stream->len != BUFFER_SIZE){
	throw MusicException(__FILE__, __LINE__, "Buffer size mismatch");
	}
	voice_set_priority(stream->voice, 255);
	}

	void MusicRenderer::play(MusicPlayer & player){
	voice_start(stream->voice);
	}

	void MusicRenderer::pause(){
	voice_stop(stream->voice);
	}

	void MusicRenderer::poll(MusicPlayer & player){
	short * buffer = (short*) get_audio_stream_buffer(stream);
	if (buffer){
	player.render(buffer, BUFFER_SIZE);

	/* allegro wants unsigned data but gme produces signed so to convert
	* signed samples to unsigned samples we have to raise each value
	* by half the maximum value of a short (0xffff+1)/2 = 0x8000
	*/
	for (int i = 0; i < BUFFER_SIZE * 2; i++){
	buffer[i] += 0x8000;
	}

	free_audio_stream_buffer(stream);
	}
	}

	MusicRenderer::~MusicRenderer(){
	stop_audio_stream(stream);
	}
	#endif

	MusicPlayer::MusicPlayer():
	volume(1.0),
	out(new MusicRenderer()){
	}

	MusicPlayer::~MusicPlayer(){
	}

	void MusicPlayer::setRenderer(const ReferenceCount<MusicRenderer> & what){
	this->out = what;
	}

	void MusicPlayer::play(){
	out->play(*this);
	}

	void MusicPlayer::pause(){
	out->pause();
	}

	void MusicPlayer::poll(){
	out->poll(*this);
	}

	static const char * typeToExtension( int i ){
	switch (i){
	case 0 : return ".xm";
	case 1 : return ".s3m";
	case 2 : return ".it";
	case 3 : return ".mod";
	default : return "";
	}
	}

	/* expects each sample to be 4 bytes, 2 bytes per sample * 2 channels */
	-DumbPlayer::DumbPlayer(const char * path){
	+DumbPlayer::DumbPlayer(string path){
	music_file = loadDumbFile(path);
	if (music_file == NULL){
	std::ostringstream error;
	error << "Could not load DUMB file " << path;
	throw MusicException(__FILE__, __LINE__, error.str());
	}

	int n_channels = 2;
	int position = 0;
	renderer = duh_start_sigrenderer(music_file, 0, n_channels, position);
	if (!renderer){
	Global::debug(0) << "Could not create renderer" << std::endl;
	throw Exception::Base(__FILE__, __LINE__);
	}
	}

	void DumbPlayer::render(void * data, int samples){
	double delta = 65536.0 / Sound::Info.frequency;
	/* FIXME: use global music volume to scale the output here */
	int n = duh_render(renderer, 16, 0, volume, delta, samples, data);
	}

	void DumbPlayer::setVolume(double volume){
	this->volume = volume;
	}

	DumbPlayer::~DumbPlayer(){
	duh_end_sigrenderer(renderer);
	unload_duh(music_file);
	}

	-DUH * DumbPlayer::loadDumbFile(const char * path){
	+DUH * DumbPlayer::loadDumbFile(string path){
	DUH * what;
	for (int i = 0; i < 4; i++){
	/* the order of trying xm/s3m/it/mod matters because mod could be
	* confused with one of the other formats, so load it last.
	*/
	switch (i){
	case 0 : {
	- what = dumb_load_xm_quick(path);
	+ what = dumb_load_xm_quick(path.c_str());
	break;
	}
	case 1 : {
	- what = dumb_load_s3m_quick(path);
	+ what = dumb_load_s3m_quick(path.c_str());
	break;
	}
	case 2 : {
	- what = dumb_load_it_quick(path);
	+ what = dumb_load_it_quick(path.c_str());
	break;
	}
	case 3 : {
	- what = dumb_load_mod_quick(path);
	+ what = dumb_load_mod_quick(path.c_str());
	break;
	}
	}

	if (what != NULL){
	Global::debug(0) << "Loaded " << path << " type " << typeToExtension(i) << "(" << i << ")" << std::endl;
	return what;
	}
	}
	return NULL;
	}

	-GMEPlayer::GMEPlayer(const char * path):
	+GMEPlayer::GMEPlayer(string path):
	emulator(NULL){
	- gme_err_t fail = gme_open_file(path, &emulator, Sound::Info.frequency);
	+ gme_err_t fail = gme_open_file(path.c_str(), &emulator, Sound::Info.frequency);
	if (fail != NULL){
	Global::debug(0) << "GME load error for " << path << ": " << fail << std::endl;
	throw MusicException(__FILE__, __LINE__, "Could not load GME file");
	}
	emulator->start_track(0);
	Global::debug(0) << "Loaded GME file " << path << std::endl;
	}

	void GMEPlayer::render(void * stream, int length){
	/* length/2 to convert bytes to short */
	emulator->play(length * 2, (short*) stream);

	if (emulator->track_ended()){
	gme_info_t * info;
	gme_track_info(emulator, &info, 0);
	int intro = info->intro_length;
	emulator->start_track(0);
	// Global::debug(0) << "Seeking " << intro << "ms. Track length " << info->length << "ms" << std::endl;
	/* skip past the intro if there is a loop */
	if (info->loop_length != 0){
	emulator->seek(intro);
	}
	}

	/* scale for volume */
	for (int i = 0; i < length * 2; i++){
	short & sample = ((short *) stream)[i];
	sample *= volume;
	}

	/*
	short large = 0;
	short small = 0;
	for (int i = 0; i < length / 2; i++){
	// ((short ) stream)[i] = 2;
	short z = ((short *) stream)[i];
	if (z < small){
	small = z;
	}
	if (z > large){
	large = z;
	}
	}
	Global::debug(0) << "Largest " << large << " Smallest " << small << std::endl;
	*/
	}

	void GMEPlayer::setVolume(double volume){
	this->volume = volume;
	}

	GMEPlayer::~GMEPlayer(){
	delete emulator;
	}

	#ifdef HAVE_MP3_MPG123
	/* initialize the mpg123 library and open up an mp3 file for reading */
	-static void initializeMpg123(mpg123_handle ** mp3, const char * path){
	+static void initializeMpg123(mpg123_handle ** mp3, string path){
	/* Initialize */
	if (mpg123_init() != MPG123_OK){
	throw MusicException(__FILE__, __LINE__, "Could not initialize mpg123");
	}
	try{
	*mp3 = mpg123_new(NULL, NULL);
	if (*mp3 == NULL){
	throw MusicException(__FILE__,__LINE__, "Could not allocate mpg handle");
	}
	mpg123_format_none(*mp3);

	/* allegro wants unsigned samples but mpg123 can't actually provide unsigned
	* samples even though it has an enum for it, MPG123_ENC_UNSIGNED_16. this
	* was rectified in 1.13.0 or something, but for now signed samples are ok.
	*/
	int error = mpg123_format(*mp3, Sound::Info.frequency, MPG123_STEREO, MPG123_ENC_SIGNED_16);
	if (error != MPG123_OK){
	Global::debug(0) << "Could not set format for mpg123 handle" << std::endl;
	}

	/* FIXME workaround for libmpg issues with "generic" decoder frequency not being set */
	- error = mpg123_open(mp3, (char) path);
	+ error = mpg123_open(mp3, (char) path.c_str());
	if (error == -1){
	std::ostringstream error;
	error << "Could not open mpg123 file " << path << " error code " << error;
	throw MusicException(__FILE__,__LINE__, error.str());
	}

	/* reading a frame is the only surefire way to get mpg123 to set the
	* sampling_frequency which it needs to set the decoder a few lines below
	*/
	size_t dont_care;
	unsigned char tempBuffer[4096];
	error = mpg123_read(*mp3, tempBuffer, sizeof(tempBuffer), &dont_care);
	if (!(error == MPG123_OK \|\| error == MPG123_NEW_FORMAT)){
	std::ostringstream error;
	error << "Could not read mpg123 file " << path << " error code " << error;
	throw MusicException(__FILE__,__LINE__, error.str());
	}
	mpg123_close(*mp3);

	/* stream has progressed a little bit so reset it by opening it again */
	- error = mpg123_open(mp3, (char) path);
	+ error = mpg123_open(mp3, (char) path.c_str());
	if (error == -1){
	std::ostringstream error;
	error << "Could not open mpg123 file " << path << " error code " << error;
	throw MusicException(__FILE__,__LINE__, error.str());
	}
	/* FIXME end */

	/* some of the native decoders aren't stable in older versions of mpg123
	* so just use generic for now. 1.13.1 should work better
	*/
	error = mpg123_decoder(*mp3, "generic");
	if (error != MPG123_OK){
	std::ostringstream error;
	error << "Could not use 'generic' mpg123 decoder for " << path << " error code " << error;
	throw MusicException(__FILE__,__LINE__, error.str());
	}
	// Global::debug(0) << "mpg support " << mpg123_format_support(mp3, Sound::FREQUENCY, MPG123_ENC_SIGNED_16) << std::endl;

	/*
	double base, really, rva;
	mpg123_getvolume(*mp3, &base, &really, &rva);
	// Global::debug(0) << "mpg volume base " << base << " really " << really << " rva " << rva << std::endl;
	base_volume = base;

	long rate;
	int channels, encoding;
	mpg123_getformat(*mp3, &rate, &channels, &encoding);
	// Global::debug(0) << path << " rate " << rate << " channels " << channels << " encoding " << encoding << std::endl;
	*/
	} catch (const MusicException & fail){
	if (*mp3 != NULL){
	mpg123_close(*mp3);
	mpg123_delete(*mp3);
	*mp3 = NULL;
	}
	mpg123_exit();
	throw;
	}
	}

	static const int MPG123_BUFFER_SIZE = 1 << 11;
	-Mp3Player::Mp3Player(const char * path):
	+Mp3Player::Mp3Player(string path):
	mp3(NULL){
	initializeMpg123(&mp3, path);
	long rate = 0;
	int channels = 0, encoding = 0;
	mpg123_getformat(mp3, &rate, &channels, &encoding);
	}

	void Mp3Player::render(void * data, int samples){
	/* buffer * 4 for 16 bits per sample * 2 samples for stereo */
	size_t out = 0;
	mpg123_read(mp3, (unsigned char ) data, samples 4, &out);

	/*
	long rate;
	int channels, encoding;
	mpg123_getformat(mp3, &rate, &channels, &encoding);
	Global::debug(0) << "rate " << rate << " channels " << channels << " encoding " << encoding << std::endl;
	*/
	}

	void Mp3Player::setVolume(double volume){
	mpg123_volume(mp3, volume);
	/*
	this->volume = volume;
	// mpg123_volume(mp3, volume * base_volume / 5000);
	mpg123_volume(mp3, 0.0001);
	*/
	// mpg123_volume(mp3, volume);
	}

	Mp3Player::~Mp3Player(){
	mpg123_close(mp3);
	mpg123_exit();
	}

	#endif /* MP3_MPG123 */

	#ifdef HAVE_OGG
	int OGG_BUFFER_SIZE = 1024 * 32;
	-OggPlayer::OggPlayer(const char * path):
	+OggPlayer::OggPlayer(string path):
	path(path){
	- file = fopen(path, "rb");
	+ file = fopen(path.c_str(), "rb");
	if (!file) {
	throw MusicException(__FILE__, __LINE__, "Could not open file");
	}

	if (ov_open_callbacks(file, &ogg, 0, 0, OV_CALLBACKS_DEFAULT) != 0) {
	fclose(file);
	throw MusicException(__FILE__, __LINE__, "Could not open ogg");
	}

	vorbis_info * info = ov_info(&ogg, -1);

	frequency = info->rate;
	channels = info->channels;
	bits = 16;
	length = ov_pcm_total(&ogg, -1);

	setRenderer(new MusicRenderer(info->rate, info->channels));

	buffer = new OggPage();
	buffer->buffer1.buffer = new char[OGG_BUFFER_SIZE];
	// buffer->buffer2.buffer = new char[OGG_BUFFER_SIZE];

	fillPage(&buffer->buffer1);
	// fillPage(&buffer->buffer2);
	// buffer->use = 0;
	}

	void OggPlayer::fillPage(OggPage::Page * page){
	int dont_care;
	page->position = 0;
	page->max = 0;
	while (page->max < OGG_BUFFER_SIZE){
	/* ov_read might not read all available samples, I guess it stops
	* reading on a page boundary. We just plow on through.
	*/
	int read = ov_read(&ogg, (char*) page->buffer + page->max, OGG_BUFFER_SIZE - page->max,
	bigEndian(), 2, 1, &dont_care);
	/* if we hit the end of the file then re-open it and keep reading */
	if (read == 0){
	ov_clear(&ogg);
	file = fopen(path.c_str(), "rb");
	if (!file){
	throw MusicException(__FILE__, __LINE__, "Could not open file");
	}
	int ok = ov_open_callbacks(file, &ogg, 0, 0, OV_CALLBACKS_DEFAULT);
	if (ok != 0){
	fclose(file);
	throw MusicException(__FILE__, __LINE__, "Could not open ogg");
	}
	} else if (read == OV_HOLE){
	throw MusicException(__FILE__, __LINE__, "Garbage in ogg file");
	} else if (read == OV_EBADLINK){
	throw MusicException(__FILE__, __LINE__, "Invalid stream section in ogg");
	} else if (read == OV_EINVAL){
	throw MusicException(__FILE__, __LINE__, "File headers are corrupt in ogg");
	} else {
	page->max += read;
	}
	}
	}

	void OggPlayer::doRender(char * data, int bytes){
	OggPage::Page & page = buffer->buffer1;
	if (page.max - page.position >= bytes){
	memcpy(data, page.buffer + page.position, bytes);
	page.position += bytes;
	} else {
	/* copy the rest, fill the page, switch to the other buffer */
	memcpy(data, page.buffer + page.position, page.max - page.position);
	int at = page.max - page.position;
	int rest = bytes - (page.max - page.position);
	fillPage(&page);
	doRender(data + at, rest);
	}
	}

	void OggPlayer::render(void * data, int length){
	doRender((char) data, length 4);
	}

	void OggPlayer::setVolume(double volume){
	this->volume = volume;
	// Mix_VolumeMusic(volume * MIX_MAX_VOLUME);
	}

	OggPlayer::~OggPlayer(){
	/* ov_clear will close the file */
	ov_clear(&ogg);
	}
	#endif /* OGG */

	#ifdef HAVE_MP3_MAD
	/* TODO */
	-Mp3Player::Mp3Player(const char * path){
	+Mp3Player::Mp3Player(string path){
	/* TODO */
	}

	void Mp3Player::render(void * data, int length){
	}

	void Mp3Player::setVolume(double volume){
	/* TODO */
	}

	Mp3Player::~Mp3Player(){
	/* TODO */
	}
	#endif /* MP3_MAD */


	}
	diff --git a/util/music-player.h b/util/music-player.h
	index cf330fa1..8f92c0ec 100644
	--- a/util/music-player.h
	+++ b/util/music-player.h
	@@ -1,185 +1,185 @@
	#ifndef _paintown_music_player_h
	#define _paintown_music_player_h

	#include <string>
	#include <stdio.h>

	#ifdef USE_SDL
	/* for Uint8 */
	#include <SDL.h>
	#include "sdl/mixer/SDL_mixer.h"
	#endif

	#ifdef HAVE_MP3_MPG123
	#include <mpg123.h>
	#endif

	#ifdef HAVE_OGG
	#include <vorbis/vorbisfile.h>
	#endif

	#ifdef HAVE_MP3_MAD
	#include <mad.h>
	#endif

	#include "pointer.h"

	struct DUH;
	struct DUH_SIGRENDERER;
	#ifdef USE_ALLEGRO
	struct AUDIOSTREAM;
	#endif
	struct LOGG_Stream;
	class Music_Emu;

	#ifdef USE_ALLEGRO5
	struct ALLEGRO_AUDIO_STREAM;
	struct ALLEGRO_EVENT_QUEUE;
	#endif

	namespace Util{

	class MusicPlayer;
	/* implemented by some backend: allegro4/sdl/allergo5 */
	class MusicRenderer{
	public:
	MusicRenderer();
	MusicRenderer(int frequency, int channels);
	virtual ~MusicRenderer();
	void poll(MusicPlayer & player);
	void play(MusicPlayer & player);
	void pause();

	protected:
	void create(int frequency, int channels);
	#ifdef USE_SDL
	static void mixer(void * arg, Uint8 * stream, int length);
	SDL_AudioCVT convert;
	Uint8 * data;
	#endif

	#ifdef USE_ALLEGRO
	AUDIOSTREAM * stream;
	#endif

	#ifdef USE_ALLEGRO5
	ALLEGRO_AUDIO_STREAM * stream;
	ALLEGRO_EVENT_QUEUE * queue;
	#endif
	};

	class MusicPlayer{
	public:
	MusicPlayer();
	virtual void play();
	virtual void poll();
	virtual void pause();
	virtual void setVolume(double volume) = 0;
	virtual ~MusicPlayer();

	/* length is in samples not bytes */
	virtual void render(void * stream, int length) = 0;

	virtual inline double getVolume() const {
	return volume;
	}

	virtual const ReferenceCount<MusicRenderer> & getRenderer() const {
	return out;
	}
	virtual void setRenderer(const ReferenceCount<MusicRenderer> & what);

	protected:
	double volume;
	ReferenceCount<MusicRenderer> out;
	};

	/* uses the GME library, plays nintendo music files and others */
	class GMEPlayer: public MusicPlayer {
	public:
	- GMEPlayer(const char * path);
	+ GMEPlayer(std::string path);
	virtual void setVolume(double volume);
	virtual ~GMEPlayer();
	virtual void render(void * stream, int length);

	protected:
	Music_Emu * emulator;
	};

	#ifdef HAVE_OGG
	struct OggPage{
	struct Page{
	int position;
	int max;
	char * buffer;

	~Page(){
	delete[] buffer;
	}
	};
	Page buffer1;
	// Page buffer2;
	// int use;
	};

	/* Maybe have some common sdl mixer class that this can inherit? */
	class OggPlayer: public MusicPlayer {
	public:
	- OggPlayer(const char * path);
	+ OggPlayer(std::string path);
	virtual void setVolume(double volume);
	virtual void render(void * stream, int length);

	virtual ~OggPlayer();
	protected:
	void fillPage(OggPage::Page * page);
	void doRender(char * data, int bytes);
	FILE* file;
	std::string path;
	OggVorbis_File ogg;
	ReferenceCount<OggPage> buffer;

	int frequency;
	int channels;
	int bits;
	ogg_int64_t length;
	};
	#endif

	#if defined (HAVE_MP3_MPG123) \|\| defined (HAVE_MP3_MAD)
	/* Interface for mp3s */
	class Mp3Player: public MusicPlayer {
	public:
	- Mp3Player(const char * path);
	+ Mp3Player(std::string path);
	virtual void setVolume(double volume);
	virtual void render(void * data, int length);

	virtual ~Mp3Player();
	protected:
	#ifdef HAVE_MP3_MPG123
	mpg123_handle * mp3;
	double base_volume;
	#elif HAVE_MP3_MAD
	#endif
	};
	#endif

	/* interface to DUMB, plays mod/s3m/xm/it */
	class DumbPlayer: public MusicPlayer {
	public:
	- DumbPlayer(const char * path);
	+ DumbPlayer(std::string path);
	virtual void setVolume(double volume);
	virtual void render(void * data, int samples);

	virtual ~DumbPlayer();

	protected:
	- DUH * loadDumbFile(const char * path);
	+ DUH * loadDumbFile(std::string path);

	protected:
	DUH * music_file;
	DUH_SIGRENDERER * renderer;
	};

	}

	#endif
	diff --git a/util/music.cpp b/util/music.cpp
	index 6cbec39e..b03efac2 100644
	--- a/util/music.cpp
	+++ b/util/music.cpp
	@@ -1,461 +1,434 @@
	#include "music.h"
	#include <string>
	#include <iostream>
	#include "globals.h"
	#include <algorithm>
	// #include "defs.h"

	#include "configuration.h"
	#include "thread.h"
	#include "funcs.h"
	#include "file-system.h"
	#include "music-player.h"

	using namespace std;

	static Music * instance = NULL;

	static double volume = 1.0;
	// static bool muted = false;
	static Util::Thread::Id musicThread;
	static Util::Thread::Lock musicMutex;
	static bool alive = true;

	static void * playMusic( void * );

	-#define synchronized for( int __l( ! Util::Thread::acquireLock(&musicMutex)); __l; __l = 0, Util::Thread::releaseLock(&musicMutex) )
	-
	#define LOCK Util::Thread::acquireLock(&musicMutex);
	#define UNLOCK Util::Thread::releaseLock(&musicMutex);

	/*
	#undef LOCK
	#undef UNLOCK
	#define LOCK
	#define UNLOCK
	*/

	static void * bogus_thread( void * x){
	return NULL;
	}

	Music::Music(bool on):
	playing(false),
	enabled(on),
	fading(0),
	musicPlayer(NULL),
	currentSong(""){

	if (instance != NULL){
	cerr << "Trying to instantiate music object twice!" << endl;
	return;
	}

	volume = (double) Configuration::getMusicVolume() / 100.0;

	instance = this;

	Util::Thread::initializeLock(&musicMutex);
	Global::debug(1) << "Creating music thread" << endl;
	if (on){
	Util::Thread::createThread(&musicThread, NULL, (Util::Thread::ThreadFunction) playMusic, (void *)instance);
	} else {
	/* FIXME: just don't create a thread at all.. */
	Util::Thread::createThread(&musicThread, NULL, (Util::Thread::ThreadFunction) bogus_thread, NULL);
	}
	}

	/*
	static bool isAlive(){
	bool f = false;
	synchronized{
	f = alive;
	}
	return f;
	}
	*/

	static void * playMusic( void * _music ){
	Music * music = (Music *) _music;

	Global::debug(1) << "Playing music" << endl;

	/*
	unsigned int tick = 0;
	unsigned int counter;
	*/

	bool playing = true;
	while (playing){
	LOCK;{
	playing = alive;
	music->doPlay();
	}
	UNLOCK;
	Util::rest(10);

	// Util::YIELD();
	// pthread_yield();
	}

	// cout << "Done with music thread" << endl;

	return NULL;
	}

	double Music::getVolume(){
	double vol = 0;
	LOCK;{
	vol = volume;
	}
	UNLOCK;
	return vol;
	}

	void Music::doPlay(){
	if (this->playing){
	double f = fading / 500.0;
	switch (fading){
	case -1: {
	if (volume + f < 0){
	fading = 0;
	volume = 0;
	} else {
	volume += f;
	this->_setVolume(volume);
	}
	break;
	}
	case 1: {
	if (volume + f > 1.0){
	fading = 0;
	volume = 1.0;
	} else {
	volume += f;
	this->_setVolume(volume);
	}
	break;
	}
	}
	if (musicPlayer != NULL){
	musicPlayer->poll();
	}
	}
	}

	/*
	Music::Music( const char * song ):
	volume( 1.0 ),
	muted( false ),
	player( NULL ),
	music_file( NULL ){

	loadSong( song );

	}

	Music::Music( const string & song ):
	volume( 1.0 ),
	muted( false ),
	player( NULL ),
	music_file( NULL ){
	loadSong( song );
	}
	*/

	void Music::fadeIn(double vol){
	LOCK;{
	// volume = vol;
	instance->_fadeIn();
	}
	UNLOCK;
	}

	void Music::fadeOut( double vol ){
	LOCK;{
	// volume = vol;
	instance->_fadeOut();
	}
	UNLOCK;
	}

	/* FIXME */
	void Music::_fadeIn(){
	// fading = 1;
	}

	void Music::_fadeOut(){
	// fading = -1;
	}

	-bool Music::loadSong( const char * song ){
	+bool Music::doLoadSong(string song){
	bool loaded = false;
	LOCK;{
	if (instance != NULL){
	loaded = instance->internal_loadSong(song);
	}
	}
	UNLOCK;
	return loaded;
	// muted = false;
	}

	/* remove an element from a vector at index 'pos' and return it */
	template< class Tx_ >
	static Tx_ removeVectorElement( vector< Tx_ > & toRemove, int pos ){
	int count = 0;
	typename vector< Tx_ >::iterator it;
	for ( it = toRemove.begin(); it != toRemove.end() && count < pos; count++, it++ );

	if ( it == toRemove.end() ){
	/* this isnt right, but whatever */
	return toRemove.front();
	}

	Tx_ removed = toRemove[pos];
	toRemove.erase(it);
	return removed;

	}

	void Music::loadSong(vector<Filesystem::AbsolutePath> songs){
	-
	- /*
	- cout << "Songs = " << &Songs << endl;
	- if ( ! loadSong( "music/song5.xm" ) ){
	- cerr << "Could not load music/song5.xm" << endl;
	- }
	- return;
	- */
	-
	- /*
	- vector<Filesystem::AbsolutePath> _songs = Songs;
	- vector<Filesystem::AbsolutePath> songs;
	- while ( ! _songs.empty() ){
	- int i = Util::rnd(_songs.size());
	- songs.push_back(removeVectorElement(_songs, i));
	- }
	- */
	-
	- /*
	- songs.clear();
	- songs.push_back( "music/song3.xm" );
	- */
	-
	std::random_shuffle(songs.begin(), songs.end());
	for (vector<Filesystem::AbsolutePath>::iterator it = songs.begin(); it != songs.end(); it++){
	Global::debug(1) << "Trying to load song " << (*it).path() << endl;
	- if (loadSong((*it).path())){
	+ if (doLoadSong((*it).path())){
	break;
	}
	}
	}

	-bool Music::loadSong( const string & song ){
	- return loadSong( song.c_str() );
	+bool Music::loadSong(const string & song){
	+ return doLoadSong(song);
	}

	void Music::_play(){
	if (playing == false && musicPlayer != NULL){
	musicPlayer->play();
	playing = true;
	}
	}

	void Music::play(){
	LOCK;{
	instance->_play();
	}
	UNLOCK;
	}

	void Music::_pause(){
	playing = false;
	if (musicPlayer != NULL){
	musicPlayer->pause();
	}
	}

	void Music::pause(){
	LOCK;{
	instance->_pause();
	}
	UNLOCK;
	}

	void Music::soften(){
	LOCK;{
	instance->_soften();
	}
	UNLOCK;
	}

	void Music::_soften(){
	if (volume > 0.1){
	volume -= 0.1;
	} else {
	volume = 0.0;
	}

	_setVolume(volume);
	}

	void Music::louden(){
	LOCK;{
	instance->_louden();
	}
	UNLOCK;
	}

	void Music::_louden(){
	if ( volume < 0.9 ){
	volume += 0.1;
	} else {
	volume = 1.0;
	}

	_setVolume(volume);
	}

	void Music::mute(){
	setVolume(0);
	}

	void Music::setVolume( double vol ){

	LOCK;{
	volume = vol;
	if ( volume > 1.0 ){
	volume = 1.0;
	}
	if ( volume < 0 ){
	volume = 0;
	}
	instance->_setVolume( volume );
	}
	UNLOCK;
	}

	void Music::_setVolume(double vol){
	if (musicPlayer){
	musicPlayer->setVolume(vol);
	}
	}

	Music::~Music(){

	LOCK;{
	if (musicPlayer){
	delete musicPlayer;
	}

	alive = false;
	playing = false;
	}
	UNLOCK;

	- Global::debug( 1 ) << "Waiting for music thread to die" << endl;
	+ Global::debug(1) << "Waiting for music thread to die" << endl;
	Util::Thread::joinThread(musicThread);

	}

	-static string getExtension(const char * path_){
	- string path(path_);
	+static string getExtension(string path){
	if (path.rfind('.') != string::npos){
	return Util::lowerCaseAll(path.substr(path.rfind('.') + 1));
	}
	return "";
	}

	/* true if the file extension is something DUMB will probably recognize */
	-static bool isDumbFile(const char * path){
	+static bool isDumbFile(string path){
	string extension = getExtension(path);
	return extension == "mod" \|\|
	extension == "s3m" \|\|
	extension == "it" \|\|
	extension == "xm";
	}

	-static bool isGMEFile(const char * path){
	+static bool isGMEFile(string path){
	string extension = getExtension(path);
	return extension == "nsf" \|\|
	extension == "spc" \|\|
	extension == "gym";
	}

	-static bool isOggFile(const char * path){
	+static bool isOggFile(string path){
	string extension = getExtension(path);
	return extension == "ogg";
	}

	-static bool isMp3File(const char * path){
	+static bool isMp3File(string path){
	string extension = getExtension(path);
	return extension == "mp3";
	}

	-bool Music::internal_loadSong( const char * path ){
	+bool Music::internal_loadSong(string path){
	if (!enabled){
	return false;
	}

	// cout << "Trying to load '" << path << "'" << endl;

	// Check current song and/or set it
	- if (currentSong.compare(std::string(path))==0){
	+ if (currentSong.compare(path)==0){
	return true;
	} else {
	- currentSong = std::string(path);
	+ currentSong = path;
	}

	if (musicPlayer != NULL){
	delete musicPlayer;
	musicPlayer = NULL;
	}
	try {
	if (isDumbFile(path)){
	musicPlayer = new Util::DumbPlayer(path);
	musicPlayer->play();
	playing = true;
	} else if (isGMEFile(path)){
	musicPlayer = new Util::GMEPlayer(path);
	musicPlayer->play();
	playing = true;
	#ifdef HAVE_OGG
	} else if (isOggFile(path)){
	musicPlayer = new Util::OggPlayer(path);
	musicPlayer->play();
	playing = true;
	#endif

	#if defined(HAVE_MP3_MPG123) \|\| defined(HAVE_MP3_MAD)
	} else if (isMp3File(path)){
	/* Utilize SDL mixer to handle mp3 */
	musicPlayer = new Util::Mp3Player(path);
	musicPlayer->play();
	playing = true;
	#endif
	} else {
	return false;
	}
	if (musicPlayer != NULL){
	musicPlayer->setVolume(volume);
	}
	} catch (const Exception::Base & ex){
	Global::debug(0) << "Could not open music file '" << path << "' because " << ex.getTrace() << endl;
	//! FIXME Change from Base exception in the futer
	return false;
	}

	return true;
	}

	void Music::changeSong(){
	- pause();
	+ // pause();
	fadeIn(0.3);
	loadSong(Storage::instance().getFiles(Storage::instance().find(Filesystem::RelativePath("music/")), "*"));
	play();
	}

	-#undef synchronized
	#undef LOCK
	#undef UNLOCK
	diff --git a/util/music.h b/util/music.h
	index f33de9da..5b5a312b 100644
	--- a/util/music.h
	+++ b/util/music.h
	@@ -1,66 +1,65 @@
	#ifndef _paintown_music_class_h
	#define _paintown_music_class_h

	#include <string>
	#include <vector>
	#include "util/file-system.h"

	struct AL_DUH_PLAYER;
	struct DUH;

	namespace Util{
	class MusicPlayer;
	}

	/* The music class. Dont be late or youll get an F!
	*/
	class Music{
	public:
	Music( bool on );

	virtual ~Music();

	- static bool loadSong( const char * song );
	- static bool loadSong( const std::string & song );
	-
	+ static bool loadSong(const std::string & song);
	static void changeSong();

	- /* load one of the songs in 'songs' */
	+ /* randomnly select a song from 'songs' and load it */
	static void loadSong(std::vector<Filesystem::AbsolutePath> songs);

	static void pause();
	static void play();
	static void soften();
	static void louden();
	static void fadeIn( double vol );
	static void fadeOut( double vol );
	static void setVolume( double v );
	static double getVolume();
	static void mute();
	static void unmute();

	void doPlay();

	protected:
	+ static bool doLoadSong(std::string song);

	void _setVolume( double vol );
	void _play();
	void _pause();
	void _soften();
	void _louden();
	void _fadeIn();
	void _fadeOut();

	bool playing;
	bool enabled;

	int fading;

	- bool internal_loadSong( const char * path );
	+ bool internal_loadSong(std::string path);

	Util::MusicPlayer * musicPlayer;

	std::string currentSong;
	};

	#endif
	diff --git a/util/nacl/network-system.cpp b/util/nacl/network-system.cpp
	index c03a9c03..9c9501b9 100644
	--- a/util/nacl/network-system.cpp
	+++ b/util/nacl/network-system.cpp
	@@ -1,926 +1,812 @@
	#ifdef NACL

	/* documentation for ppapi
	* http://code.google.com/chrome/nativeclient/docs/reference/peppercpp/inherits.html
	*/

	/* issues with getting data
	* 1. the function that starts the game is called from the main chrome thread
	* which starts from a javascript call to module.PostMessage('run').
	* ...
	*
	*/

	#include <unistd.h>
	#include <errno.h>
	#include "network-system.h"
	#include <sstream>
	#include <fstream>
	#include "../funcs.h"
	#include "../debug.h"
	#include <ppapi/c/pp_errors.h>
	#include <ppapi/cpp/url_loader.h>
	#include <ppapi/cpp/url_request_info.h>
	#include <ppapi/cpp/url_response_info.h>
	#include <ppapi/c/ppb_url_request_info.h>
	#include <ppapi/cpp/completion_callback.h>

	using std::string;
	using std::map;
	using std::vector;
	using std::ostringstream;
	using std::ifstream;

	namespace Nacl{

	static const char * CONTEXT = "nacl";

	typedef Path::AbsolutePath AbsolutePath;
	typedef Path::RelativePath RelativePath;

	enum RequestType{
	Exists
	};

	struct Request{
	RequestType type;
	AbsolutePath absolute;
	RelativePath relative;
	bool complete;
	bool success;
	};

	Request operation;

	struct NaclRequest{
	virtual ~NaclRequest(){
	}

	virtual void start() = 0;
	};

	struct NaclRequestOpen: public NaclRequest {
	NaclRequestOpen(pp::Instance * instance, const string & url, Manager * manager):
	request(instance),
	loader(instance),
	url(url),
	manager(manager){
	request.SetURL(url);
	request.SetMethod("GET");
	// request.SetProperty(PP_URLREQUESTPROPERTY_RECORDDOWNLOADPROGRESS, pp::Var((bool) PP_TRUE));
	}

	void start(){
	Global::debug(2) << "Request open for url " << url << std::endl;
	pp::CompletionCallback callback(&NaclRequestOpen::onFinish, this);
	int32_t ok = loader.Open(request, callback);
	Global::debug(2) << "Open " << ok << std::endl;
	if (ok != PP_OK_COMPLETIONPENDING){
	// Global::debug(0) << "Call on main thread" << std::endl;
	// core->CallOnMainThread(0, callback, ok);
	callback.Run(ok);
	}
	// Global::debug(1) << "Callback running" << std::endl;
	}

	static void onFinish(void * me, int32_t result){
	NaclRequestOpen * self = (NaclRequestOpen*) me;
	self->finish(result);
	}

	void finish(int32_t result);

	pp::URLRequestInfo request;
	pp::URLLoader loader;
	string url;
	Manager * manager;
	};

	struct NaclRequestExists: public NaclRequest {
	NaclRequestExists(pp::Instance * instance, const string & url, Manager * manager):
	request(instance),
	loader(instance),
	url(url),
	manager(manager){
	request.SetURL(url);
	request.SetMethod("GET");
	}

	void start(){
	pp::CompletionCallback callback(&NaclRequestExists::onFinish, this);
	int32_t ok = loader.Open(request, callback);
	if (ok != PP_OK_COMPLETIONPENDING){
	callback.Run(ok);
	}
	}

	static void onFinish(void * me, int32_t result){
	NaclRequestExists * self = (NaclRequestExists*) me;
	self->finish(result);
	}

	void finish(int32_t result);

	pp::URLRequestInfo request;
	pp::URLLoader loader;
	string url;
	Manager * manager;
	};

	-struct NaclRequestRead: public NaclRequest {
	- NaclRequestRead(pp::URLLoader & loader, Manager * manager, void * buffer, int read):
	- loader(loader),
	- manager(manager),
	- buffer(buffer),
	- read(read){
	- }
	-
	- void start(){
	- pp::CompletionCallback callback(&NaclRequestRead::onFinish, this);
	- int32_t ok = loader.ReadResponseBody(buffer, read, callback);
	- Global::debug(2) << "Read " << ok << std::endl;
	- if (ok != PP_OK_COMPLETIONPENDING){
	- // Global::debug(0) << "Call on main thread" << std::endl;
	- // core->CallOnMainThread(0, callback, ok);
	- callback.Run(ok);
	- }
	- }
	-
	- static void onFinish(void * me, int32_t result){
	- NaclRequestRead * self = (NaclRequestRead*) me;
	- self->finish(result);
	- }
	-
	- void finish(int32_t result);
	-
	- pp::URLLoader loader;
	- Manager * manager;
	- void * buffer;
	- int read;
	-};
	-
	class FileHandle{
	public:
	- FileHandle(const Util::ReferenceCount<NaclRequestOpen> & open):
	- open(open),
	- buffer(NULL){
	- }
	+ FileHandle():
	+ buffer(NULL){
	+ }

	~FileHandle(){
	delete[] buffer;
	}

	- pp::URLLoader & getLoader(){
	- return open->loader;
	- }
	-
	class Reader{
	public:
	static const int PAGE_SIZE = 1024 * 32;
	struct Page{
	Page():
	buffer(NULL),
	size(0),
	next(NULL){
	buffer = new char[PAGE_SIZE];
	}

	char * buffer;
	int size;
	Page * next;

	~Page(){
	delete[] buffer;
	delete next;
	}
	};

	Reader(pp::CompletionCallback finish, pp::URLLoader & loader, FileHandle * handle, pp::Core * core):
	finish(finish),
	loader(loader),
	handle(handle),
	core(core),
	tries(0){
	current = &page;
	}

	int getSize(){
	Page * use = &page;
	int total = 0;
	while (use != NULL){
	total += use->size;
	use = use->next;
	}
	return total;
	}

	void copy(char * buffer){
	Page * use = &page;
	while (use != NULL){
	memcpy(buffer, use->buffer, use->size);
	buffer += use->size;
	use = use->next;
	}
	}

	void read(){
	pp::CompletionCallback callback(&Reader::onRead, this);
	if (current->size == PAGE_SIZE){
	Page * next = new Page();
	current->next = next;
	current = next;
	}
	int32_t ok = loader.ReadResponseBody(current->buffer + current->size, PAGE_SIZE - current->size, callback);
	if (ok != PP_OK_COMPLETIONPENDING){
	callback.Run(ok);
	}
	}

	static void onRead(void * self, int32_t result){
	Reader * reader = (Reader*) self;
	reader->didRead(result);
	}

	void didRead(int32_t result){
	Global::debug(2) << "Read " << result << " bytes" << std::endl;
	current->size += result;
	if (result > 0){
	tries = 0;
	read();
	} else {
	- if (tries >= 2){
	+ if (tries >= 3){
	handle->readDone(this);
	} else {
	tries += 1;
	pp::CompletionCallback callback(&Reader::doRead, this);
	- core->CallOnMainThread(50, callback, 0);
	+ core->CallOnMainThread((tries - 1) * 25, callback, 0);
	}
	}
	}

	static void doRead(void * self, int32_t result){
	Reader * reader = (Reader*) self;
	reader->read();
	}

	pp::CompletionCallback finish;
	pp::URLLoader & loader;
	Page page;
	Page * current;
	FileHandle * handle;
	pp::Core * core;
	int tries;
	};

	- void readAll(pp::CompletionCallback finish, pp::Core * core){
	- reader = new Reader(finish, open->loader, this, core);
	+ void readAll(pp::CompletionCallback finish, pp::Core * core, pp::URLLoader & loader){
	+ reader = new Reader(finish, loader, this, core);
	reader->read();
	}

	void readDone(Reader * reader){
	length = reader->getSize();
	Global::debug(2) << "Done reading, got " << length << " bytes" << std::endl;
	position = 0;
	buffer = new char[length];
	reader->copy(buffer);
	reader->finish.Run(0);
	}

	int read(void * buffer, size_t count){
	size_t bytes = position + count < length ? count : (length - position);
	memcpy(buffer, this->buffer + position, bytes);
	position += bytes;
	return bytes;
	}

	off_t seek(off_t offset, int whence){
	switch (whence){
	case SEEK_SET: {
	position = offset;
	break;
	}
	case SEEK_CUR: {
	position += offset;
	break;
	}
	case SEEK_END: {
	position = length - offset;
	break;
	}
	}

	return position;
	}

	- Util::ReferenceCount<NaclRequestOpen> open;
	off_t position;
	off_t length;
	char * buffer;
	Util::ReferenceCount<Reader> reader;
	};

	class Manager{
	public:
	Manager(pp::Instance * instance, pp::Core * core):
	instance(instance),
	core(core),
	factory(this){
	next = 2;
	}

	pp::Instance * instance;
	pp::Core * core;
	Util::ReferenceCount<NaclRequest> request;
	pp::CompletionCallbackFactory<Manager> factory;

	- map<int, Util::ReferenceCount<FileHandle> > fileTable;
	-
	int next;

	struct OpenFileData{
	const char * path;
	- int file;
	+ Util::ReferenceCount<FileHandle> file;
	};

	struct ExistsData{
	const char * path;
	bool exists;
	};

	- struct ReadFileData{
	- int file;
	- void * buffer;
	- /* how much to read */
	- int count;
	- /* how much was read */
	- int read;
	- };
	-
	struct CloseFileData{
	int fd;
	};

	OpenFileData openFileData;
	- ReadFileData readFileData;
	CloseFileData closeFileData;
	ExistsData existsData;

	Util::Thread::LockObject lock;
	volatile bool done;

	- int openFile(const char * path){
	+ Util::ReferenceCount<FileHandle> openFile(const char * path){
	Global::debug(1, CONTEXT) << "open " << path << std::endl;
	Util::Thread::ScopedLock scoped(lock);
	done = false;
	openFileData.path = path;
	- openFileData.file = -1;
	pp::CompletionCallback callback(&Manager::doOpenFile, this);
	core->CallOnMainThread(0, callback, 0);
	lock.wait(done);
	return openFileData.file;
	}

	bool exists(const string & path){
	Global::debug(1, CONTEXT) << "exists " << path << std::endl;
	Util::Thread::ScopedLock scoped(lock);
	done = false;
	existsData.exists = false;
	existsData.path = path.c_str();
	pp::CompletionCallback callback(&Manager::doExists, this);
	core->CallOnMainThread(0, callback, 0);
	lock.wait(done);
	return existsData.exists;
	}

	- off_t lseek(int fd, off_t offset, int whence){
	- Global::debug(2, CONTEXT) << "seek fd " << fd << " offset " << offset << " whence " << whence << std::endl;
	- Util::Thread::ScopedLock scoped(lock);
	- if (fileTable.find(fd) == fileTable.end()){
	- return -1;
	- }
	-
	- Util::ReferenceCount<FileHandle> handle = fileTable[fd];
	- return handle->seek(offset, whence);
	- }
	-
	- int close(int fd){
	- Util::Thread::ScopedLock scoped(lock);
	- if (fileTable.find(fd) == fileTable.end()){
	- return -1;
	- /* set errno to EBADF */
	- }
	-
	- done = false;
	- closeFileData.fd = fd;
	-
	- pp::CompletionCallback callback(&Manager::doCloseFile, this);
	- core->CallOnMainThread(0, callback, 0);
	- lock.wait(done);
	- return 0;
	- }
	-
	- static void doCloseFile(void * self, int32_t result){
	- Manager * manager = (Manager*) self;
	- manager->continueCloseFile();
	- }
	-
	- /* the destructor for the NaclRequestOpen has to occur in the main thread */
	- void continueCloseFile(){
	- fileTable.erase(fileTable.find(closeFileData.fd));
	- requestComplete();
	- }
	-
	- ssize_t readFile(int fd, void * buffer, size_t count){
	- Util::Thread::ScopedLock scoped(lock);
	- if (fileTable.find(fd) == fileTable.end()){
	- return EBADF;
	- }
	-
	- /* dont need to sleep on a condition variable because we are
	- * in the game thread.
	- */
	-
	- Util::ReferenceCount<FileHandle> handle = fileTable[fd];
	- return handle->read(buffer, count);
	-
	- /*
	- done = false;
	- readFileData.file = fd;
	- readFileData.buffer = buffer;
	- readFileData.count = count;
	- readFileData.read = 0;
	- pp::CompletionCallback callback(&Manager::doReadFile, this);
	- core->CallOnMainThread(0, callback, 0);
	- lock.wait(done);
	- return readFileData.read;
	- */
	- }
	-
	- static void doReadFile(void * self, int32_t result){
	- Manager * manager = (Manager*) self;
	- manager->continueReadFile();
	- }
	-
	- void continueReadFile(){
	- /* hack to get the open request.. */
	- Util::ReferenceCount<FileHandle> open = fileTable[readFileData.file];
	- request = new NaclRequestRead(open->getLoader(), this, readFileData.buffer, readFileData.count);
	- request->start();
	- }
	-
	static void doExists(void * self, int32_t result){
	Manager * manager = (Manager*) self;
	manager->continueExists();
	}

	void continueExists(){
	request = new NaclRequestExists(instance, existsData.path, this);
	request->start();
	}

	void success(NaclRequestExists & exists){
	existsData.exists = true;
	requestComplete();
	}

	void failure(NaclRequestExists & exists){
	existsData.exists = false;
	requestComplete();
	}

	/* called by the main thread */
	static void doOpenFile(void * self, int32_t result){
	Manager * manager = (Manager*) self;
	manager->continueOpenFile();
	}

	void continueOpenFile(){
	request = new NaclRequestOpen(instance, openFileData.path, this);
	request->start();
	}

	- int nextFileDescriptor(){
	- int n = next;
	- next += 1;
	- return n;
	- }
	-
	void requestComplete(){
	- /* delete the reference counted request object in the main thread */
	+ /* destroy request on the main thread */
	request = NULL;
	lock.lockAndSignal(done, true);
	}

	void success(NaclRequestOpen & open){
	pp::URLResponseInfo info = open.loader.GetResponseInfo();
	if (info.GetStatusCode() == 200){
	Global::debug(1) << "Opened file" << std::endl;
	/*
	int64_t received = 0;
	int64_t total = 0;
	if (open.loader.GetDownloadProgress(&received, &total)){
	Global::debug(0) << "Downloaded " << received << " total " << total << std::endl;
	}
	*/
	+ Util::ReferenceCount<FileHandle> handle = new FileHandle();
	+ pp::CompletionCallback callback(&Manager::completeRead, this);
	+ openFileData.file = handle;
	+ handle->readAll(callback, core, open.loader);
	+ /*
	openFileData.file = nextFileDescriptor();
	fileTable[openFileData.file] = new FileHandle(request.convert<NaclRequestOpen>());
	readEntireFile(fileTable[openFileData.file]);
	+ */
	} else {
	Global::debug(1) << "Could not open file" << std::endl;
	- openFileData.file = -1;
	requestComplete();
	}
	}

	- void readEntireFile(Util::ReferenceCount<FileHandle> & file){
	- pp::CompletionCallback callback(&Manager::completeRead, this);
	- file->readAll(callback, core);
	- }
	-
	static void completeRead(void * self, int32_t result){
	Manager * manager = (Manager*) self;
	manager->requestComplete();
	}

	void failure(NaclRequestOpen & open){
	- openFileData.file = -1;
	- requestComplete();
	- }
	-
	- void success(NaclRequestRead & request, int read){
	- readFileData.read = read;
	requestComplete();
	}
	};

	void NaclRequestOpen::finish(int32_t result){
	if (result == 0){
	manager->success(*this);
	} else {
	manager->failure(*this);
	}
	}

	void NaclRequestExists::finish(int32_t result){
	if (result == 0){
	pp::URLResponseInfo info = loader.GetResponseInfo();
	if (info.GetStatusCode() == 200){
	manager->success(*this);
	} else {
	manager->failure(*this);
	}
	} else {
	manager->failure(*this);
	}
	}

	-void NaclRequestRead::finish(int32_t result){
	- manager->success(*this, result);
	-}
	-
	NetworkSystem::NetworkSystem(pp::Instance * instance, pp::Core * core):
	instance(instance),
	-manager(new Manager(instance, core)){
	+core(core){
	}

	NetworkSystem::~NetworkSystem(){
	}

	AbsolutePath NetworkSystem::find(const RelativePath & path){
	AbsolutePath all = Util::getDataPath2().join(path);
	if (exists(all)){
	return all;
	}
	throw Storage::NotFound(__FILE__, __LINE__, path.path());
	}

	RelativePath NetworkSystem::cleanse(const AbsolutePath & path){
	string str = path.path();
	if (str.find(Util::getDataPath2().path()) == 0){
	str.erase(0, Util::getDataPath2().path().length());
	} else if (str.find(userDirectory().path()) == 0){
	str.erase(0, userDirectory().path().length());
	}
	return RelativePath(str);
	}

	bool NetworkSystem::exists(const RelativePath & path){
	try{
	AbsolutePath absolute = find(path);
	return true;
	} catch (const Storage::NotFound & found){
	return false;
	}
	}

	bool NetworkSystem::exists(const AbsolutePath & path){
	Util::Thread::ScopedLock scoped(lock);
	if (existsCache.find(path) != existsCache.end()){
	return existsCache[path];
	}
	- bool what = manager->exists(path.path());
	+ Manager manager(instance, core);
	+ bool what = manager.exists(path.path());
	existsCache[path] = what;
	return what;
	}

	string NetworkSystem::readFileAsString(const AbsolutePath & path){
	if (!exists(path)){
	ostringstream fail;
	fail << "Could not read " << path.path();
	throw Filesystem::NotFound(__FILE__, __LINE__, fail.str());
	}
	ostringstream buffer;
	ifstream input(path.path().c_str());
	char stuff[1024];
	while (input.good()){
	input.read(stuff, sizeof(stuff) - 1);
	stuff[sizeof(stuff) - 1] = '\0';
	buffer << stuff;
	}
	return buffer.str();
	}

	static vector<string> split(string input, char splitter){
	vector<string> all;
	size_t found = input.find(splitter);
	while (found != string::npos){
	all.push_back(input.substr(0, found));
	input.erase(0, found + 1);
	found = input.find(splitter);
	}
	if (input.size() != 0){
	all.push_back(input);
	}
	return all;
	}

	vector<AbsolutePath> NetworkSystem::readDirectory(const AbsolutePath & dataPath){
	/* assume existence of 'directory.txt' in the given directory */
	AbsolutePath fullPath = dataPath.join(RelativePath("directory.txt"));
	string all = readFileAsString(fullPath);
	vector<string> files = split(all, '\n');
	vector<AbsolutePath> paths;
	for (vector<string>::iterator it = files.begin(); it != files.end(); it++){
	string what = *it;
	paths.push_back(dataPath.join(RelativePath(what)));
	}
	return paths;
	}

	/* check if 'foo/bar/baz.txt' matches .txt /
	static bool matchFile(const AbsolutePath & path, const string & find, bool insensitive = false){
	string file = path.getFilename().path();
	unsigned int index = 0;
	while (index < file.size()){
	if (index >= find.size()){
	return false;
	}
	if (find[index] == '*'){
	return true;
	}
	if (insensitive){
	if (tolower(find[index]) != tolower(file[index])){
	return false;
	}
	} else {
	if (find[index] != file[index]){
	return false;
	}
	}
	index += 1;
	}
	return true;
	}

	std::vector<AbsolutePath> NetworkSystem::getFiles(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive){
	vector<AbsolutePath> files = readDirectory(dataPath);
	vector<AbsolutePath> paths;
	for (vector<AbsolutePath>::iterator it = files.begin(); it != files.end(); it++){
	AbsolutePath check = *it;
	if (matchFile(check, find)){
	paths.push_back(check);
	}
	}
	return paths;
	}

	std::vector<AbsolutePath> NetworkSystem::getFilesRecursive(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive){
	vector<AbsolutePath> files = readDirectory(dataPath);
	vector<AbsolutePath> paths;
	for (vector<AbsolutePath>::iterator it = files.begin(); it != files.end(); it++){
	AbsolutePath check = *it;
	if (matchFile(check, find)){
	paths.push_back(check);
	}

	vector<AbsolutePath> more = getFilesRecursive(check, find, caseInsensitive);
	paths.insert(paths.end(), more.begin(), more.end());
	}
	return paths;
	}

	AbsolutePath NetworkSystem::configFile(){
	return AbsolutePath("paintownrc");
	}

	AbsolutePath NetworkSystem::userDirectory(){
	return AbsolutePath("paintown-user");
	}

	std::vector<AbsolutePath> NetworkSystem::findDirectories(const RelativePath & path){
	vector<AbsolutePath> files = readDirectory(find(path));
	vector<AbsolutePath> paths;
	for (vector<AbsolutePath>::iterator it = files.begin(); it != files.end(); it++){
	AbsolutePath check = *it;
	try{
	/* if we can read directory contents then its a directory */
	vector<AbsolutePath> more = readDirectory(check);
	paths.push_back(check);
	} catch (const Filesystem::NotFound & fail){
	}
	}
	return paths;

	}

	AbsolutePath NetworkSystem::findInsensitive(const RelativePath & path){
	try{
	/* try sensitive lookup first */
	return find(path);
	} catch (const Filesystem::NotFound & fail){
	}
	/* get the base directory */
	AbsolutePath directory = find(path.getDirectory());
	return lookupInsensitive(directory, path.getFilename());

	}

	AbsolutePath NetworkSystem::lookupInsensitive(const AbsolutePath & directory, const RelativePath & path){
	vector<AbsolutePath> files = readDirectory(directory);
	vector<AbsolutePath> paths;
	for (vector<AbsolutePath>::iterator it = files.begin(); it != files.end(); it++){
	AbsolutePath check = *it;
	if (matchFile(check, path.path(), true)){
	return check;
	}
	}
	ostringstream out;
	out << "Cannot find " << path.path() << " in " << directory.path();
	throw Filesystem::NotFound(__FILE__, __LINE__, out.str());
	}
	-
	+
	+int nextFileDescriptor(){
	+ static int next = 3;
	+ int n = next;
	+ next += 1;
	+ return n;
	+}
	+
	int NetworkSystem::libcOpen(const char * path, int mode, int params){
	+ Manager manager(instance, core);
	+ Util::ReferenceCount<FileHandle> handle = manager.openFile(path);
	Util::Thread::ScopedLock scoped(lock);
	- return manager->openFile(path);
	+ int file = nextFileDescriptor();
	+ fileTable[file] = handle;
	+ return file;
	}

	-ssize_t NetworkSystem::libcRead(int fd, void * buf, size_t count){
	+ssize_t NetworkSystem::libcRead(int fd, void * buffer, size_t count){
	Util::Thread::ScopedLock scoped(lock);
	- return manager->readFile(fd, buf, count);
	+ if (fileTable.find(fd) == fileTable.end()){
	+ return EBADF;
	+ }
	+
	+ Util::ReferenceCount<FileHandle> handle = fileTable[fd];
	+ return handle->read(buffer, count);
	}

	int NetworkSystem::libcClose(int fd){
	Util::Thread::ScopedLock scoped(lock);
	- return manager->close(fd);
	+ if (fileTable.find(fd) == fileTable.end()){
	+ return -1;
	+ /* set errno to EBADF */
	+ }
	+
	+ fileTable.erase(fileTable.find(fd));
	+ return 0;
	}

	off_t NetworkSystem::libcLseek(int fd, off_t offset, int whence){
	+ Global::debug(2, CONTEXT) << "seek fd " << fd << " offset " << offset << " whence " << whence << std::endl;
	Util::Thread::ScopedLock scoped(lock);
	- return manager->lseek(fd, offset, whence);
	+ if (fileTable.find(fd) == fileTable.end()){
	+ return -1;
	+ }
	+
	+ Util::ReferenceCount<FileHandle> handle = fileTable[fd];
	+ return handle->seek(offset, whence);
	}

	}

	/* NOTE FIXME Missing I/O in Native Client */

	Nacl::NetworkSystem & getSystem(){
	return (Nacl::NetworkSystem&) Storage::instance();
	}

	extern "C" {

	/* http://sourceware.org/binutils/docs-2.21/ld/Options.html#index-g_t_002d_002dwrap_003d_0040var_007bsymbol_007d-261
	* --wrap=symbol
	* Use a wrapper function for symbol. Any undefined reference to symbol will be resolved to __wrap_symbol. Any undefined reference to __real_symbol will be resolved to symbol.
	*/
	int __wrap_open(const char * path, int mode, int params){
	return getSystem().libcOpen(path, mode, params);
	}

	ssize_t __wrap_read(int fd, void * buf, size_t count){
	return getSystem().libcRead(fd, buf, count);
	}

	extern int __real_close(int fd);

	int __wrap_close(int fd){
	/* we may be given a file descriptor that we do not own, probably
	* because some file descriptors are really tied to sockets so
	* if we don't own the fd then pass it to the real close function.
	*/
	int ok = getSystem().libcClose(fd);
	if (ok == -1){
	return __real_close(fd);
	}
	return ok;
	}

	off_t __wrap_lseek(int fd, off_t offset, int whence){
	return getSystem().libcLseek(fd, offset, whence);
	}

	int pipe (int filedes[2]){
	return -1;
	}

	int mkdir (const char *filename, mode_t mode){
	return -1;
	}

	int access(const char *filename, int how){
	return -1;
	}

	char * getcwd (char *buffer, size_t size){
	return NULL;
	}

	int lstat (const char path, struct stat buf){
	return -1;
	}

	int rmdir (const char *filename){
	return -1;
	}

	int chdir (const char *filename){
	return -1;
	}

	int setuid (uid_t newuid){
	return 0;
	}

	int seteuid (uid_t uid){
	return 0;
	}

	uid_t geteuid (void){
	return NULL;
	}

	int setgid (gid_t gid){
	return 0;
	}

	gid_t getgid (void){
	return NULL;
	}

	int setegid (gid_t gid){
	return 0;
	}

	gid_t getegid (void){
	return NULL;
	}

	char * getlogin (void){
	return NULL;
	}

	uid_t getuid(void){
	return NULL;
	}

	struct passwd * getpwuid (uid_t uid){
	return NULL;
	}

	struct passwd * getpwnam (const char *name){
	return NULL;
	}

	struct group * getgrnam(const char *name){
	return NULL;
	}

	struct group * getgrgid(gid_t gid){
	return NULL;
	}

	int link (const char oldname, const char newname){
	return -1;
	}

	int unlink (const char *filename){
	return -1;
	}

	int kill(pid_t pid, int sig){
	return -1;
	}

	}

	#endif
	diff --git a/util/nacl/network-system.h b/util/nacl/network-system.h
	index 7ecbf88f..851c9848 100644
	--- a/util/nacl/network-system.h
	+++ b/util/nacl/network-system.h
	@@ -1,64 +1,68 @@
	#ifndef _paintown_network_system_h
	#define _paintown_network_system_h

	#ifdef NACL

	#include <map>
	#include <string>
	#include <vector>
	#include "../file-system.h"
	#include "../thread.h"
	#include "../pointer.h"

	namespace pp{
	class Instance;
	class Core;
	}

	namespace Nacl{

	typedef Path::AbsolutePath AbsolutePath;
	typedef Path::RelativePath RelativePath;

	class Manager;
	+class FileHandle;
	+
	class NetworkSystem: public Storage::System {
	public:
	NetworkSystem(pp::Instance * instance, pp::Core * core);
	virtual ~NetworkSystem();

	virtual AbsolutePath find(const RelativePath & path);
	virtual RelativePath cleanse(const AbsolutePath & path);
	virtual bool exists(const RelativePath & path);
	virtual bool exists(const AbsolutePath & path);
	virtual std::vector<AbsolutePath> getFilesRecursive(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive = false);
	virtual std::vector<AbsolutePath> getFiles(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive = false);
	virtual AbsolutePath configFile();
	virtual AbsolutePath userDirectory();
	virtual std::vector<AbsolutePath> findDirectories(const RelativePath & path);
	virtual AbsolutePath findInsensitive(const RelativePath & path);
	virtual AbsolutePath lookupInsensitive(const AbsolutePath & directory, const RelativePath & path);

	public:
	int libcOpen(const char * path, int mode, int params);
	ssize_t libcRead(int fd, void * buf, size_t count);
	int libcClose(int fd);
	off_t libcLseek(int fd, off_t offset, int whence);

	protected:
	std::string readFileAsString(const AbsolutePath & path);
	std::vector<AbsolutePath> readDirectory(const AbsolutePath & dataPath);

	protected:
	pp::Instance * instance;
	pp::Core * core;
	/* only one thread at a time to access the network system */
	Util::Thread::LockObject lock;
	- Util::ReferenceCount<Manager> manager;
	+ // Util::ReferenceCount<Manager> manager;
	std::map<AbsolutePath, bool> existsCache;
	+ std::map<int, Util::ReferenceCount<FileHandle> > fileTable;
	+
	};

	}

	#endif

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 11, 10:18 AM (3 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 68353
Default Alt Text: (66 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions