1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "map.h"

     4

#include "sound.h"

     5

#include "vehicle.h"

     6

#include "window.h"

     7

#include "viewport.h"

     8

#include "fileio.h"

     9

    10

typedef struct MixerChannel {

    11

	// Mixer

    12

	Mixer *mx;

    13

	bool active;

    14

    15

	// pointer to allocated buffer memory

    16

	int8 *memory;

    17

    18

	// current position in memory

    19

	uint32 pos;

    20

	uint32 frac_pos;

    21

	uint32 frac_speed;

    22

	uint32 samples_left;

    23

    24

	// Mixing volume

    25

	uint volume_left;

    26

	uint volume_right;

    27

    28

	uint flags;

    29

} MixerChannel;

    30

    31

typedef struct FileEntry {

    32

	uint32 file_offset;

    33

	uint32 file_size;

    34

	uint16 rate;

    35

	uint8 bits_per_sample;

    36

	uint8 channels;

    37

} FileEntry;

    38

    39

struct Mixer {

    40

	uint32 play_rate;

    41

	FileEntry *files;

    42

	uint32 file_count;

    43

	MixerChannel channels[8];

    44

};

    45

    46

enum {

    47

	MX_AUTOFREE = 1,

    48

//	MX_8BIT = 2,

    49

//	MX_STEREO = 4,

    50

	MX_UNSIGNED = 8,

    51

};

    52

    53

#define SOUND_SLOT 31

    54

    55

    56

static void mix_int8_to_int16(MixerChannel *sc, int16 *buffer, uint samples)

    57

{

    58

	int8 *b;

    59

	uint32 frac_pos;

    60

	uint32 frac_speed;

    61

	uint volume_left;

    62

	uint volume_right;

    63

    64

	if (samples > sc->samples_left) samples = sc->samples_left;

    65

	sc->samples_left -= samples;

    66

	assert(samples > 0);

    67

    68

	b = sc->memory + sc->pos;

    69

	frac_pos = sc->frac_pos;

    70

	frac_speed = sc->frac_speed;

    71

	volume_left = sc->volume_left;

    72

	volume_right = sc->volume_right;

    73

    74

	if (frac_speed == 0x10000) {

    75

		// Special case when frac_speed is 0x10000

    76

		do {

    77

			buffer[0] += *b * volume_left >> 8;

    78

			buffer[1] += *b * volume_right >> 8;

    79

			b++;

    80

			buffer += 2;

    81

		} while (--samples > 0);

    82

	} else {

    83

		do {

    84

			buffer[0] += *b * volume_left >> 8;

    85

			buffer[1] += *b * volume_right >> 8;

    86

			buffer += 2;

    87

			frac_pos += frac_speed;

    88

			b += frac_pos >> 16;

    89

			frac_pos &= 0xffff;

    90

		} while (--samples > 0);

    91

	}

    92

    93

	sc->frac_pos = frac_pos;

    94

	sc->pos = b - sc->memory;

    95

}

    96

    97

static void MxCloseChannel(MixerChannel *mc)

    98

{

    99

	if (mc->flags & MX_AUTOFREE) free(mc->memory);

   100

	mc->memory = NULL;

   101

	mc->active = false;

   102

}

   103

   104

void MxMixSamples(Mixer *mx, void *buffer, uint samples)

   105

{

   106

	MixerChannel *mc;

   107

   108

	// Clear the buffer

   109

	memset(buffer, 0, sizeof(int16) * 2 * samples);

   110

   111

	// Mix each channel

   112

	for (mc = mx->channels; mc != endof(mx->channels); mc++) {

   113

		if (mc->active) {

   114

			mix_int8_to_int16(mc, buffer, samples);

   115

			if (mc->samples_left == 0) MxCloseChannel(mc);

   116

		}

   117

	}

   118

   119

	#if 0

   120

	{

   121

		static FILE *out = NULL;

   122

		if (out == NULL)

   123

			out = fopen("d:\\dump.raw", "wb");

   124

		fwrite(buffer, samples * 4, 1, out);

   125

	}

   126

	#endif

   127

}

   128

   129

static MixerChannel *MxAllocateChannel(Mixer *mx)

   130

{

   131

	MixerChannel *mc;

   132

	for (mc = mx->channels; mc != endof(mx->channels); mc++)

   133

		if (mc->memory == NULL) {

   134

			mc->active = false;

   135

			mc->mx = mx;

   136

			return mc;

   137

		}

   138

	return NULL;

   139

}

   140

   141

static void MxSetChannelRawSrc(MixerChannel *mc, int8 *mem, uint size, uint rate, uint flags)

   142

{

   143

	mc->memory = mem;

   144

	mc->flags = flags;

   145

	mc->frac_pos = 0;

   146

	mc->pos = 0;

   147

   148

	mc->frac_speed = (rate << 16) / mc->mx->play_rate;

   149

   150

	// adjust the magnitude to prevent overflow

   151

	while (size & 0xFFFF0000) {

   152

		size >>= 1;

   153

		rate = (rate >> 1) + 1;

   154

	}

   155

   156

	mc->samples_left = size * mc->mx->play_rate / rate;

   157

}

   158

   159

static void MxSetChannelVolume(MixerChannel *mc, uint left, uint right)

   160

{

   161

	mc->volume_left = left;

   162

	mc->volume_right = right;

   163

}

   164

   165

static void MxOpenBankFile(Mixer *mx, const char *filename)

   166

{

   167

	uint count, i;

   168

	uint32 size, tag;

   169

	FileEntry *fe;

   170

   171

	FioOpenFile(SOUND_SLOT, filename);

   172

	mx->file_count = count = FioReadDword() >> 3;

   173

	fe = mx->files = calloc(sizeof(FileEntry), count);

   174

   175

	FioSeekTo(0, SEEK_SET);

   176

   177

	for (i = 0; i != count; i++, fe++) {

   178

		fe->file_offset = FioReadDword();

   179

		fe->file_size = FioReadDword();

   180

	}

   181

   182

	fe = mx->files;

   183

	for (i = 0; i != count; i++, fe++) {

   184

		char name[255];

   185

   186

		FioSeekTo(fe->file_offset, SEEK_SET);

   187

   188

		// Check for special case, see else case

   189

		FioReadBlock(name, FioReadByte()); // Read the name of the sound

   190

		if (strcmp(name, "Corrupt sound") != 0) {

   191

			FioSeekTo(12, SEEK_CUR); // Skip past RIFF header

   192

   193

			// Read riff tags

   194

			for (;;) {

   195

				tag = FioReadDword();

   196

				size = FioReadDword();

   197

   198

				if (tag == ' tmf') {

   199

					FioReadWord(); // wFormatTag

   200

					fe->channels = FioReadWord(); // wChannels

   201

					FioReadDword();   // samples per second

   202

					fe->rate = 11025; // seems like all samples should be played at this rate.

   203

					FioReadDword();   // avg bytes per second

   204

					FioReadWord();    // alignment

   205

					fe->bits_per_sample = FioReadByte(); // bits per sample

   206

					FioSeekTo(size - (2 + 2 + 4 + 4 + 2 + 1), SEEK_CUR);

   207

				} else if (tag == 'atad') {

   208

					fe->file_size = size;

   209

					fe->file_offset = FioGetPos() | (SOUND_SLOT << 24);

   210

					break;

   211

				} else {

   212

					fe->file_size = 0;

   213

					break;

   214

				}

   215

			}

   216

		} else {

   217

			/*

   218

			 * Special case for the jackhammer sound

   219

			 * (name in sample.cat is "Corrupt sound")

   220

			 * It's no RIFF file, but raw PCM data

   221

			 */

   222

			fe->channels = 1;

   223

			fe->rate = 11025;

   224

			fe->bits_per_sample = 8;

   225

			fe->file_offset = FioGetPos() | (SOUND_SLOT << 24);

   226

		}

   227

	}

   228

}

   229

   230

static bool MxSetBankSource(MixerChannel *mc, uint bank)

   231

{

   232

	FileEntry *fe = &mc->mx->files[bank];

   233

	int8 *mem;

   234

	uint i;

   235

   236

	if (fe->file_size == 0)

   237

		return false;

   238

   239

	mem = malloc(fe->file_size); /* XXX unchecked malloc */

   240

	FioSeekToFile(fe->file_offset);

   241

	FioReadBlock(mem, fe->file_size);

   242

   243

	for (i = 0; i != fe->file_size; i++)

   244

		mem[i] -= 128; // Convert unsigned sound data to signed

   245

   246

	assert(fe->bits_per_sample == 8 && fe->channels == 1 && fe->file_size != 0 && fe->rate != 0);

   247

   248

	MxSetChannelRawSrc(mc, mem, fe->file_size, fe->rate, MX_AUTOFREE | MX_UNSIGNED);

   249

   250

	return true;

   251

}

   252

   253

bool MxInitialize(uint rate, const char *filename)

   254

{

   255

	static Mixer mx;

   256

	_mixer = &mx;

   257

	mx.play_rate = rate;

   258

	MxOpenBankFile(&mx, filename);

   259

	return true;

   260

}

   261

   262

// Low level sound player

   263

static void StartSound(uint sound, uint panning, uint volume)

   264

{

   265

	if (volume != 0) {

   266

		MixerChannel *mc = MxAllocateChannel(_mixer);

   267

		if (mc == NULL)

   268

			return;

   269

		if (MxSetBankSource(mc, sound)) {

   270

			MxSetChannelVolume(mc, volume << 8, volume << 8);

   271

			mc->active = true;

   272

		}

   273

	}

   274

}

   275

   276

   277

static const byte _vol_factor_by_zoom[] = {255, 190, 134};

   278

   279

static const byte _sound_base_vol[] = {

   280

	128,  90, 128, 128, 128, 128, 128, 128,

   281

	128,  90,  90, 128, 128, 128, 128, 128,

   282

	128, 128, 128,  80, 128, 128, 128, 128,

   283

	128, 128, 128, 128, 128, 128, 128, 128,

   284

	128, 128,  90,  90,  90, 128,  90, 128,

   285

	128,  90, 128, 128, 128,  90, 128, 128,

   286

	128, 128, 128, 128,  90, 128, 128, 128,

   287

	128,  90, 128, 128, 128, 128, 128, 128,

   288

	128, 128,  90,  90,  90, 128, 128, 128,

   289

	 90,

   290

};

   291

   292

static const byte _sound_idx[] = {

   293

	2, 3, 4, 5, 6, 7, 8, 9,

   294

	10, 11, 12, 13, 14, 15, 16, 17,

   295

	18, 19, 20, 21, 22, 23, 24, 25,

   296

	26, 27, 28, 29, 30, 31, 32, 33,

   297

	34, 35, 36, 37, 38, 39, 40, 0,

   298

	1, 41, 42, 43, 44, 45, 46, 47,

   299

	48, 49, 50, 51, 52, 53, 54, 55,

   300

	56, 57, 58, 59, 60, 61, 62, 63,

   301

	64, 65, 66, 67, 68, 69, 70, 71,

   302

	72,

   303

};

   304

   305

static void SndPlayScreenCoordFx(SoundFx sound, int x, int y)

   306

{

   307

	Window *w;

   308

	ViewPort *vp;

   309

	int left;

   310

   311

	if (msf.effect_vol == 0)

   312

		return;

   313

   314

	for (w = _windows; w != _last_window; w++) {

   315

		if ((vp = w->viewport) != NULL &&

   316

				IS_INSIDE_1D(x, vp->virtual_left, vp->virtual_width) &&

   317

				IS_INSIDE_1D(y, vp->virtual_top, vp->virtual_height)) {

   318

   319

			left = ((x - vp->virtual_left) >> vp->zoom) + vp->left;

   320

			StartSound(

   321

				_sound_idx[sound],

   322

				clamp(left / 71, 0, 8),

   323

				(_sound_base_vol[sound] * msf.effect_vol * _vol_factor_by_zoom[vp->zoom]) >> 15

   324

			);

   325

			return;

   326

		}

   327

	}

   328

   329

}

   330

   331

void SndPlayTileFx(SoundFx sound, TileIndex tile)

   332

{

   333

	/* emits sound from center (+ 8) of the tile */

   334

	int x = TileX(tile) * 16 + 8;

   335

	int y = TileY(tile) * 16 + 8;

   336

	Point pt = RemapCoords(x, y, GetSlopeZ(x, y));

   337

	SndPlayScreenCoordFx(sound, pt.x, pt.y);

   338

}

   339

   340

void SndPlayVehicleFx(SoundFx sound, const Vehicle *v)

   341

{

   342

	SndPlayScreenCoordFx(sound,

   343

		(v->left_coord + v->right_coord) / 2,

   344

		(v->top_coord + v->bottom_coord) / 2

   345

	);

   346

}

   347

   348

void SndPlayFx(SoundFx sound)

   349

{

   350

	StartSound(

   351

		_sound_idx[sound],

   352

		4,

   353

		(_sound_base_vol[sound] * msf.effect_vol) >> 7

   354

	);

   355

}