1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "sound.h"

     4

#include "vehicle.h"

     5

#include "window.h"

     6

#include "viewport.h"

     7

#include "fileio.h"

     8

     9

typedef struct MixerChannel {

    10

	// Mixer

    11

	Mixer *mx;

    12

	bool active;

    13

    14

	// pointer to allocated buffer memory

    15

	int8 *memory;

    16

    17

	// current position in memory

    18

	uint32 pos;

    19

	uint32 frac_pos;

    20

	uint32 frac_speed;

    21

	uint32 samples_left;

    22

    23

	// Mixing volume

    24

	uint volume_left;

    25

	uint volume_right;

    26

    27

	uint flags;

    28

} MixerChannel;

    29

    30

typedef struct FileEntry {

    31

	uint32 file_offset;

    32

	uint32 file_size;

    33

	uint16 rate;

    34

	uint8 bits_per_sample;

    35

	uint8 channels;

    36

} FileEntry;

    37

    38

struct Mixer {

    39

	uint32 play_rate;

    40

	FileEntry *files;

    41

	uint32 file_count;

    42

	MixerChannel channels[8];

    43

};

    44

    45

enum {

    46

	MX_AUTOFREE = 1,

    47

//	MX_8BIT = 2,

    48

//	MX_STEREO = 4,

    49

	MX_UNSIGNED = 8,

    50

};

    51

    52

#define SOUND_SLOT 31

    53

    54

    55

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

    56

{

    57

	int8 *b;

    58

	uint32 frac_pos;

    59

	uint32 frac_speed;

    60

	uint volume_left;

    61

	uint volume_right;

    62

    63

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

    64

	sc->samples_left -= samples;

    65

	assert(samples > 0);

    66

    67

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

    68

	frac_pos = sc->frac_pos;

    69

	frac_speed = sc->frac_speed;

    70

	volume_left = sc->volume_left;

    71

	volume_right = sc->volume_right;

    72

    73

	if (frac_speed == 0x10000) {

    74

		// Special case when frac_speed is 0x10000

    75

		do {

    76

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

    77

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

    78

			b++;

    79

			buffer += 2;

    80

		} while (--samples > 0);

    81

	} else {

    82

		do {

    83

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

    84

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

    85

			buffer += 2;

    86

			frac_pos += frac_speed;

    87

			b += frac_pos >> 16;

    88

			frac_pos &= 0xffff;

    89

		} while (--samples > 0);

    90

	}

    91

    92

	sc->frac_pos = frac_pos;

    93

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

    94

}

    95

    96

static void MxCloseChannel(MixerChannel *mc)

    97

{

    98

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

    99

	mc->memory = NULL;

   100

	mc->active = false;

   101

}

   102

   103

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

   104

{

   105

	MixerChannel *mc;

   106

   107

	// Clear the buffer

   108

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

   109

   110

	// Mix each channel

   111

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

   112

		if (mc->active) {

   113

			mix_int8_to_int16(mc, buffer, samples);

   114

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

   115

		}

   116

	}

   117

   118

	#if 0

   119

	{

   120

		static FILE *out = NULL;

   121

		if (out == NULL)

   122

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

   123

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

   124

	}

   125

	#endif

   126

}

   127

   128

static MixerChannel *MxAllocateChannel(Mixer *mx)

   129

{

   130

	MixerChannel *mc;

   131

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

   132

		if (mc->memory == NULL) {

   133

			mc->active = false;

   134

			mc->mx = mx;

   135

			return mc;

   136

		}

   137

	return NULL;

   138

}

   139

   140

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

   141

{

   142

	mc->memory = mem;

   143

	mc->flags = flags;

   144

	mc->frac_pos = 0;

   145

	mc->pos = 0;

   146

   147

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

   148

   149

	// adjust the magnitude to prevent overflow

   150

	while (size & 0xFFFF0000) {

   151

		size >>= 1;

   152

		rate = (rate >> 1) + 1;

   153

	}

   154

   155

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

   156

}

   157

   158

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

   159

{

   160

	mc->volume_left = left;

   161

	mc->volume_right = right;

   162

}

   163

   164

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

   165

{

   166

	uint count, i;

   167

	uint32 size, tag;

   168

	FileEntry *fe;

   169

   170

	FioOpenFile(SOUND_SLOT, filename);

   171

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

   172

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

   173

   174

	FioSeekTo(0, SEEK_SET);

   175

   176

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

   177

		fe->file_offset = FioReadDword();

   178

		fe->file_size = FioReadDword();

   179

	}

   180

   181

	fe = mx->files;

   182

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

   183

		char name[255];

   184

   185

		FioSeekTo(fe->file_offset, SEEK_SET);

   186

   187

		// Check for special case, see else case

   188

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

   189

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

   190

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

   191

   192

			// Read riff tags

   193

			for (;;) {

   194

				tag = FioReadDword();

   195

				size = FioReadDword();

   196

   197

				if (tag == ' tmf') {

   198

					FioReadWord(); // wFormatTag

   199

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

   200

					FioReadDword();   // samples per second

   201

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

   202

					FioReadDword();   // avg bytes per second

   203

					FioReadWord();    // alignment

   204

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

   205

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

   206

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

   207

					fe->file_size = size;

   208

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

   209

					break;

   210

				} else {

   211

					fe->file_size = 0;

   212

					break;

   213

				}

   214

			}

   215

		} else {

   216

			/*

   217

			 * Special case for the jackhammer sound

   218

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

   219

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

   220

			 */

   221

			fe->channels = 1;

   222

			fe->rate = 11025;

   223

			fe->bits_per_sample = 8;

   224

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

   225

		}

   226

	}

   227

}

   228

   229

static bool MxSetBankSource(MixerChannel *mc, uint bank)

   230

{

   231

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

   232

	int8 *mem;

   233

	uint i;

   234

   235

	if (fe->file_size == 0)

   236

		return false;

   237

   238

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

   239

	FioSeekToFile(fe->file_offset);

   240

	FioReadBlock(mem, fe->file_size);

   241

   242

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

   243

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

   244

   245

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

   246

   247

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

   248

   249

	return true;

   250

}

   251

   252

bool MxInitialize(uint rate, const char *filename)

   253

{

   254

	static Mixer mx;

   255

	_mixer = &mx;

   256

	mx.play_rate = rate;

   257

	MxOpenBankFile(&mx, filename);

   258

	return true;

   259

}

   260

   261

// Low level sound player

   262

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

   263

{

   264

	if (volume != 0) {

   265

		MixerChannel *mc = MxAllocateChannel(_mixer);

   266

		if (mc == NULL)

   267

			return;

   268

		if (MxSetBankSource(mc, sound)) {

   269

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

   270

			mc->active = true;

   271

		}

   272

	}

   273

}

   274

   275

   276

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

   277

   278

static const byte _sound_base_vol[] = {

   279

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

   280

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

   281

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

   282

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

   283

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

   284

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

   285

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

   286

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

   287

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

   288

	 90,

   289

};

   290

   291

static const byte _sound_idx[] = {

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

	72,

   302

};

   303

   304

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

   305

{

   306

	Window *w;

   307

	ViewPort *vp;

   308

	int left;

   309

   310

	if (msf.effect_vol == 0)

   311

		return;

   312

   313

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

   314

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

   315

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

   316

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

   317

   318

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

   319

			StartSound(

   320

				_sound_idx[sound],

   321

				clamp(left / 71, 0, 8),

   322

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

   323

			);

   324

			return;

   325

		}

   326

	}

   327

   328

}

   329

   330

void SndPlayTileFx(SoundFx sound, TileIndex tile)

   331

{

   332

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

   333

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

   334

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

   335

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

   336

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

   337

}

   338

   339

void SndPlayVehicleFx(SoundFx sound, const Vehicle *v)

   340

{

   341

	SndPlayScreenCoordFx(sound,

   342

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

   343

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

   344

	);

   345

}

   346

   347

void SndPlayFx(SoundFx sound)

   348

{

   349

	StartSound(

   350

		_sound_idx[sound],

   351

		4,

   352

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

   353

	);

   354

}