1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "map.h"

     7

#include "mixer.h"

     8

#include "sound.h"

     9

#include "vehicle.h"

    10

#include "window.h"

    11

#include "viewport.h"

    12

#include "fileio.h"

    13

#include "newgrf_sound.h"

    14

#include "helpers.hpp"

    15

    16

static uint _file_count;

    17

static FileEntry *_files;

    18

    19

#define SOUND_SLOT 63

    20

// Number of levels of panning per side

    21

#define PANNING_LEVELS 16

    22

    23

    24

static void OpenBankFile(const char *filename)

    25

{

    26

	FileEntry *fe;

    27

	uint count;

    28

	uint i;

    29

    30

	FioOpenFile(SOUND_SLOT, filename);

    31

	count = FioReadDword() / 8;

    32

	CallocT(&fe, count);

    33

    34

	if (fe == NULL) {

    35

		_file_count = 0;

    36

		_files = NULL;

    37

		return;

    38

	}

    39

    40

	_file_count = count;

    41

	_files = fe;

    42

    43

	FioSeekTo(0, SEEK_SET);

    44

    45

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

    46

		fe[i].file_offset = FioReadDword();

    47

		fe[i].file_size = FioReadDword();

    48

	}

    49

    50

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

    51

		char name[255];

    52

    53

		FioSeekTo(fe->file_offset, SEEK_SET);

    54

    55

		// Check for special case, see else case

    56

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

    57

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

    58

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

    59

    60

			// Read riff tags

    61

			for (;;) {

    62

				uint32 tag = FioReadDword();

    63

				uint32 size = FioReadDword();

    64

    65

				if (tag == ' tmf') {

    66

					FioReadWord(); // wFormatTag

    67

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

    68

					FioReadDword();   // samples per second

    69

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

    70

					FioReadDword();   // avg bytes per second

    71

					FioReadWord();    // alignment

    72

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

    73

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

    74

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

    75

					fe->file_size = size;

    76

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

    77

					break;

    78

				} else {

    79

					fe->file_size = 0;

    80

					break;

    81

				}

    82

			}

    83

		} else {

    84

			/*

    85

			 * Special case for the jackhammer sound

    86

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

    87

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

    88

			 */

    89

			fe->channels = 1;

    90

			fe->rate = 11025;

    91

			fe->bits_per_sample = 8;

    92

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

    93

		}

    94

	}

    95

}

    96

    97

uint GetNumOriginalSounds(void)

    98

{

    99

	return _file_count;

   100

}

   101

   102

static bool SetBankSource(MixerChannel *mc, uint bank)

   103

{

   104

	const FileEntry *fe;

   105

	int8 *mem;

   106

	uint i;

   107

   108

	if (bank >= GetNumSounds()) return false;

   109

	fe = GetSound(bank);

   110

   111

	if (fe->file_size == 0) return false;

   112

   113

	MallocT(&mem, fe->file_size);

   114

	if (mem == NULL) return false;

   115

   116

	FioSeekToFile(fe->file_offset);

   117

	FioReadBlock(mem, fe->file_size);

   118

   119

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

   120

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

   121

   122

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

   123

   124

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

   125

   126

	return true;

   127

}

   128

   129

bool SoundInitialize(const char *filename)

   130

{

   131

	OpenBankFile(filename);

   132

	return true;

   133

}

   134

   135

// Low level sound player

   136

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

   137

{

   138

	MixerChannel *mc;

   139

	uint left_vol, right_vol;

   140

   141

	if (volume == 0) return;

   142

	mc = MxAllocateChannel();

   143

	if (mc == NULL) return;

   144

	if (!SetBankSource(mc, sound)) return;

   145

   146

	panning = clamp(panning, -PANNING_LEVELS, PANNING_LEVELS);

   147

	left_vol = (volume * PANNING_LEVELS) - (volume * panning);

   148

	right_vol = (volume * PANNING_LEVELS) + (volume * panning);

   149

	MxSetChannelVolume(mc, left_vol * 128 / PANNING_LEVELS, right_vol * 128 / PANNING_LEVELS);

   150

	MxActivateChannel(mc);

   151

}

   152

   153

   154

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

   155

   156

static const byte _sound_base_vol[] = {

   157

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

   158

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

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

	 90,

   167

};

   168

   169

static const byte _sound_idx[] = {

   170

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

   171

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

   172

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

   173

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

   174

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

   175

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

   176

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

   177

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

   178

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

   179

	72,

   180

};

   181

   182

void SndCopyToPool(void)

   183

{

   184

	uint i;

   185

   186

	for (i = 0; i < _file_count; i++) {

   187

		FileEntry *orig = &_files[_sound_idx[i]];

   188

		FileEntry *fe = AllocateFileEntry();

   189

   190

		*fe = *orig;

   191

		fe->volume = _sound_base_vol[i];

   192

		fe->priority = 0;

   193

	}

   194

}

   195

   196

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

   197

{

   198

	Window* const *wz;

   199

   200

	if (msf.effect_vol == 0) return;

   201

   202

	FOR_ALL_WINDOWS(wz) {

   203

		const ViewPort *vp = (*wz)->viewport;

   204

   205

		if (vp != NULL &&

   206

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

   207

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

   208

			int left = (x - vp->virtual_left);

   209

   210

			StartSound(

   211

				sound,

   212

				left / (vp->virtual_width / ((PANNING_LEVELS << 1) + 1)) - PANNING_LEVELS,

   213

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

   214

			);

   215

			return;

   216

		}

   217

	}

   218

   219

}

   220

   221

void SndPlayTileFx(SoundFx sound, TileIndex tile)

   222

{

   223

	/* emits sound from center of the tile */

   224

	int x = TileX(tile) * TILE_SIZE + TILE_SIZE / 2;

   225

	int y = TileY(tile) * TILE_SIZE + TILE_SIZE / 2;

   226

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

   227

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

   228

}

   229

   230

void SndPlayVehicleFx(SoundFx sound, const Vehicle *v)

   231

{

   232

	SndPlayScreenCoordFx(sound,

   233

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

   234

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

   235

	);

   236

}

   237

   238

void SndPlayFx(SoundFx sound)

   239

{

   240

	StartSound(

   241

		sound,

   242

		0,

   243

		(GetSound(sound)->volume * msf.effect_vol) >> 7

   244

	);

   245

}