1

/* $Id$ */

     2

     3

/** @file sound.cpp Handling of playing sounds. */

     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

	size_t 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_COUNT);

   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

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

   201

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

   202

		FileEntry *fe = AllocateFileEntry();

   203

   204

		*fe = *orig;

   205

		fe->volume = _sound_base_vol[i];

   206

		fe->priority = 0;

   207

	}

   208

}

   209

   210

/**

   211

 * Decide 'where' (between left and right speaker) to play the sound effect.

   212

 * @param sound Sound effect to play

   213

 * @param left   Left edge of virtual coordinates where the sound is produced

   214

 * @param right  Right edge of virtual coordinates where the sound is produced

   215

 * @param top    Top edge of virtual coordinates where the sound is produced

   216

 * @param bottom Bottom edge of virtual coordinates where the sound is produced

   217

 */

   218

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

   219

{

   220

	Window* const *wz;

   221

   222

	if (msf.effect_vol == 0) return;

   223

   224

	FOR_ALL_WINDOWS(wz) {

   225

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

   226

   227

		if (vp != NULL &&

   228

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

   229

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

   230

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

   231

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

   232

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

   233

   234

			StartSound(

   235

				sound,

   236

				panning,

   237

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

   238

			);

   239

			return;

   240

		}

   241

	}

   242

}

   243

   244

void SndPlayTileFx(SoundFx sound, TileIndex tile)

   245

{

   246

	/* emits sound from center of the tile */

   247

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

   248

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

   249

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

   250

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

   251

	y += 2 * TILE_SIZE;

   252

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

   253

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

   254

}

   255

   256

void SndPlayVehicleFx(SoundFx sound, const Vehicle *v)

   257

{

   258

	SndPlayScreenCoordFx(sound,

   259

		v->left_coord, v->right_coord,

   260

		v->top_coord, v->top_coord

   261

	);

   262

}

   263

   264

void SndPlayFx(SoundFx sound)

   265

{

   266

	StartSound(sound, 0, msf.effect_vol);

   267

}