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

#include "debug.h"

    18

    19

static uint _file_count;

    20

static FileEntry *_files;

    21

MusicFileSettings msf;

    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 i;

    30

    31

	FioOpenFile(SOUND_SLOT, filename);

    32

	uint pos = FioGetPos();

    33

	uint count = FioReadDword() / 8;

    34

    35

	/* Simple check for the correct number of original sounds. */

    36

	if (count != 73) {

    37

		DEBUG(misc, 6, "Incorrect number of sounds in '%s', ignoring.", filename);

    38

		_file_count = 0;

    39

		_files = NULL;

    40

		return;

    41

	}

    42

    43

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

    44

    45

	if (fe == NULL) {

    46

		_file_count = 0;

    47

		_files = NULL;

    48

		return;

    49

	}

    50

    51

	_file_count = count;

    52

	_files = fe;

    53

    54

	FioSeekTo(pos, SEEK_SET);

    55

    56

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

    57

		fe[i].file_slot = SOUND_SLOT;

    58

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

    59

		fe[i].file_size = FioReadDword();

    60

	}

    61

    62

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

    63

		char name[255];

    64

    65

		FioSeekTo(fe->file_offset, SEEK_SET);

    66

    67

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

    68

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

    69

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

    70

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

    71

    72

			/* Read riff tags */

    73

			for (;;) {

    74

				uint32 tag = FioReadDword();

    75

				uint32 size = FioReadDword();

    76

    77

				if (tag == ' tmf') {

    78

					FioReadWord(); // wFormatTag

    79

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

    80

					FioReadDword();   // samples per second

    81

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

    82

					FioReadDword();   // avg bytes per second

    83

					FioReadWord();    // alignment

    84

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

    85

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

    86

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

    87

					fe->file_size = size;

    88

					fe->file_slot = SOUND_SLOT;

    89

					fe->file_offset = FioGetPos();

    90

					break;

    91

				} else {

    92

					fe->file_size = 0;

    93

					break;

    94

				}

    95

			}

    96

		} else {

    97

			/*

    98

			 * Special case for the jackhammer sound

    99

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

   100

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

   101

			 */

   102

			fe->channels = 1;

   103

			fe->rate = 11025;

   104

			fe->bits_per_sample = 8;

   105

			fe->file_slot = SOUND_SLOT;

   106

			fe->file_offset = FioGetPos();

   107

		}

   108

	}

   109

}

   110

   111

uint GetNumOriginalSounds()

   112

{

   113

	return _file_count;

   114

}

   115

   116

static bool SetBankSource(MixerChannel *mc, const FileEntry *fe)

   117

{

   118

	assert(fe != NULL);

   119

   120

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

   121

   122

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

   123

	if (mem == NULL) return false;

   124

   125

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

   126

	FioReadBlock(mem, fe->file_size);

   127

   128

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

   129

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

   130

	}

   131

   132

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

   133

   134

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

   135

   136

	return true;

   137

}

   138

   139

bool SoundInitialize(const char *filename)

   140

{

   141

	OpenBankFile(filename);

   142

	return true;

   143

}

   144

   145

/* Low level sound player */

   146

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

   147

{

   148

	if (volume == 0) return;

   149

   150

	const FileEntry *fe = GetSound(sound);

   151

	if (fe == NULL) return;

   152

   153

	MixerChannel *mc = MxAllocateChannel();

   154

	if (mc == NULL) return;

   155

   156

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

   157

   158

	/* Apply the sound effect's own volume. */

   159

	volume = (fe->volume * volume) / 128;

   160

   161

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

   162

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

   163

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

   164

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

   165

	MxActivateChannel(mc);

   166

}

   167

   168

   169

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

   170

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

   171

   172

static const byte _sound_base_vol[] = {

   173

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

   174

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

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

	 90,

   183

};

   184

   185

static const byte _sound_idx[] = {

   186

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

   187

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

   188

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

   189

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

   190

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

   191

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

   192

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

   193

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

   194

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

   195

	72,

   196

};

   197

   198

void SndCopyToPool()

   199

{

   200

	uint i;

   201

   202

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

   203

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

   204

		FileEntry *fe = AllocateFileEntry();

   205

   206

		*fe = *orig;

   207

		fe->volume = _sound_base_vol[i];

   208

		fe->priority = 0;

   209

	}

   210

}

   211

   212

static void SndPlayScreenCoordFx(SoundFx sound, int left, int right, int top, int bottom)

   213

{

   214

	Window* const *wz;

   215

   216

	if (msf.effect_vol == 0) return;

   217

   218

	FOR_ALL_WINDOWS(wz) {

   219

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

   220

   221

		if (vp != NULL &&

   222

				left < vp->virtual_left + vp->virtual_width && right > vp->virtual_left &&

   223

				top < vp->virtual_top + vp->virtual_height && bottom > vp->virtual_top) {

   224

			int screen_x = (left + right) / 2 - vp->virtual_left;

   225

			int width = (vp->virtual_width == 0 ? 1 : vp->virtual_width);

   226

			int panning = (screen_x * PANNING_LEVELS * 2) / width - PANNING_LEVELS;

   227

   228

			StartSound(

   229

				sound,

   230

				panning,

   231

				(msf.effect_vol * _vol_factor_by_zoom[vp->zoom - ZOOM_LVL_BEGIN]) / 256

   232

			);

   233

			return;

   234

		}

   235

	}

   236

   237

}

   238

   239

void SndPlayTileFx(SoundFx sound, TileIndex tile)

   240

{

   241

	/* emits sound from center of the tile */

   242

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

   243

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

   244

	uint z = (y < 0 ? 0 : GetSlopeZ(x, y));

   245

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

   246

	y += 2 * TILE_SIZE;

   247

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

   248

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

   249

}

   250

   251

void SndPlayVehicleFx(SoundFx sound, const Vehicle *v)

   252

{

   253

	SndPlayScreenCoordFx(sound,

   254

		v->left_coord, v->right_coord,

   255

		v->top_coord, v->top_coord

   256

	);

   257

}

   258

   259

void SndPlayFx(SoundFx sound)

   260

{

   261

	StartSound(sound, 0, msf.effect_vol);

   262

}