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

	uint count;

    27

	uint i;

    28

    29

	FioOpenFile(SOUND_SLOT, filename);

    30

	count = FioReadDword() / 8;

    31

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

    32

    33

	if (fe == NULL) {

    34

		_file_count = 0;

    35

		_files = NULL;

    36

		return;

    37

	}

    38

    39

	_file_count = count;

    40

	_files = fe;

    41

    42

	FioSeekTo(0, SEEK_SET);

    43

    44

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

    45

		fe[i].file_offset = FioReadDword();

    46

		fe[i].file_size = FioReadDword();

    47

	}

    48

    49

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

    50

		char name[255];

    51

    52

		FioSeekTo(fe->file_offset, SEEK_SET);

    53

    54

		// Check for special case, see else case

    55

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

    56

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

    57

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

    58

    59

			// Read riff tags

    60

			for (;;) {

    61

				uint32 tag = FioReadDword();

    62

				uint32 size = FioReadDword();

    63

    64

				if (tag == ' tmf') {

    65

					FioReadWord(); // wFormatTag

    66

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

    67

					FioReadDword();   // samples per second

    68

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

    69

					FioReadDword();   // avg bytes per second

    70

					FioReadWord();    // alignment

    71

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

    72

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

    73

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

    74

					fe->file_size = size;

    75

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

    76

					break;

    77

				} else {

    78

					fe->file_size = 0;

    79

					break;

    80

				}

    81

			}

    82

		} else {

    83

			/*

    84

			 * Special case for the jackhammer sound

    85

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

    86

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

    87

			 */

    88

			fe->channels = 1;

    89

			fe->rate = 11025;

    90

			fe->bits_per_sample = 8;

    91

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

    92

		}

    93

	}

    94

}

    95

    96

uint GetNumOriginalSounds(void)

    97

{

    98

	return _file_count;

    99

}

   100

   101

static bool SetBankSource(MixerChannel *mc, uint bank)

   102

{

   103

	const FileEntry *fe;

   104

	uint i;

   105

   106

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

   107

	fe = GetSound(bank);

   108

   109

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

   110

   111

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

   112

	if (mem == NULL) return false;

   113

   114

	FioSeekToFile(fe->file_offset);

   115

	FioReadBlock(mem, fe->file_size);

   116

   117

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

   118

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

   119

   120

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

   121

   122

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

   123

   124

	return true;

   125

}

   126

   127

bool SoundInitialize(const char *filename)

   128

{

   129

	OpenBankFile(filename);

   130

	return true;

   131

}

   132

   133

// Low level sound player

   134

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

   135

{

   136

	MixerChannel *mc;

   137

	uint left_vol, right_vol;

   138

   139

	if (volume == 0) return;

   140

	mc = MxAllocateChannel();

   141

	if (mc == NULL) return;

   142

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

   143

   144

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

   145

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

   146

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

   147

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

   148

	MxActivateChannel(mc);

   149

}

   150

   151

   152

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

   153

   154

static const byte _sound_base_vol[] = {

   155

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

   156

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

   157

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

   158

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

   159

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

   160

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

   161

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

   162

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

   163

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

   164

	 90,

   165

};

   166

   167

static const byte _sound_idx[] = {

   168

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

   169

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

   170

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

   171

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

   172

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

   173

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

   174

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

   175

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

   176

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

   177

	72,

   178

};

   179

   180

void SndCopyToPool(void)

   181

{

   182

	uint i;

   183

   184

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

   185

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

   186

		FileEntry *fe = AllocateFileEntry();

   187

   188

		*fe = *orig;

   189

		fe->volume = _sound_base_vol[i];

   190

		fe->priority = 0;

   191

	}

   192

}

   193

   194

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

   195

{

   196

	Window* const *wz;

   197

   198

	if (msf.effect_vol == 0) return;

   199

   200

	FOR_ALL_WINDOWS(wz) {

   201

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

   202

   203

		if (vp != NULL &&

   204

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

   205

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

   206

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

   207

   208

			StartSound(

   209

				sound,

   210

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

   211

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

   212

			);

   213

			return;

   214

		}

   215

	}

   216

   217

}

   218

   219

void SndPlayTileFx(SoundFx sound, TileIndex tile)

   220

{

   221

	/* emits sound from center of the tile */

   222

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

   223

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

   224

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

   225

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

   226

}

   227

   228

void SndPlayVehicleFx(SoundFx sound, const Vehicle *v)

   229

{

   230

	SndPlayScreenCoordFx(sound,

   231

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

   232

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

   233

	);

   234

}

   235

   236

void SndPlayFx(SoundFx sound)

   237

{

   238

	StartSound(

   239

		sound,

   240

		0,

   241

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

   242

	);

   243

}