1

/* $Id$ */

     2

     3

/** @file sound.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "landscape.h"

     8

#include "mixer.h"

     9

#include "sound_func.h"

    10

#include "fileio.h"

    11

#include "newgrf_sound.h"

    12

#include "fios.h"

    13

#include "window_gui.h"

    14

#include "core/alloc_func.hpp"

    15

#include "map_func.h"

    16

#include "vehicle_base.h"

    17

    18

static uint _file_count;

    19

static FileEntry *_files;

    20

MusicFileSettings msf;

    21

    22

// Number of levels of panning per side

    23

#define PANNING_LEVELS 16

    24

    25

    26

static void OpenBankFile(const char *filename)

    27

{

    28

	uint count;

    29

	uint i;

    30

    31

	FioOpenFile(SOUND_SLOT, filename);

    32

	uint pos = FioGetPos();

    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(pos, SEEK_SET);

    46

    47

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

    48

		fe[i].file_slot = SOUND_SLOT;

    49

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

    50

		fe[i].file_size = FioReadDword();

    51

	}

    52

    53

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

    54

		char name[255];

    55

    56

		FioSeekTo(fe->file_offset, SEEK_SET);

    57

    58

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

    59

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

    60

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

    61

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

    62

    63

			/* Read riff tags */

    64

			for (;;) {

    65

				uint32 tag = FioReadDword();

    66

				uint32 size = FioReadDword();

    67

    68

				if (tag == ' tmf') {

    69

					FioReadWord(); // wFormatTag

    70

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

    71

					FioReadDword();   // samples per second

    72

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

    73

					FioReadDword();   // avg bytes per second

    74

					FioReadWord();    // alignment

    75

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

    76

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

    77

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

    78

					fe->file_size = size;

    79

					fe->file_slot = SOUND_SLOT;

    80

					fe->file_offset = FioGetPos();

    81

					break;

    82

				} else {

    83

					fe->file_size = 0;

    84

					break;

    85

				}

    86

			}

    87

		} else {

    88

			/*

    89

			 * Special case for the jackhammer sound

    90

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

    91

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

    92

			 */

    93

			fe->channels = 1;

    94

			fe->rate = 11025;

    95

			fe->bits_per_sample = 8;

    96

			fe->file_slot = SOUND_SLOT;

    97

			fe->file_offset = FioGetPos();

    98

		}

    99

	}

   100

}

   101

   102

uint GetNumOriginalSounds()

   103

{

   104

	return _file_count;

   105

}

   106

   107

static bool SetBankSource(MixerChannel *mc, uint bank)

   108

{

   109

	const FileEntry *fe;

   110

	uint i;

   111

   112

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

   113

	fe = GetSound(bank);

   114

   115

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

   116

   117

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

   118

	if (mem == NULL) return false;

   119

   120

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

   121

	FioReadBlock(mem, fe->file_size);

   122

   123

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

   124

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

   125

   126

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

   127

   128

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

   129

   130

	return true;

   131

}

   132

   133

bool SoundInitialize(const char *filename)

   134

{

   135

	OpenBankFile(filename);

   136

	return true;

   137

}

   138

   139

/* Low level sound player */

   140

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

   141

{

   142

	MixerChannel *mc;

   143

	uint left_vol, right_vol;

   144

   145

	if (volume == 0) return;

   146

	mc = MxAllocateChannel();

   147

	if (mc == NULL) return;

   148

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

   149

   150

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

   151

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

   152

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

   153

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

   154

	MxActivateChannel(mc);

   155

}

   156

   157

   158

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

   159

assert_compile(lengthof(_vol_factor_by_zoom) == ZOOM_LVL_END - ZOOM_LVL_BEGIN);

   160

   161

static const byte _sound_base_vol[] = {

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

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

   169

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

   170

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

   171

	 90,

   172

};

   173

   174

static const byte _sound_idx[] = {

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

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

   184

	72,

   185

};

   186

   187

void SndCopyToPool()

   188

{

   189

	uint i;

   190

   191

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

   192

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

   193

		FileEntry *fe = AllocateFileEntry();

   194

   195

		*fe = *orig;

   196

		fe->volume = _sound_base_vol[i];

   197

		fe->priority = 0;

   198

	}

   199

}

   200

   201

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

   202

{

   203

	Window* const *wz;

   204

   205

	if (msf.effect_vol == 0) return;

   206

   207

	FOR_ALL_WINDOWS(wz) {

   208

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

   209

   210

		if (vp != NULL &&

   211

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

   212

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

   213

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

   214

   215

			StartSound(

   216

				sound,

   217

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

   218

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

   219

			);

   220

			return;

   221

		}

   222

	}

   223

   224

}

   225

   226

void SndPlayTileFx(SoundFx sound, TileIndex tile)

   227

{

   228

	/* emits sound from center of the tile */

   229

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

   230

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

   231

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

   232

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

   233

}

   234

   235

void SndPlayVehicleFx(SoundFx sound, const Vehicle *v)

   236

{

   237

	SndPlayScreenCoordFx(sound,

   238

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

   239

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

   240

	);

   241

}

   242

   243

void SndPlayFx(SoundFx sound)

   244

{

   245

	StartSound(

   246

		sound,

   247

		0,

   248

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

   249

	);

   250

}