1

/* $Id$ */

     2

     3

/** @file sound.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "functions.h"

     8

#include "landscape.h"

     9

#include "map.h"

    10

#include "mixer.h"

    11

#include "sound.h"

    12

#include "vehicle.h"

    13

#include "window.h"

    14

#include "viewport.h"

    15

#include "fileio.h"

    16

#include "newgrf_sound.h"

    17

#include "helpers.hpp"

    18

#include "fios.h"

    19

    20

static uint _file_count;

    21

static FileEntry *_files;

    22

    23

// Number of levels of panning per side

    24

#define PANNING_LEVELS 16

    25

    26

    27

static void OpenBankFile(const char *filename)

    28

{

    29

	uint count;

    30

	uint i;

    31

    32

	FioOpenFile(SOUND_SLOT, filename);

    33

	uint pos = FioGetPos();

    34

	count = FioReadDword() / 8;

    35

	FileEntry *fe = CallocT<FileEntry>(count);

    36

    37

	if (fe == NULL) {

    38

		_file_count = 0;

    39

		_files = NULL;

    40

		return;

    41

	}

    42

    43

	_file_count = count;

    44

	_files = fe;

    45

    46

	FioSeekTo(pos, SEEK_SET);

    47

    48

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

    49

		fe[i].file_slot = SOUND_SLOT;

    50

		fe[i].file_offset = FioReadDword() + pos;

    51

		fe[i].file_size = FioReadDword();

    52

	}

    53

    54

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

    55

		char name[255];

    56

    57

		FioSeekTo(fe->file_offset, SEEK_SET);

    58

    59

		/* Check for special case, see else case */

    60

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

    61

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

    62

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

    63

    64

			/* Read riff tags */

    65

			for (;;) {

    66

				uint32 tag = FioReadDword();

    67

				uint32 size = FioReadDword();

    68

    69

				if (tag == ' tmf') {

    70

					FioReadWord(); // wFormatTag

    71

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

    72

					FioReadDword();   // samples per second

    73

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

    74

					FioReadDword();   // avg bytes per second

    75

					FioReadWord();    // alignment

    76

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

    77

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

    78

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

    79

					fe->file_size = size;

    80

					fe->file_slot = SOUND_SLOT;

    81

					fe->file_offset = FioGetPos();

    82

					break;

    83

				} else {

    84

					fe->file_size = 0;

    85

					break;

    86

				}

    87

			}

    88

		} else {

    89

			/*

    90

			 * Special case for the jackhammer sound

    91

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

    92

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

    93

			 */

    94

			fe->channels = 1;

    95

			fe->rate = 11025;

    96

			fe->bits_per_sample = 8;

    97

			fe->file_slot = SOUND_SLOT;

    98

			fe->file_offset = FioGetPos();

    99

		}

   100

	}

   101

}

   102

   103

uint GetNumOriginalSounds()

   104

{

   105

	return _file_count;

   106

}

   107

   108

static bool SetBankSource(MixerChannel *mc, uint bank)

   109

{

   110

	const FileEntry *fe;

   111

	uint i;

   112

   113

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

   114

	fe = GetSound(bank);

   115

   116

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

   117

   118

	int8 *mem = MallocT<int8>(fe->file_size);

   119

	if (mem == NULL) return false;

   120

   121

	FioSeekToFile(fe->file_slot, fe->file_offset);

   122

	FioReadBlock(mem, fe->file_size);

   123

   124

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

   125

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

   126

   127

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

   128

   129

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

   130

   131

	return true;

   132

}

   133

   134

bool SoundInitialize(const char *filename)

   135

{

   136

	OpenBankFile(filename);

   137

	return true;

   138

}

   139

   140

/* Low level sound player */

   141

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

   142

{

   143

	MixerChannel *mc;

   144

	uint left_vol, right_vol;

   145

   146

	if (volume == 0) return;

   147

	mc = MxAllocateChannel();

   148

	if (mc == NULL) return;

   149

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

   150

   151

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

   152

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

   153

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

   154

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

   155

	MxActivateChannel(mc);

   156

}

   157

   158

   159

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

   161

   162

static const byte _sound_base_vol[] = {

   163

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

   164

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

   165

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

   166

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

   167

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

   168

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

   169

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

   170

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

   171

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

   172

	 90,

   173

};

   174

   175

static const byte _sound_idx[] = {

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

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

   184

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

   185

	72,

   186

};

   187

   188

void SndCopyToPool()

   189

{

   190

	uint i;

   191

   192

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

   193

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

   194

		FileEntry *fe = AllocateFileEntry();

   195

   196

		*fe = *orig;

   197

		fe->volume = _sound_base_vol[i];

   198

		fe->priority = 0;

   199

	}

   200

}

   201

   202

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

   203

{

   204

	Window* const *wz;

   205

   206

	if (msf.effect_vol == 0) return;

   207

   208

	FOR_ALL_WINDOWS(wz) {

   209

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

   210

   211

		if (vp != NULL &&

   212

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

   213

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

   214

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

   215

   216

			StartSound(

   217

				sound,

   218

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

   220

			);

   221

			return;

   222

		}

   223

	}

   224

   225

}

   226

   227

void SndPlayTileFx(SoundFx sound, TileIndex tile)

   228

{

   229

	/* emits sound from center of the tile */

   230

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

   231

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

   232

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

   233

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

   234

}

   235

   236

void SndPlayVehicleFx(SoundFx sound, const Vehicle *v)

   237

{

   238

	SndPlayScreenCoordFx(sound,

   239

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

   240

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

   241

	);

   242

}

   243

   244

void SndPlayFx(SoundFx sound)

   245

{

   246

	StartSound(

   247

		sound,

   248

		0,

   249

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

   250

	);

   251

}