No OneTemporary
Actions

Authored By

Unknown

Size

18 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/funcs.cpp b/util/funcs.cpp
	index e686f387..90e38cdd 100644
	--- a/util/funcs.cpp
	+++ b/util/funcs.cpp
	@@ -1,242 +1,251 @@
	#ifdef USE_ALLEGRO
	#include <allegro.h>
	#endif
	#ifdef USE_SDL
	#include <SDL.h>
	#endif
	#include "funcs.h"
	#include "globals.h"
	#include <vector>
	#include <string>
	#include <string.h>
	#include "file-system.h"
	#include "bitmap.h"

	#ifndef USE_ALLEGRO
	/* FIXME: move this to the filesystem module */
	#include "sfl/sfl.h"
	#include "sfl/sflfile.h"
	#endif

	#ifndef WINDOWS
	#include <unistd.h>
	#endif

	#ifdef max
	#undef max
	#endif

	#ifdef min
	#undef min
	#endif

	using namespace std;

	/* remove this once cmake and scons properly set DATA_PATH */
	#ifndef DATA_PATH
	#define DATA_PATH "data"
	#endif

	/* the build system should define DATA_PATH */
	static string dataPath = DATA_PATH;

	const double Util::pi = 3.14159265;

	double Util::radians(double degree){
	return degree * pi / 180.0;
	}

	/*
	inline int rnd( int q ){
	if ( q <= 0 ) return 0;
	return (int)( rand() % q );
	}
	*/

	int Util::max(int a, int b){
	if (a>b){
	return a;
	}
	return b;
	}

	/*
	int Util::min(int a, int b){
	if (a<b){
	return a;
	}
	return b;
	}
	*/

	int Util::rnd( int q, int min, int range ){
	return q - min + rnd( range );
	}

	int Util::rnd( int min, int max ){
	return rnd( max - min ) + min;
	}

	/* sleep for `x' milliseconds */
	void Util::rest( int x ){
	#ifdef USE_ALLEGRO
	::rest(x);
	#endif
	#ifdef USE_SDL
	SDL_Delay(x);
	#endif
	}

	void Util::restSeconds(double x){
	Util::rest((int)(x * 1000));
	}

	bool Util::checkVersion(int version){
	if (version == Global::getVersion()){
	return true;
	}

	/* when an incompatible version is made, add a check here, like
	* version < getVersion(3, 5)
	* would mean any client below version 3.5 is incompatible.
	*
	* assume versions of client's greater than ourself is compatible, but
	* this may not be true. There is no way to check this.
	*/
	if (version < 0){
	return false;
	}

	return true;
	}

	void Util::setDataPath( const string & str ){
	dataPath = str;
	}

	Filesystem::AbsolutePath Util::getDataPath2(){
	return Filesystem::AbsolutePath(dataPath + "/");
	}

	bool Util::exists( const string & file ){
	#ifdef USE_ALLEGRO
	return ::exists(file.c_str()) != 0;
	#else
	return file_exists(file.c_str());
	#endif
	}

	vector< string > Util::getFiles(const Filesystem::AbsolutePath & dataPath, const string & find){
	return Filesystem::getFiles(dataPath, find);
	}

	void Util::blend_palette(int * pal, int mp, int startColor, int endColor ) {
	/*
	ASSERT(pal);
	ASSERT(mp != 0);
	*/

	int sc_r = Bitmap::getRed(startColor);
	int sc_g = Bitmap::getGreen(startColor);
	int sc_b = Bitmap::getBlue(startColor);

	int ec_r = Bitmap::getRed(endColor);
	int ec_g = Bitmap::getGreen(endColor);
	int ec_b = Bitmap::getBlue(endColor);

	for ( int q = 0; q < mp; q++ ) {
	float j = (float)( q + 1 ) / (float)( mp );
	int f_r = (int)( 0.5 + (float)( sc_r ) + (float)( ec_r-sc_r ) * j );
	int f_g = (int)( 0.5 + (float)( sc_g ) + (float)( ec_g-sc_g ) * j );
	int f_b = (int)( 0.5 + (float)( sc_b ) + (float)( ec_b-sc_b ) * j );
	pal[q] = Bitmap::makeColor( f_r, f_g, f_b );
	}
	}

	string Util::trim(const std::string & str){
	string s;
	size_t startpos = str.find_first_not_of(" \t");
	size_t endpos = str.find_last_not_of(" \t");
	// if all spaces or empty return an empty string
	if ((string::npos == startpos) \|\|
	(string::npos == endpos)){
	return "";
	} else {
	return str.substr(startpos, endpos-startpos+1);
	}
	return str;
	}

	/* makes the first letter of a string upper case */
	string Util::upcase(std::string str){
	if ( str.length() > 0 && (str[0] >= 'a' && str[0] <= 'z') ){
	str[0] = str[0] - 'a' + 'A';
	}
	return str;
	}

	+string Util::lowerCaseAll(std::string str){
	+ for (int i = 0; i < str.length(); i++){
	+ if (str[0] >= 'A' && str[0] <= 'Z'){
	+ str[0] = str[0] - 'A' + 'a';
	+ }
	+ }
	+ return str;
	+}
	+
	/Gets the minimum of three values/
	static int minimum(int a,int b,int c){
	int min=a;
	if(b<min)
	min=b;
	if(c<min)
	min=c;
	return min;
	}

	/* Compute levenshtein distance between s and t
	* from: http://www.merriampark.com/ldc.htm
	*/
	static int levenshtein_distance(const char s, const char t){
	//Step 1
	int k,i,j,n,m,cost,distance;
	int * d;
	n=strlen(s);
	m=strlen(t);
	if(n!=0&&m!=0){
	d = (int) malloc((sizeof(int))(m+1)*(n+1));
	m++;
	n++;
	//Step 2
	for(k=0;k<n;k++)
	d[k]=k;
	for(k=0;k<m;k++)
	d[k*n]=k;
	//Step 3 and 4
	for(i=1;i<n;i++)
	for(j=1;j<m;j++)
	{
	//Step 5
	if(s[i-1]==t[j-1])
	cost=0;
	else
	cost=1;
	//Step 6
	d[jn+i]=minimum(d[(j-1)n+i]+1,d[jn+i-1]+1,d[(j-1)n+i-1]+cost);
	}
	distance=d[n*m-1];
	free(d);
	return distance;
	} else {
	return -1; //a negative return value means that one or both strings are empty.
	}
	}

	int Util::levenshtein(const std::string & str1, const std::string & str2){
	return levenshtein_distance(str1.c_str(), str2.c_str());
	}

	void Util::limitPrintf(char * buffer, int size, const char * format, va_list args){
	#ifdef USE_ALLEGRO
	uvszprintf(buffer, size, format, args);
	#else
	vsnprintf(buffer, size, format, args);
	#endif
	}

	#ifndef WINDOWS
	int Util::getPipe(int files[2]){
	return pipe(files);
	}
	#endif
	diff --git a/util/funcs.h b/util/funcs.h
	index dcd36f1e..280aa8ae 100644
	--- a/util/funcs.h
	+++ b/util/funcs.h
	@@ -1,77 +1,78 @@
	#ifndef _paintown_funcs_h
	#define _paintown_funcs_h

	#include <stdlib.h>
	#include <vector>
	#include <string>
	#include <stdarg.h>

	#include "regex.h"
	#include "file-system.h"

	namespace Util{

	extern const double pi;


	/* returns a number between 0 and q-1. you will never get `q'. if
	* you wanted to get `q' then pass in q+1
	*/
	inline int rnd( int q ){
	if (q <= 0){
	return 0;
	}

	return (int)(rand() % q);
	}

	std::vector< std::string > getFiles(const Filesystem::AbsolutePath & dataPath, const std::string & find );

	double radians(double degree);

	Filesystem::AbsolutePath getDataPath2();

	void setDataPath( const std::string & str );

	bool exists( const std::string & file );

	/* check that `version' is compatible with this program, mostly used
	* for network clients.
	*/
	bool checkVersion(int version);

	/* return a random number + some range between min/max */
	int rnd( int q, int min, int max );

	int max(int a, int b);

	inline int min(int a, int b){
	if (a<b){
	return a;
	}
	return b;
	}

	/* return a number between min/max */
	int rnd( int min, int max );

	void blend_palette( int * pal, int mp, int sc, int ec );

	/* rest in milliseconds */
	void rest( int x );

	/* rest in seconds */
	void restSeconds(double x);

	std::string trim(const std::string & str);
	std::string upcase(std::string str);
	+std::string lowerCaseAll(std::string str);

	int levenshtein(const std::string & str1, const std::string & str2);

	int getPipe(int files[2]);

	void limitPrintf(char * buffer, int size, const char * format, va_list args);

	}

	#endif
	diff --git a/util/music-player.cpp b/util/music-player.cpp
	index a4009923..33b0f16c 100644
	--- a/util/music-player.cpp
	+++ b/util/music-player.cpp
	@@ -1,334 +1,358 @@
	#ifdef USE_ALLEGRO
	#include <allegro.h>
	#endif
	#include "music-player.h"
	#include "globals.h"
	#include <iostream>
	#include "configuration.h"
	#include "sound.h"

	#include "dumb/include/dumb.h"
	#include "gme/Music_Emu.h"

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

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

	#endif

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

	namespace Util{

	static double scaleVolume(double start){
	return start * Configuration::getMusicVolume() / 100;
	}

	MusicPlayer::MusicPlayer(){
	}

	MusicPlayer::~MusicPlayer(){
	}

	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 "";
	}
	}

	DUH * DumbPlayer::loadDumbFile(const char * 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);
	break;
	}
	case 1 : {
	what = dumb_load_s3m_quick(path);
	break;
	}
	case 2 : {
	what = dumb_load_it_quick(path);
	break;
	}
	case 3 : {
	what = dumb_load_mod_quick(path);
	break;
	}
	}

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

	#ifdef USE_ALLEGRO

	DumbPlayer::DumbPlayer(const char * path):
	volume(1.0){
	music_file = loadDumbFile(path);
	if (music_file != NULL){
	int buf = 1 << 11;
	player = al_start_duh(music_file, 2, 0, scaleVolume(volume), buf, Sound::FREQUENCY);
	}
	}

	void DumbPlayer::play(){
	al_resume_duh(this->player);
	}

	void DumbPlayer::poll(){
	if (al_poll_duh(this->player) != 0){
	}
	}

	void DumbPlayer::pause(){
	al_pause_duh(this->player);
	}

	void DumbPlayer::setVolume(double volume){
	this->volume = volume;
	al_duh_set_volume(player, scaleVolume(volume));
	}

	DumbPlayer::~DumbPlayer(){
	al_stop_duh(player);
	unload_duh(music_file);
	}

	static const int GME_BUFFER_SIZE = 1 << 11;
	GMEPlayer::GMEPlayer(const char * path):
	volume(1.0){
	gme_err_t fail = gme_open_file(path, &emulator, Sound::FREQUENCY);
	if (fail != NULL){
	Global::debug(0) << "GME load error for " << path << ": " << fail << std::endl;
	throw std::exception();
	}
	emulator->start_track(0);
	Global::debug(0) << "Loaded GME file " << path << std::endl;

	stream = play_audio_stream(GME_BUFFER_SIZE, 16, 1, Sound::FREQUENCY, 255, 128);
	voice_set_priority(stream->voice, 255);
	}

	void GMEPlayer::play(){
	voice_start(stream->voice);
	}

	void GMEPlayer::poll(){
	short * buffer = (short*) get_audio_stream_buffer(stream);
	if (buffer){
	/* size in 16-bit samples is buffer size * channels */
	emulator->play(GME_BUFFER_SIZE * 2, buffer);
	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);
	}
	}

	/* 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 < GME_BUFFER_SIZE * 2; i++){
	buffer[i] += 0x8000;
	}

	free_audio_stream_buffer(stream);
	}
	}

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

	void GMEPlayer::setVolume(double volume){
	/* FIXME */
	}

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

	#endif

	#ifdef USE_SDL
	DumbPlayer::DumbPlayer(const char * path):
	volume(1.0){
	music_file = loadDumbFile(path);
	if (music_file == NULL){
	/* FIXME */
	throw std::exception();
	}

	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 std::exception();
	}
	}

	void DumbPlayer::render(Uint8 * stream, int length){
	double delta = 65536.0 / Sound::FREQUENCY;

	/* a frame is 32 bits, 16 bit samples with 2 channels = 2 * 16,
	* so we have to divide the number of 'dumb samples' by the
	* size of each frame, 32 bits = 4 bytes
	*/
	/* FIXME: use global music volume to scale the output here */
	int n = duh_render(renderer, 16, 0, volume, delta, length / 4, stream);

	if (n == 0){
	Global::debug(0) << "Sound finished?" << std::endl;
	}

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

	struct DumbPlayerInfo{
	MusicPlayer * who;
	};

	void DumbPlayer::mixer(void * player_, Uint8 * stream, int length){
	DumbPlayerInfo * info = (DumbPlayerInfo *) player_;
	DumbPlayer * player = (DumbPlayer *) info->who;
	player->render(stream, length);
	}

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

	void DumbPlayer::play(){
	DumbPlayerInfo * me = new DumbPlayerInfo;
	me->who = this;
	Mix_HookMusic(mixer, me);
	}

	void DumbPlayer::poll(){
	}

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

	DumbPlayer::~DumbPlayer(){
	DumbPlayerInfo * info = (DumbPlayerInfo*) Mix_GetMusicHookData();
	Mix_HookMusic(NULL, NULL);
	if (info != NULL){
	delete info;
	}
	/* I'm pretty sure if we get this far then there is no chance
	* that our mixer function will still be active.
	*/
	duh_end_sigrenderer(renderer);
	unload_duh(music_file);
	}

	struct GMEInfo{
	GMEPlayer * player;
	};

	GMEPlayer::GMEPlayer(const char * path):
	volume(1.0){
	gme_err_t fail = gme_open_file(path, &emulator, Sound::FREQUENCY);
	if (fail != NULL){
	Global::debug(0) << "GME load error for " << path << ": " << fail << std::endl;
	throw std::exception();
	}
	emulator->start_track(0);
	Global::debug(0) << "Loaded GME file " << path << std::endl;
	}

	void GMEPlayer::mixer(void * arg, Uint8 * stream, int length){
	GMEInfo * info = (GMEInfo*) arg;
	info->player->render(stream, length);
	}

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

	/*
	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::play(){
	GMEInfo * me = new GMEInfo;
	me->player = this;
	Mix_HookMusic(mixer, me);
	}

	void GMEPlayer::poll(){
	}

	void GMEPlayer::pause(){
	}

	void GMEPlayer::setVolume(double volume){
	}

	GMEPlayer::~GMEPlayer(){
	GMEInfo * info = (GMEInfo*) Mix_GetMusicHookData();
	Mix_HookMusic(NULL, NULL);
	if (info != NULL){
	delete info;
	}
	delete emulator;
	}
	+
	+OggPlayer::OggPlayer(const char * path){
	+ music = Mix_LoadMUS(path);
	+}
	+
	+void OggPlayer::play(){
	+ Mix_PlayMusic(music, -1);
	+}
	+
	+void OggPlayer::poll(){
	+}
	+
	+void OggPlayer::pause(){
	+ Mix_PauseMusic();
	+}
	+
	+void OggPlayer::setVolume(double volume){
	+ Mix_VolumeMusic(volume * MIX_MAX_VOLUME);
	+}
	+
	+OggPlayer::~OggPlayer(){
	+ Mix_FreeMusic(music);
	+}
	+
	#endif

	}
	diff --git a/util/music-player.h b/util/music-player.h
	index c1f0789d..d9f66bd5 100644
	--- a/util/music-player.h
	+++ b/util/music-player.h
	@@ -1,98 +1,104 @@
	#ifndef _paintown_music_player_h
	#define _paintown_music_player_h

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

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

	namespace Util{

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

	/* uses the GME library, plays nintendo music files and others */
	class GMEPlayer: public MusicPlayer {
	public:
	GMEPlayer(const char * path);
	virtual void play();
	virtual void poll();
	virtual void pause();
	virtual void setVolume(double volume);
	virtual ~GMEPlayer();
	protected:
	#ifdef USE_SDL
	static void mixer(void * arg, Uint8 * stream, int length);
	void render(Uint8 * stream, int length);
	#endif
	#ifdef USE_ALLEGRO
	AUDIOSTREAM * stream;
	#endif
	double volume;
	Music_Emu * emulator;
	};

	#ifdef HAVE_OGG
	+/* Maybe have some common sdl mixer class that this can inherit? */
	class OggPlayer: public MusicPlayer {
	public:
	OggPlayer(const char * path);
	virtual void play();

	virtual void poll();
	virtual void pause();
	virtual void setVolume(double volume);

	virtual ~OggPlayer();
	+protected:
	+#if USE_SDL
	+ Mix_Music * music;
	+#endif
	};
	#endif

	/* interface to DUMB, plays mod/s3m/xm/it */
	class DumbPlayer: public MusicPlayer {
	public:
	DumbPlayer(const char * path);
	virtual void play();
	virtual void poll();
	virtual void pause();
	virtual void setVolume(double volume);

	virtual ~DumbPlayer();

	protected:
	DUH * loadDumbFile(const char * path);

	#ifdef USE_SDL
	static void mixer(void * player, Uint8 * stream, int length);
	void render(Uint8 * stream, int length);
	#endif

	protected:
	#ifdef USE_ALLEGRO
	AL_DUH_PLAYER * player;
	#endif
	DUH * music_file;

	#ifdef USE_SDL
	DUH_SIGRENDERER * renderer;
	#endif

	double volume;
	};

	}

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 11, 12:39 PM (3 w, 4 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 69072
Default Alt Text: (18 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions