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

    10

	// Mixer

    11

	Mixer *mx;

    12

	bool active;

    13

    14

	// pointer to allocated buffer 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

    31

	uint32 file_offset;

    32

	uint32 file_size;

    33

	uint16 rate;

    34

	uint8 bits_per_sample;

    35

	uint8 channels;

    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

    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 {

    78

			b++;

    79

			buffer += 2;

    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;

    90

	}

    91

    92

	sc->frac_pos = frac_pos;

    94

}

    95

    96

static void MxCloseChannel(MixerChannel *mc)

    97

{

    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

   109

   110

	// Mix each channel

   112

		if (mc->active) {

   115

		}

   116

	}

   117

   126

}

   127

   128

static MixerChannel *MxAllocateChannel(Mixer *mx)

   129

{

   130

	MixerChannel *mc;

   133

			mc->active = false;

   134

			mc->mx = mx;

   135

			return mc;

   136

		}

   137

	return NULL;

   138

}

   139

   141

{

   142

	mc->memory = mem;

   143

	mc->flags = flags;

   144

	mc->frac_pos = 0;

   145

	mc->pos = 0;

   146

   148

   149

	// adjust the magnitude to prevent overflow

   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

   177

		fe->file_offset = FioReadDword();

   178

		fe->file_size = FioReadDword();

   179

	}

   180

   181

	fe = mx->files;

   184

   214

			}

   225

		}

   226

	}

   227

}

   228

   229

static bool MxSetBankSource(MixerChannel *mc, uint bank)

   230

{

   231

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

   233

	uint i;

   234

   235

	if (fe->file_size == 0)

   236

		return false;

   237

   239

	FioSeekToFile(fe->file_offset);

   240

	FioReadBlock(mem, fe->file_size);

   241

   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

   305

{

   306

	Window *w;

   307

	ViewPort *vp;

   308

	int left;

   309

   310

	if (msf.effect_vol == 0)

   311

		return;

   312

   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

   331

{

   336

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

   337

}

   338

   340

{

   341

	SndPlayScreenCoordFx(sound,

   344

	);

   345

}

   346

   348

{

   349

	StartSound(

   350

		_sound_idx[sound],

   351

		4,

   352

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

   353

	);

   354

}