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

    14

typedef struct FileEntry {

    15

	uint32 file_offset;

    16

	uint32 file_size;

    17

	uint16 rate;

    18

	uint8 bits_per_sample;

    19

	uint8 channels;

    20

} FileEntry;

    21

    22

static uint _file_count;

    23

static FileEntry* _files;

    24

    25

#define SOUND_SLOT 31

    26

// Number of levels of panning per side

    27

#define PANNING_LEVELS 16

    28

    29

    30

static void OpenBankFile(const char *filename)

    31

{

    32

	FileEntry* fe;

    33

	uint count;

    34

	uint i;

    35

    36

	FioOpenFile(SOUND_SLOT, filename);

    37

	count = FioReadDword() / 8;

    38

	fe = calloc(sizeof(*fe), count);

    39

    40

	if (fe == NULL) {

    41

		_file_count = 0;

    42

		_files = NULL;

    43

		return;

    44

	}

    45

    46

	_file_count = count;

    47

	_files = fe;

    48

    49

	FioSeekTo(0, SEEK_SET);

    50

    51

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

    52

		fe[i].file_offset = FioReadDword();

    53

		fe[i].file_size = FioReadDword();

    54

	}

    55

    56

	for (i = 0; i != 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_offset = FioGetPos() | (SOUND_SLOT << 24);

    83

					break;

    84

				} else {

    85

					fe->file_size = 0;

    86

					break;

    87

				}

    88

			}

    89

		} else {

    90

			/*

    91

			 * Special case for the jackhammer sound

    92

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

    93

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

    94

			 */

    95

			fe->channels = 1;

    96

			fe->rate = 11025;

    97

			fe->bits_per_sample = 8;

    98

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

    99

		}

   100

	}

   101

}

   102

   103

static bool SetBankSource(MixerChannel *mc, uint bank)

   104

{

   105

	FileEntry* fe;

   106

	int8* mem;

   107

	uint i;

   108

   109

	if (bank >= _file_count) return false;

   110

	fe = &_files[bank];

   111

   112

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

   113

   114

	mem = malloc(fe->file_size);

   115

	if (mem == NULL) return false;

   116

   117

	FioSeekToFile(fe->file_offset);

   118

	FioReadBlock(mem, fe->file_size);

   119

   120

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

   121

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

   122

   123

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

   124

   125

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

   126

   127

	return true;

   128

}

   129

   130

bool SoundInitialize(const char *filename)

   131

{

   132

	OpenBankFile(filename);

   133

	return true;

   134

}

   135

   136

// Low level sound player

   137

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

   138

{

   139

	MixerChannel* mc;

   140

	uint left_vol, right_vol;

   141

   142

	if (volume == 0) return;

   143

	mc = MxAllocateChannel(_mixer);

   144

	if (mc == NULL) return;

   145

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

   146

   147

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

   148

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

   149

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

   150

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

   151

	MxActivateChannel(mc);

   152

}

   153

   154

   155

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

   156

   157

static const byte _sound_base_vol[] = {

   158

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

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

	 90,

   168

};

   169

   170

static const byte _sound_idx[] = {

   171

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

   172

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

   173

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

   174

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

   175

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

   176

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

   177

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

   178

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

   179

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

   180

	72,

   181

};

   182

   183

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

   184

{

   185

	const Window* w;

   186

   187

	if (msf.effect_vol == 0) return;

   188

   189

	for (w = _windows; w != _last_window; w++) {

   190

		const ViewPort* vp = w->viewport;

   191

   192

		if (vp != NULL &&

   193

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

   194

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

   195

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

   196

   197

			StartSound(

   198

				_sound_idx[sound],

   199

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

   200

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

   201

			);

   202

			return;

   203

		}

   204

	}

   205

   206

}

   207

   208

void SndPlayTileFx(SoundFx sound, TileIndex tile)

   209

{

   210

	/* emits sound from center (+ 8) of the tile */

   211

	int x = TileX(tile) * 16 + 8;

   212

	int y = TileY(tile) * 16 + 8;

   213

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

   214

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

   215

}

   216

   217

void SndPlayVehicleFx(SoundFx sound, const Vehicle *v)

   218

{

   219

	SndPlayScreenCoordFx(sound,

   220

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

   221

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

   222

	);

   223

}

   224

   225

void SndPlayFx(SoundFx sound)

   226

{

   227

	StartSound(

   228

		_sound_idx[sound],

   229

		0,

   230

		(_sound_base_vol[sound] * msf.effect_vol) >> 7

   231

	);

   232

}