[Scummvm-cvs-logs] CVS: scummvm/simon simonsound.cpp,NONE,1.1 simonsound.h,NONE,1.1 items.cpp,1.21,1.22 module.mk,1.1,1.2 simon.cpp,1.91,1.92 simon.h,1.20,1.21 vga.cpp,1.9,1.10

Oliver Kiehl olki at users.sourceforge.net
Sun Nov 24 04:54:02 CET 2002


Update of /cvsroot/scummvm/scummvm/simon
In directory sc8-pr-cvs1:/tmp/cvs-serv27620/simon

Modified Files:
	items.cpp module.mk simon.cpp simon.h vga.cpp 
Added Files:
	simonsound.cpp simonsound.h 
Log Message:
split simon sound


--- NEW FILE: simonsound.cpp ---
#include "simon/simonsound.h"
#include "common/file.h"
#include "common/engine.h"

enum {
	GAME_SIMON2 = 1,
	GAME_WIN = 2,
	GAME_TALKIE = 4,
	GAME_DEMO = 8,

	GAME_SIMON1DOS = 0,
	GAME_SIMON2DOS = GAME_SIMON2,
	GAME_SIMON1TALKIE = GAME_TALKIE,
	GAME_SIMON2TALKIE = GAME_SIMON2 + GAME_TALKIE,
	GAME_SIMON1WIN = GAME_WIN + GAME_TALKIE,
	GAME_SIMON2WIN = GAME_SIMON2 + GAME_WIN + GAME_TALKIE,
	GAME_SIMON1DEMO = GAME_DEMO,
};

SimonSound::SimonSound(const byte game, const GameSpecificSettings *gss, const char *gameDataPath, SoundMixer *mixer)
{
	_game = game;
	_mixer = mixer;
	
	_effects_paused = false;
	_ambient_paused = false;

	_voice_handle = 0;
	_effects_handle = 0;
	_ambient_handle = 0;

	_ambient_playing = 0;

	File *file = new File();
	File *file2 = new File();
	const char *s;

#ifdef USE_MAD
	file->open(gss->mp3_filename, gameDataPath);
	if (file->isOpen() == false) {
#endif
		if (_game & GAME_WIN) {
			s = gss->wav_filename;
			file->open(s, gameDataPath);
			if (file->isOpen() == false) {
				warning("Cannot open voice file %s", s);
			} else	{
				_voice = new WavSound(_mixer, file, gss->NUM_VOICE_RESOURCES);
			}
		} else if (_game & GAME_TALKIE) {
			s = gss->voc_filename;
			file->open(s, gameDataPath);
			if (file->isOpen() == false) {
				warning("Cannot open voice file %s", s);
			} else {
				_voice = new VocSound(_mixer, file, gss->NUM_VOICE_RESOURCES);
			}
		}
#ifdef USE_MAD
	} else {
		_voice = new MP3Sound(_mixer, file, gss->NUM_VOICE_RESOURCES);
	}
#endif

	if (_game == GAME_SIMON1TALKIE) {
#ifdef USE_MAD
		file2->open(gss->mp3_effects_filename, gameDataPath);
		if (file2->isOpen() == false) {
#endif
			s = gss->voc_effects_filename;
			file2->open(s, gameDataPath);
			if (file2->isOpen() == false) {
				warning("Cannot open effects file %s", s);
			} else {
				_effects = new VocSound(_mixer, file2, gss->NUM_VOICE_RESOURCES);
			}
#ifdef USE_MAD
		} else {
			_effects = new MP3Sound(_mixer, file2, gss->NUM_VOICE_RESOURCES);
		}
#endif
	}
}

void SimonSound::readSfxFile(const char *filename, const char *gameDataPath)
{
	stopAll();

	File *file = new File();
	file->open(filename, gameDataPath);

	if (file->isOpen() == false) {
		warning("readSfxFile: Cannot load sfx file %s", filename);
		return;
	}

	_effects = new WavSound(_mixer, file);
}

void SimonSound::loadSfxTable(File *gameFile, uint32 offs, int set) 
{
	if (!set)
		return;

	stopAll();

	if (_game & GAME_WIN)
		_effects = new WavSound(_mixer, gameFile, offs, set);
	else
		_effects = new VocSound(_mixer, gameFile, offs, set);
}

void SimonSound::playVoice(uint sound)
{
	if (!_voice)
		return;
	
	_voice->playSound(sound, &_voice_handle, 0);
}

void SimonSound::playEffects(uint sound)
{
	if (!_effects)
		return;
	
	if (_effects_paused)
		return;

	_effects->playSound(sound, &_effects_handle, 0);
}

void SimonSound::playAmbient(uint sound)
{
	if (!_effects)
		return;

	if (sound == _ambient_playing)
		return;

	_ambient_playing = sound;

	if (_ambient_paused)
		return;

	if (_ambient_handle)
		_mixer->stop(_ambient_index);

	_ambient_index = _effects->playSound(sound, &_ambient_handle, SoundMixer::FLAG_LOOP);
}

void SimonSound::stopAll()
{
	_mixer->stopAll();
	_ambient_playing = 0;
}

void SimonSound::effectsPause(bool b)
{
	_effects_paused = b;
}

void SimonSound::ambientPause(bool b)
{
	_ambient_paused = b;

	if (_ambient_paused && _ambient_playing) {
		_mixer->stop(_ambient_index);
	} else if (_ambient_playing) {
		uint tmp = _ambient_playing;
		_ambient_playing = 0;
		playAmbient(tmp);
	}
}

/******************************************************************************/

SimonSound::WavSound::WavSound(SoundMixer *mixer, File *file, uint resources)
{
	_mixer = mixer;
	_file = file;
	loadOffsets(resources);
}

SimonSound::WavSound::WavSound(SoundMixer *mixer, File *file) /* only used in simon1win */
{
	_mixer = mixer;
	_file = file;
	loadOffsets();
}

SimonSound::WavSound::WavSound(SoundMixer *mixer, File *file, uint32 offs, int set) /* only used in simon2 */
{
	_mixer = mixer;
	_file = file;
	loadOffsets(offs, set);
}

SimonSound::VocSound::VocSound(SoundMixer *mixer, File *file, uint resources)
{
	_mixer = mixer;
	_file = file;
	loadOffsets(resources);
}

SimonSound::VocSound::VocSound(SoundMixer *mixer, File *file, uint32 offs, int set) /* only used in simon2 */
{
	_mixer = mixer;
	_file = file;
	loadOffsets(offs, set);
}

#ifdef USE_MAD
SimonSound::MP3Sound::MP3Sound(SoundMixer *mixer, File *file, uint resources)
{
	_mixer = mixer;
	_file = file;

	_offsets = (uint32 *)malloc((resources + 1) * sizeof(uint32));

	if (_offsets == NULL)
		error("Out of memory for voice offsets");
	
	if (_file->read(_offsets, resources * sizeof(uint32)) != resources * sizeof(uint32))
		error("Cannot read offsets");

#ifdef SCUMM_BIG_ENDIAN
	for (uint i = 0; i < resources; i++)
		_offsets[i] = FROM_LE_32(_offsets[i]);
#endif
	_file->seek(0, SEEK_END);
	_offsets[resources] = _file->pos();
}
#endif

/******************************************************************************/

void SimonSound::Sound::loadOffsets(uint resources)
{
	_offsets = (uint32 *)malloc(resources * sizeof(uint32));

	if (_offsets == NULL)
		error("Out of memory for offsets");

	if (_file->read(_offsets, resources * sizeof(uint32)) != resources * sizeof(uint32))
		error("Cannot read offsets");

#ifdef SCUMM_BIG_ENDIAN
	for (uint i = 0; i < resources; i++)
		_offsets[i] = FROM_LE_32(_offsets[i]);
#endif
}

void SimonSound::Sound::loadOffsets()
{
	uint num = 0;

	uint32 size;

	_file->seek(4, SEEK_SET);
	size = _file->readUint32LE();

	num = size / sizeof(uint32);

	_offsets = (uint32 *)malloc(size);

	_file->seek(0, SEEK_SET);
	_file->read(_offsets, size);

#if defined(SCUMM_BIG_ENDIAN)
	for (uint r = 0; r < num; r++)
		_offsets[r] = FROM_LE_32(_offsets[r]);
#endif
}

void SimonSound::Sound::loadOffsets(uint32 offs, int set)
{
	int num_per_set[] = {0, 188, 223, 217, 209, 179, 187, 189, 116, 174, 203,
			173, 176, 38, 205, 134, 213, 212, 167, 141};

	uint num;
	uint i;

	num = num_per_set[set];

	if (num == 0)
		return;

	_offsets = (uint32 *)malloc(num * sizeof(uint32));

	_file->seek(offs, SEEK_SET);
	_file->read(_offsets, num * sizeof(uint32));

	for (i = 0; i < num; i++) {
#if defined(SCUMM_BIG_ENDIAN)
		_offsets[i] = FROM_LE_32(_offsets[i]);
#endif
		_offsets[i] += offs;
	}
}

/******************************************************************************/

#if !defined(__GNUC__)
#pragma START_PACK_STRUCTS
#endif

struct WaveHeader {
	uint32 riff;
	uint32 unk;
	uint32 wave;
	uint32 fmt;

	uint32 size;

	uint16 format_tag;
	uint16 channels;
	uint32 samples_per_sec;
	uint32 avg_bytes;

	uint16 block_align;
	uint16 bits_per_sample;
} GCC_PACK;

struct VocHeader {
	uint8 desc[20];
	uint16 datablock_offset;
	uint16 version;
	uint16 id;
} GCC_PACK;

struct VocBlockHeader {
	uint8 blocktype;
	uint8 size[3];
	uint8 sr;
	uint8 pack;
} GCC_PACK;

#if !defined(__GNUC__)
#pragma END_PACK_STRUCTS
#endif
	
#ifdef USE_MAD
int SimonSound::MP3Sound::playSound(uint sound, PlayingSoundHandle *handle, byte flags)
{
	if (_offsets == NULL)
		return 0;

	flags |= SoundMixer::FLAG_AUTOFREE;

	_file->seek(_offsets[sound], SEEK_SET);

	uint32 size = _offsets[sound+1] - _offsets[sound];

	byte *buffer = (byte *)malloc(size);
	_file->read(buffer, size);

	return _mixer->playMP3(handle, buffer, size, flags);
}
#endif

int SimonSound::VocSound::playSound(uint sound, PlayingSoundHandle *handle, byte flags)
{
	if (_offsets == NULL)
		return 0;

	VocHeader voc_hdr;
	VocBlockHeader voc_block_hdr;
	uint32 size;

	flags |= SoundMixer::FLAG_UNSIGNED|SoundMixer::FLAG_AUTOFREE;

	_file->seek(_offsets[sound], SEEK_SET);

	if (_file->read(&voc_hdr, sizeof(voc_hdr)) != sizeof(voc_hdr) ||
			strncmp((char *)voc_hdr.desc, "Creative Voice File\x1A", 10) != 0) {
		error("playVoc(%d): cannot read voc header", sound);
	}

	_file->read(&voc_block_hdr, sizeof(voc_block_hdr));

	size = voc_block_hdr.size[0] + (voc_block_hdr.size[1] << 8) + (voc_block_hdr.size[2] << 16) - 2;
	uint32 samples_per_sec;

	/* workaround for voc weakness */
	if (voc_block_hdr.sr == 0xa6) {
		samples_per_sec = 11025;
	} else if (voc_block_hdr.sr == 0xd2) {
		samples_per_sec = 22050;
	} else {
		samples_per_sec = 1000000L / (256L - (long)voc_block_hdr.sr);
		warning("inexact sample rate used: %i", samples_per_sec);
	}

	byte *buffer = (byte *)malloc(size);
	_file->read(buffer, size);

	return _mixer->playRaw(handle, buffer, size, samples_per_sec, flags);
}

int SimonSound::WavSound::playSound(uint sound, PlayingSoundHandle *handle, byte flags)
{
	if (_offsets == NULL)
		return 0;

	WaveHeader wave_hdr;
	uint32 data[2];

	flags |= SoundMixer::FLAG_UNSIGNED|SoundMixer::FLAG_AUTOFREE;

	_file->seek(_offsets[sound], SEEK_SET);

	if (_file->read(&wave_hdr, sizeof(wave_hdr)) != sizeof(wave_hdr) ||
			wave_hdr.riff != MKID('RIFF') || wave_hdr.wave != MKID('WAVE')
			|| wave_hdr.fmt != MKID('fmt ') || READ_LE_UINT16(&wave_hdr.format_tag) != 1
			|| READ_LE_UINT16(&wave_hdr.channels) != 1
			|| READ_LE_UINT16(&wave_hdr.bits_per_sample) != 8) {
		error("playWav(%d): cannot read RIFF header", sound);
	}

	_file->seek(FROM_LE_32(wave_hdr.size) - sizeof(wave_hdr) + 20, SEEK_CUR);

	data[0] = _file->readUint32LE();
	data[1] = _file->readUint32LE();
	if (//fread(data, sizeof(data), 1, sound_file) != 1 ||
			 data[0] != 'atad') {
		error("playWav(%d): cannot read data header", sound);
	}

	byte *buffer = (byte *)malloc(data[1]);
	_file->read(buffer, data[1]);

	return _mixer->playRaw(handle, buffer, data[1], FROM_LE_32(wave_hdr.samples_per_sec), flags);
}


--- NEW FILE: simonsound.h ---
#include "sound/mixer.h"
#include "simon/intern.h"

class SimonSound {
private:
	class Sound {
	protected:
		File *_file;
		uint32 *_offsets;
		SoundMixer *_mixer;

		void loadOffsets(uint resources);
		void loadOffsets();
		void loadOffsets(uint32 offs, int set);

	public:
		virtual int playSound(uint sound, PlayingSoundHandle *handle, byte flags) = 0;
	};


	class WavSound : public Sound {
	public:
		WavSound(SoundMixer *mixer, File *file, uint resources);
		WavSound(SoundMixer *mixer, File *file);
		WavSound(SoundMixer *mixer, File *file, uint32 offs, int set);

		int playSound(uint sound, PlayingSoundHandle *handle, byte flags);
	};

	class VocSound : public Sound {
	public:
		VocSound(SoundMixer *mixer, File *file, uint resources);
		VocSound(SoundMixer *mixer, File *file, uint32 offs, int set);
		
		int playSound(uint sound, PlayingSoundHandle *handle, byte flags);
	};

	class MP3Sound : public Sound {
	public:
		MP3Sound(SoundMixer *mixer, File *file, uint resources);
		int playSound(uint sound, PlayingSoundHandle *handle, byte flags);
	};

	byte _game;
	int _ambient_index;
	SoundMixer *_mixer;

	Sound *_voice;
	Sound *_effects;

	bool _effects_paused;
	bool _ambient_paused;

public:
	PlayingSoundHandle _voice_handle;
	PlayingSoundHandle _effects_handle;
	PlayingSoundHandle _ambient_handle;

	uint _ambient_playing;

	SimonSound(const byte game, const GameSpecificSettings *gss, const char *gameDataPath, SoundMixer *mixer);

	void readSfxFile(const char *filename, const char *gameDataPath);
	void loadSfxTable(File *gameFile, uint32 offs, int set);

	void playVoice(uint sound);
	void playEffects(uint sound);
	void playAmbient(uint sound);

	void stopAll();
	void effectsPause(bool b);
	void ambientPause(bool b);
};


Index: items.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/simon/items.cpp,v
retrieving revision 1.21
retrieving revision 1.22
diff -u -d -r1.21 -r1.22
--- items.cpp	20 Nov 2002 08:05:55 -0000	1.21
+++ items.cpp	24 Nov 2002 12:53:00 -0000	1.22
@@ -1655,7 +1655,7 @@
 
 void SimonState::o_unk_163(uint a)
 {
-	playEffects(a);
+	_sound->playEffects(a);
 }
 
 void SimonState::o_unk_160(uint a)

Index: module.mk
===================================================================
RCS file: /cvsroot/scummvm/scummvm/simon/module.mk,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- module.mk	21 Nov 2002 04:08:37 -0000	1.1
+++ module.mk	24 Nov 2002 12:53:00 -0000	1.2
@@ -5,9 +5,10 @@
 	simon/items.o \
 	simon/midi.o \
 	simon/res.o \
+	simon/simonsound.o \
 	simon/simon.o \
 	simon/verb.o \
-	simon/vga.o
+	simon/vga.o \
 
 # Include common rules 
 include common.rules

Index: simon.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/simon/simon.cpp,v
retrieving revision 1.91
retrieving revision 1.92
diff -u -d -r1.91 -r1.92
--- simon.cpp	23 Nov 2002 16:08:38 -0000	1.91
+++ simon.cpp	24 Nov 2002 12:53:00 -0000	1.92
@@ -150,10 +150,6 @@
 						"Features of the game that depend on sound synchronization will most likely break");
 	set_volume(detector->_sfx_volume);
 
-	_effects_sound = 0;
-	_voice_sound = 0;
-	_ambient_sound = 0;
-
 	_effects_paused = false;
 	_ambient_paused = false;
 	_music_paused = false;
@@ -818,7 +814,12 @@
 				closeTablesFile(in);
 
 				memcpy(filename, "SFXXXX", 6);
-				readSfxFile(filename);
+				if (_game == GAME_SIMON1WIN )
+					_sound->readSfxFile(filename, _gameDataPath);
+				else if (_game & GAME_SIMON2) {
+					int set = atoi(filename + 6) - 1;
+					_sound->loadSfxTable(_game_file, _game_offsets_ptr[set + gss->SOUND_INDEX_BASE], set);
+				}
 
 				alignTableMem();
 
@@ -3422,9 +3423,7 @@
 
 bool SimonState::vc_59_helper()
 {
-	if (_voice_file == NULL)
-		return true;
-	return _voice_sound == 0;
+	return _sound->_voice_handle == 0;
 }
 
 void SimonState::video_copy_if_flag_0x8_c(FillOrCopyStruct *fcs)
@@ -3466,75 +3465,6 @@
 	_fcs_ptr_1 = fcs_alloc(8, 0x90, 0x18, 6, 1, 0, 0xF);
 }
 
-void SimonState::readSfxFile(const char *filename)
-{
-	uint num = 0;
-	if (_game == GAME_SIMON1WIN) { 			/* simon 1 win */
-		uint32 size;
-
-		if (_effects_offsets)
-			free(_effects_offsets);
-
-		if (_effects_file->isOpen() == true)
-			_effects_file->close();
-
-		_effects_file->open(filename, _gameDataPath);
-
-		if (_effects_file->isOpen() == false) {
-			warning("readSfxFile: Cannot load sfx file %s", filename);
-			return;
-		}
-
-		vc_29_stop_all_sounds();
-
-		_effects_file->seek(4, SEEK_SET);
-		size = _effects_file->readUint32LE();
-
-		num = size / sizeof(uint32);
-
-		_effects_offsets = (uint32 *)malloc(size);
-
-		_effects_file->seek(0, SEEK_SET);
-		_effects_file->read(_effects_offsets, size);
-
-#if defined(SCUMM_BIG_ENDIAN)
-		for (uint r = 0; r < num; r++)
-			_effects_offsets[r] = FROM_LE_32(_effects_offsets[r]);
-#endif
-	} else if (_game & GAME_SIMON2) { 			/* simon 2 */
-		int num_per_set[] = {0, 188, 223, 217, 209, 179, 187, 189, 116, 174, 203,
-				173, 176, 38, 205, 134, 213, 212, 167, 141};
-
-		int set;
-		uint32 offs;
-		uint i;
-
-		vc_29_stop_all_sounds();
-
-		if (_effects_offsets)
-			free(_effects_offsets);
-
-		set = atoi(filename + 6) - 1;
-		offs = _game_offsets_ptr[set + gss->SOUND_INDEX_BASE];
-		num = num_per_set[set];
-
-		if (num == 0)
-			return;
-
-		_effects_offsets = (uint32 *)malloc(num * sizeof(uint32));
-
-		_game_file->seek(offs, SEEK_SET);
-		_game_file->read(_effects_offsets, num * sizeof(uint32));
-
-		for (i = 0; i < num; i++) {
-#if defined(SCUMM_BIG_ENDIAN)
-			_effects_offsets[i] = FROM_LE_32(_effects_offsets[i]);
-#endif
-			_effects_offsets[i] += offs;
-		}
-	}
-}
-
 void SimonState::video_putchar(FillOrCopyStruct *fcs, byte c)
 {
 	if (c == 0xC) {
@@ -3796,7 +3726,7 @@
 			o_unk_99_simon1(num_1 + 201);
 		}
 
-		playVoice(speech_id);
+		_sound->playVoice(speech_id);
 
 		if (num_1 < 100) {
 			start_vga_code(4, 2, num_1 + 201, 0, 0, 0);
@@ -3819,7 +3749,7 @@
 				o_unk_99_simon2(2, 5);
 			}
 			o_unk_99_simon2(2, num_1 + 2);
-			playVoice(speech_id);
+			_sound->playVoice(speech_id);
 
 			start_vga_code(4, 2, num_1 + 2, 0, 0, 0);
 		}
@@ -4540,7 +4470,7 @@
 
 	setup_vga_file_buf_pointers();
 
-	initSound();
+	_sound = new SimonSound(_game, gss, _gameDataPath, _mixer);
 
 	if (!loadGamePcFile(gss->gamepc_filename))
 		error("Error loading gamepc file '%s' (or one of the files it depends on)",
@@ -4554,12 +4484,7 @@
 	
 	_mainscript_toggle = false;
 	_vgascript_toggle = false;
-	
-	if (_voice_type != FORMAT_NONE) {
-		_vk_t_toggle = false;
-	} else {
-		_vk_t_toggle = true;
-	}
+	_vk_t_toggle = false;
 
 	while (1) {
 		hitarea_stuff();
@@ -4613,16 +4538,9 @@
 				} else if (event.kbd.ascii == 'm') {
 					midi.pause(_music_paused ^= 1);
 				} else if (event.kbd.ascii == 's') {
-					_effects_paused ^= 1;
+					_sound->effectsPause(_effects_paused ^= 1);
 				} else if (event.kbd.ascii == 'b') {
-					_ambient_paused ^= 1;
-					if (_ambient_paused && _ambient_playing) {
-						_mixer->stop(_ambient_index);
-					} else if (_ambient_playing) {
-						uint tmp = _ambient_playing;
-						_ambient_playing = 0;
-						playAmbient(tmp);
-					}
+					_sound->ambientPause(_ambient_paused ^= 1);
 				} else if (event.kbd.flags == OSystem::KBD_CTRL) {
 					if (event.kbd.ascii == 'f') {
 						_fast_mode ^= 1;
@@ -4878,322 +4796,6 @@
 #endif
 
 	return true;
-}
-
-void SimonState::initSound()
-{
-#ifdef SCUMM_BIG_ENDIAN
-	uint i;
-#endif
-	/* only read voice file in windows game */
-	if (_game & GAME_TALKIE) {
-		const char *s;
-		const char *e;
-
-		//
-		// Load voice file
-		//
-		_voice_offsets = NULL;
-		_voice_file = new File();
-		_voice_type = FORMAT_NONE;
-
-#ifdef USE_MAD
-		s = gss->mp3_filename;
-		_voice_file->open(s, _gameDataPath);
-		if (_voice_file->isOpen() == false) {
-#endif
-			if (_game & GAME_WIN) {
-				s = gss->wav_filename;
-				_voice_file->open(s, _gameDataPath);
-				if (_voice_file->isOpen() == false) {
-					warning("Cannot open voice file %s", s);
-				} else	{
-					_voice_type = FORMAT_WAV;
-				}
-			} else {
-				s = gss->voc_filename;
-				_voice_file->open(s, _gameDataPath);
-				if (_voice_file->isOpen() == false) {
-					warning("Cannot open voice file %s", s);
-				} else {
-					_voice_type = FORMAT_VOC;
-				}
-			}
-#ifdef USE_MAD
-		} else
-			_voice_type = FORMAT_MP3;
-#endif
-
-		if (_voice_type != FORMAT_NONE) {
-#ifdef USE_MAD
-			if (_voice_type == FORMAT_MP3) {
-				_voice_offsets = (uint32 *)malloc((gss->NUM_VOICE_RESOURCES + 1) * sizeof(uint32));
-			 } else {
-#endif
-				_voice_offsets = (uint32 *)malloc(gss->NUM_VOICE_RESOURCES * sizeof(uint32));
-#ifdef USE_MAD
-			}
-#endif
-			if (_voice_offsets == NULL)
-				error("Out of memory for voice offsets");
-	
-			if (_voice_file->read(_voice_offsets, gss->NUM_VOICE_RESOURCES * sizeof(uint32)) != gss->NUM_VOICE_RESOURCES * sizeof(uint32))
-				error("Cannot read voice offsets");
-#ifdef SCUMM_BIG_ENDIAN
-			for (i = 0; i < gss->NUM_VOICE_RESOURCES; i++)
-				_voice_offsets[i] = FROM_LE_32(_voice_offsets[i]);
-#endif
-#ifdef USE_MAD
-			if (_voice_type == FORMAT_MP3) {
-				_voice_file->seek(0, SEEK_END);
-				_voice_offsets[gss->NUM_EFFECTS_RESOURCES] = _voice_file->pos();
-			}
-#endif
-		}
-
-		//
-		// Load effects
-		//
-		_effects_offsets = NULL;
-		_effects_file = new File();
-		_effects_type = FORMAT_VOC;
-
-#ifdef USE_MAD
-		e = gss->mp3_effects_filename;
-		_effects_file->open(e, _gameDataPath);
-		if (_effects_file->isOpen() == false ) {
-#endif
-			e = gss->voc_effects_filename;
-			_effects_file->open(e, _gameDataPath);
-#ifdef USE_MAD
-		} else {
-			_effects_type = FORMAT_MP3;
-		}
-#endif
-		if (_effects_file->isOpen() == true)
-		{
-#ifdef USE_MAD
-			if (_effects_type == FORMAT_MP3) {
-				_effects_offsets = (uint32 *)malloc((gss->NUM_EFFECTS_RESOURCES + 1) * sizeof(uint32));
-			} else {
-#endif
-				_effects_offsets = (uint32 *)malloc(gss->NUM_EFFECTS_RESOURCES * sizeof(uint32));
-#ifdef USE_MAD
-			}
-#endif
-			if (_effects_offsets == NULL)
-				error("Out of memory for effects offsets");
-
-			if (_effects_file->read(_effects_offsets, gss->NUM_EFFECTS_RESOURCES * sizeof(uint32)) != gss->NUM_EFFECTS_RESOURCES * sizeof(uint32))
-				error("Cannot read effects offsets");
-#ifdef SCUMM_BIG_ENDIAN
-			for (i = 0; i < gss->NUM_EFFECTS_RESOURCES; i++)
-				_effects_offsets[i] = FROM_LE_32(_effects_offsets[i]);
-#endif
-#ifdef USE_MAD
-			if (_effects_type == FORMAT_MP3) {
-				_effects_file->seek(0, SEEK_END);
-				_effects_offsets[gss->NUM_EFFECTS_RESOURCES] = _effects_file->pos();
-			}
-#endif
-		} else {
-			_effects_type = FORMAT_NONE;
-		}
-
-	}
-}
-
-#if !defined(__GNUC__)
-#pragma START_PACK_STRUCTS
-#endif
-
-struct WaveHeader {
-	uint32 riff;
-	uint32 unk;
-	uint32 wave;
-	uint32 fmt;
-
-	uint32 size;
-
-	uint16 format_tag;
-	uint16 channels;
-	uint32 samples_per_sec;
-	uint32 avg_bytes;
-
-	uint16 block_align;
-	uint16 bits_per_sample;
-} GCC_PACK;
-
-struct VocHeader {
-	uint8 desc[20];
-	uint16 datablock_offset;
-	uint16 version;
-	uint16 id;
-} GCC_PACK;
-
-struct VocBlockHeader {
-	uint8 blocktype;
-	uint8 size[3];
-	uint8 sr;
-	uint8 pack;
-} GCC_PACK;
-
-
-#if !defined(__GNUC__)
-#pragma END_PACK_STRUCTS
-#endif
-
-
-#ifdef USE_MAD
-int SimonState::playMP3(File *sound_file, uint32 *offsets, uint sound, PlayingSoundHandle *sound_handle, byte flags)
-{
-	sound_file->seek(offsets[sound], SEEK_SET);
-
-	uint32 size = offsets[sound+1] - offsets[sound];
-
-	byte *buffer = (byte *)malloc(size);
-	sound_file->read(buffer, size);
-
-	return _mixer->playMP3(sound_handle, buffer, size, flags);
-}
-#endif
-
-int SimonState::playVoc(File *sound_file, uint32 *offsets, uint sound, PlayingSoundHandle *sound_handle, byte flags)
-{
-	VocHeader voc_hdr;
-	VocBlockHeader voc_block_hdr;
-	uint32 size;
-
-	sound_file->seek(offsets[sound], SEEK_SET);
-
-	if (sound_file->read(&voc_hdr, sizeof(voc_hdr)) != sizeof(voc_hdr) ||
-			strncmp((char *)voc_hdr.desc, "Creative Voice File\x1A", 10) != 0) {
-		error("playVoc(%d): cannot read voc header", sound);
-	}
-
-	sound_file->read(&voc_block_hdr, sizeof(voc_block_hdr));
-
-	size = voc_block_hdr.size[0] + (voc_block_hdr.size[1] << 8) + (voc_block_hdr.size[2] << 16) - 2;
-	uint32 samples_per_sec;
-
-	/* workaround for voc weakness */
-	if (voc_block_hdr.sr == 0xa6) {
-		samples_per_sec = 11025;
-	} else if (voc_block_hdr.sr == 0xd2) {
-		samples_per_sec = 22050;
-	} else {
-		samples_per_sec = 1000000L / (256L - (long)voc_block_hdr.sr);
-		warning("inexact sample rate used: %i", samples_per_sec);
-	}
-
-	byte *buffer = (byte *)malloc(size);
-	sound_file->read(buffer, size);
-
-	return _mixer->playRaw(sound_handle, buffer, size, samples_per_sec, flags);
-}
-
-int SimonState::playWav(File *sound_file, uint32 *offsets, uint sound, PlayingSoundHandle *sound_handle, byte flags)
-{
-	WaveHeader wave_hdr;
-	uint32 data[2];
-
-	sound_file->seek(offsets[sound], SEEK_SET);
-
-	if (sound_file->read(&wave_hdr, sizeof(wave_hdr)) != sizeof(wave_hdr) ||
-			wave_hdr.riff != MKID('RIFF') || wave_hdr.wave != MKID('WAVE')
-			|| wave_hdr.fmt != MKID('fmt ') || READ_LE_UINT16(&wave_hdr.format_tag) != 1
-			|| READ_LE_UINT16(&wave_hdr.channels) != 1
-			|| READ_LE_UINT16(&wave_hdr.bits_per_sample) != 8) {
-		error("playWav(%d): cannot read RIFF header", sound);
-	}
-
-	sound_file->seek(FROM_LE_32(wave_hdr.size) - sizeof(wave_hdr) + 20, SEEK_CUR);
-
-	data[0] = sound_file->readUint32LE();
-	data[1] = sound_file->readUint32LE();
-	if (												//fread(data, sizeof(data), 1, sound_file) != 1 ||
-			 data[0] != 'atad') {
-		error("playWav(%d): cannot read data header", sound);
-	}
-
-	byte *buffer = (byte *)malloc(data[1]);
-	sound_file->read(buffer, data[1]);
-
-	return _mixer->playRaw(sound_handle, buffer, data[1], FROM_LE_32(wave_hdr.samples_per_sec), flags);
-}
-
-void SimonState::playVoice(uint voice)
-{
-	if (_voice_offsets == NULL)
-		return;
-	
-#ifdef USE_MAD
-	if (_voice_type == FORMAT_MP3) {
-		playMP3(_voice_file, _voice_offsets, voice, &_voice_sound, SoundMixer::FLAG_AUTOFREE);
-	} else {
-#endif
-		if (_voice_type == FORMAT_WAV) {            /* WAVE audio */
-			playWav(_voice_file, _voice_offsets, voice, &_voice_sound, SoundMixer::FLAG_UNSIGNED|SoundMixer::FLAG_AUTOFREE);
-		} else if (_voice_type == FORMAT_VOC) {      /* VOC audio */
-			playVoc(_voice_file, _voice_offsets, voice, &_voice_sound, SoundMixer::FLAG_UNSIGNED|SoundMixer::FLAG_AUTOFREE);
-		}
-#ifdef USE_MAD
-	}
-#endif
-}
-
-void SimonState::playEffects(uint sound)
-{
-	if (_effects_offsets == NULL)
-		return;
-
-	if (_effects_paused)
-		return;
-
-	if (_game == GAME_SIMON1TALKIE) {		/* simon 1 talkie */
-#ifdef USE_MAD
-		if (_effects_type == FORMAT_MP3) {
-			playMP3(_effects_file, _effects_offsets, sound, &_effects_sound, SoundMixer::FLAG_AUTOFREE);
-		} else {
-#endif
-			playVoc(_effects_file, _effects_offsets, sound, &_effects_sound, SoundMixer::FLAG_UNSIGNED|SoundMixer::FLAG_AUTOFREE);
-#ifdef USE_MAD
-		}
-#endif
-	} else if (_game == GAME_SIMON1WIN){ 		/* simon 1 win */
-		playWav(_effects_file, _effects_offsets, sound, &_effects_sound, SoundMixer::FLAG_UNSIGNED|SoundMixer::FLAG_AUTOFREE);
-	} else if (_game == GAME_SIMON2WIN) {		/* simon 2 win */
-		playWav(_game_file, _effects_offsets, sound, &_effects_sound, SoundMixer::FLAG_UNSIGNED|SoundMixer::FLAG_AUTOFREE);
-	} else if (_game & GAME_SIMON2) {		/* simon 2 dos / talkie */
-		playVoc(_game_file, _effects_offsets, sound, &_effects_sound, SoundMixer::FLAG_UNSIGNED|SoundMixer::FLAG_AUTOFREE);
-	} else {					/* simon 1 dos */
-		warning("playEffects(%d)", sound);
-	}
-}
-
-void SimonState::playAmbient(uint sound)
-{
-	if (_effects_offsets == NULL)
-		return;
-
-	if (_ambient_paused)
-		return;
-
-	if (sound == _ambient_playing)
-		return;
-
-	_ambient_playing = sound;
-
-	if (_ambient_sound)
-		_mixer->stop(_ambient_index);
-
-	if (_game & GAME_WIN) {
-		_ambient_index = playWav(_game_file, _effects_offsets, sound, &_ambient_sound,
-			SoundMixer::FLAG_LOOP|SoundMixer::FLAG_UNSIGNED|SoundMixer::FLAG_AUTOFREE);
-	} else {
-		_ambient_index = playVoc(_game_file, _effects_offsets, sound, &_ambient_sound,
-			SoundMixer::FLAG_LOOP|SoundMixer::FLAG_UNSIGNED|SoundMixer::FLAG_AUTOFREE);
-	}
 }
 
 void SimonState::playMusic(uint music)

Index: simon.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/simon/simon.h,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -d -r1.20 -r1.21
--- simon.h	20 Nov 2002 14:45:00 -0000	1.20
+++ simon.h	24 Nov 2002 12:53:01 -0000	1.21
@@ -26,6 +26,7 @@
 #include "common/engine.h"
 #include "simon/midi.h"
 #include "sound/mixer.h"
+#include "simon/simonsound.h"
 
 /* Various other settings */
 //#define DRAW_IMAGES_DEBUG
@@ -332,11 +333,7 @@
 	int _num_screen_updates;
 	int _vga_tick_counter;
 
-	PlayingSoundHandle _effects_sound;
-	PlayingSoundHandle _voice_sound;
-	PlayingSoundHandle _ambient_sound;
-	int _ambient_index;
-	uint _ambient_playing;
+	SimonSound *_sound;
 
 	bool _effects_paused;
 	bool _ambient_paused;
@@ -522,8 +519,6 @@
 	File *openTablesFile_gme(const char *filename);
 	void closeTablesFile_gme(File *in);
 
-	void readSfxFile(const char *filename);
-
 	void invokeTimeEvent(TimeEvent *te);
 	bool kickoffTimeEvents();
 
@@ -772,15 +767,6 @@
 
 	void video_putchar_newline(FillOrCopyStruct *fcs);
 	void video_putchar_drawchar(FillOrCopyStruct *fcs, uint x, uint y, byte chr);
-
-	void initSound();
-	void playVoice(uint voice);
-	void playEffects(uint sound);
-	void playAmbient(uint sound);
-
-	int playVoc(File *sound_file, uint32 *offsets, uint sound, PlayingSoundHandle *sound_handle, byte flags);
-	int playWav(File *sound_file, uint32 *offsets, uint sound, PlayingSoundHandle *sound_handle, byte flags);
-	int playMP3(File *sound_file, uint32 *offsets, uint sound, PlayingSoundHandle *sound_handle, byte flags);
 
 	void playMusic(uint music);
 	void checkTimerCallback();

Index: vga.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/simon/vga.cpp,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- vga.cpp	24 Nov 2002 03:07:52 -0000	1.9
+++ vga.cpp	24 Nov 2002 12:53:01 -0000	1.10
@@ -1343,8 +1343,7 @@
 
 void SimonState::vc_29_stop_all_sounds()
 {
-	_mixer->stopAll();
-	_ambient_playing = 0;
+	_sound->stopAll();
 }
 
 void SimonState::vc_30_set_base_delay()
@@ -1604,13 +1603,13 @@
 	uint16 a = vc_read_next_word();
 
 	if (!(_game & GAME_SIMON2)) {
-		playEffects(a);
+		_sound->playEffects(a);
 	} else {
 		if (a >= 0x8000) {
 			a = -a;
-			playAmbient(a);
+			_sound->playAmbient(a);
 		} else {
-			playEffects(a);
+			_sound->playEffects(a);
 		}
 	}
 }
@@ -1790,14 +1789,12 @@
 
 	vc_29_stop_all_sounds();
 
-	if (!_video_var_3) {
-		warning("vc_62: music stuff?");
-	}
-	
+//  if (!_video_var_3) {
 	_video_var_3 = true;
 	_video_num_pal_colors = 256;
 	if (_video_palette_mode == 4)
 		_video_num_pal_colors = 208;
+//  }
 
 	memcpy(_video_buf_1, _palette_backup, _video_num_pal_colors * sizeof(uint32));
 	for (i = NUM_PALETTE_FADEOUT; i != 0; --i) {
@@ -1864,14 +1861,6 @@
 void SimonState::vc_65()
 {																// Simon2
 	warning("vc_65 unimplemented");
-	//_palette_color_count = 0x270;
-	//_video_num_pal_colors = 0x0D0;
-	//if (_video_palette_mode != 4) {
-		//_palette_color_count = 0x300;
-		//_video_num_pal_colors = 0x100;
-	//}
-	//_palette_color_count |= 0x8000;
-	//_video_var_3 = false;
 }
 
 void SimonState::vc_66()





More information about the Scummvm-git-logs mailing list