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_func.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

/** The number of sounds in the original sample.cat */

    27

static const uint ORIGINAL_SAMPLE_COUNT = 73;

    28

    29

static void OpenBankFile(const char *filename)

    30

{

    31

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

    32

	_file_count = ORIGINAL_SAMPLE_COUNT;

    33

	_files = fe;

    34

    35

	FioOpenFile(SOUND_SLOT, filename);

    36

	size_t pos = FioGetPos();

    37

	uint count = FioReadDword() / 8;

    38

    39

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

    40

	if (count != ORIGINAL_SAMPLE_COUNT) {

    41

		/* Corrupt sample data? Just leave the allocated memory as those tell

    42

		 * there is no sound to play (size = 0 due to calloc). Not allocating

    43

		 * the memory disables valid NewGRFs that replace sounds. */

    44

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

    45

		return;

    46

	}

    47

    48

	FioSeekTo(pos, SEEK_SET);

    49

    50

	for (uint i = 0; i != ORIGINAL_SAMPLE_COUNT; i++) {

    51

		fe[i].file_slot = SOUND_SLOT;

    52

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

    53

		fe[i].file_size = FioReadDword();

    54

	}

    55

    56

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

    57

		char name[255];

    58

    59

		FioSeekTo(fe->file_offset, SEEK_SET);

    60

    61

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

    62

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

    63

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

    64

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

    65

    66

			/* Read riff tags */

    67

			for (;;) {

    68

				uint32 tag = FioReadDword();

    69

				uint32 size = FioReadDword();

    70

    71

				if (tag == ' tmf') {

    72

					FioReadWord(); // wFormatTag

    73

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

    74

					FioReadDword();   // samples per second

    75

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

    76

					FioReadDword();   // avg bytes per second

    77

					FioReadWord();    // alignment

    78

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

    79

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

    80

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

    81

					fe->file_size = size;

    82

					fe->file_slot = SOUND_SLOT;

    83

					fe->file_offset = FioGetPos();

    84

					break;

    85

				} else {

    86

					fe->file_size = 0;

    87

					break;

    88

				}

    89

			}

    90

		} else {

    91

			/*

    92

			 * Special case for the jackhammer sound

    93

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

    94

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

    95

			 */

    96

			fe->channels = 1;

    97

			fe->rate = 11025;

    98

			fe->bits_per_sample = 8;

    99

			fe->file_slot = SOUND_SLOT;

   100

			fe->file_offset = FioGetPos();

   101

		}

   102

	}

   103

}

   104

   105

uint GetNumOriginalSounds()

   106

{

   107

	return _file_count;

   108

}

   109

   110

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

   111

{

   112

	assert(fe != NULL);

   113

   114

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

   115

   116

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

   117

	if (mem == NULL) return false;

   118

   119

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

   120

	FioReadBlock(mem, fe->file_size);

   121

   122

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

   123

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

   124

	}

   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

	if (volume == 0) return;

   143

   144

	const FileEntry *fe = GetSound(sound);

   145

	if (fe == NULL) return;

   146

   147

	MixerChannel *mc = MxAllocateChannel();

   148

	if (mc == NULL) return;

   149

   150

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

   151

   152

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

   153

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

   154

   155

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

   156

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

   157

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

   158

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

   159

	MxActivateChannel(mc);

   160

}

   161

   162

   163

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

   164

assert_compile(lengthof(_vol_factor_by_zoom) == ZOOM_LVL_COUNT);

   165

   166

static const byte _sound_base_vol[] = {

   167

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

   168

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

   169

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

   170

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

   171

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

   172

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

   173

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

   174

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

   175

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

   176

	 90,

   177

};

   178

   179

static const byte _sound_idx[] = {

   180

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

   181

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

   182

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

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

	72,

   190

};

   191

   192

void SndCopyToPool()

   193

{

   194

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

   195

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

   196

		FileEntry *fe = AllocateFileEntry();

   197

   198

		*fe = *orig;

   199

		fe->volume = _sound_base_vol[i];

   200

		fe->priority = 0;

   201

	}

   202

}

   203

   204

/**

   205

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

   206

 * @param sound Sound effect to play

   207

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

   208

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

   209

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

   210

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

   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

void SndPlayTileFx(SoundFx sound, TileIndex tile)

   239

{

   240

	/* emits sound from center of the tile */

   241

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

   242

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

   243

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

   244

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

   245

	y += 2 * TILE_SIZE;

   246

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

   247

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

   248

}

   249

   250

void SndPlayVehicleFx(SoundFx sound, const Vehicle *v)

   251

{

   252

	SndPlayScreenCoordFx(sound,

   253

		v->left_coord, v->right_coord,

   254

		v->top_coord, v->top_coord

   255

	);

   256

}

   257

   258

void SndPlayFx(SoundFx sound)

   259

{

   260

	StartSound(sound, 0, msf.effect_vol);

   261

}