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

    19

static uint _file_count;

    20

static FileEntry *_files;

    21

    22

#define SOUND_SLOT 63

    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

	count = FioReadDword() / 8;

    34

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

    35

    36

	if (fe == NULL) {

    37

		_file_count = 0;

    38

		_files = NULL;

    39

		return;

    40

	}

    41

    42

	_file_count = count;

    43

	_files = fe;

    44

    45

	FioSeekTo(0, SEEK_SET);

    46

    47

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

    48

		fe[i].file_offset = FioReadDword();

    49

		fe[i].file_size = FioReadDword();

    50

	}

    51

    52

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

    53

		char name[255];

    54

    55

		FioSeekTo(fe->file_offset, SEEK_SET);

    56

    57

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

    58

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

    59

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

    60

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

    61

    62

			/* Read riff tags */

    63

			for (;;) {

    64

				uint32 tag = FioReadDword();

    65

				uint32 size = FioReadDword();

    66

    67

				if (tag == ' tmf') {

    68

					FioReadWord(); // wFormatTag

    69

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

    70

					FioReadDword();   // samples per second

    71

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

    72

					FioReadDword();   // avg bytes per second

    73

					FioReadWord();    // alignment

    74

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

    75

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

    76

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

    77

					fe->file_size = size;

    78

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

    79

					break;

    80

				} else {

    81

					fe->file_size = 0;

    82

					break;

    83

				}

    84

			}

    85

		} else {

    86

			/*

    87

			 * Special case for the jackhammer sound

    88

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

    89

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

    90

			 */

    91

			fe->channels = 1;

    92

			fe->rate = 11025;

    93

			fe->bits_per_sample = 8;

    94

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

    95

		}

    96

	}

    97

}

    98

    99

uint GetNumOriginalSounds()

   100

{

   101

	return _file_count;

   102

}

   103

   104

static bool SetBankSource(MixerChannel *mc, uint bank)

   105

{

   106

	const FileEntry *fe;

   107

	uint i;

   108

   109

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

   110

	fe = GetSound(bank);

   111

   112

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

   113

   114

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

   115

	if (mem == NULL) return false;

   116

   117

	FioSeekToFile(fe->file_offset);

   118

	FioReadBlock(mem, fe->file_size);

   119

   120

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

   121

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

   122

   123

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

   124

   125

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

   126

   127

	return true;

   128

}

   129

   130

bool SoundInitialize(const char *filename)

   131

{

   132

	OpenBankFile(filename);

   133

	return true;

   134

}

   135

   136

/* Low level sound player */

   137

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

   138

{

   139

	MixerChannel *mc;

   140

	uint left_vol, right_vol;

   141

   142

	if (volume == 0) return;

   143

	mc = MxAllocateChannel();

   144

	if (mc == NULL) return;

   145

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

   146

   147

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

   148

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

   149

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

   150

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

   151

	MxActivateChannel(mc);

   152

}

   153

   154

   155

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

   156

assert_compile(lengthof(_vol_factor_by_zoom) == ZOOM_LVL_END);

   157

   158

static const byte _sound_base_vol[] = {

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

	 90,

   169

};

   170

   171

static const byte _sound_idx[] = {

   172

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

   173

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

   174

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

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

	72,

   182

};

   183

   184

void SndCopyToPool()

   185

{

   186

	uint i;

   187

   188

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

   189

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

   190

		FileEntry *fe = AllocateFileEntry();

   191

   192

		*fe = *orig;

   193

		fe->volume = _sound_base_vol[i];

   194

		fe->priority = 0;

   195

	}

   196

}

   197

   198

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

   199

{

   200

	Window* const *wz;

   201

   202

	if (msf.effect_vol == 0) return;

   203

   204

	FOR_ALL_WINDOWS(wz) {

   205

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

   206

   207

		if (vp != NULL &&

   208

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

   209

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

   210

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

   211

   212

			StartSound(

   213

				sound,

   214

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

   215

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

   216

			);

   217

			return;

   218

		}

   219

	}

   220

   221

}

   222

   223

void SndPlayTileFx(SoundFx sound, TileIndex tile)

   224

{

   225

	/* emits sound from center of the tile */

   226

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

   227

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

   228

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

   229

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

   230

}

   231

   232

void SndPlayVehicleFx(SoundFx sound, const Vehicle *v)

   233

{

   234

	SndPlayScreenCoordFx(sound,

   235

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

   236

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

   237

	);

   238

}

   239

   240

void SndPlayFx(SoundFx sound)

   241

{

   242

	StartSound(

   243

		sound,

   244

		0,

   245

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

   246

	);

   247

}