1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "mixer.h"

     6

     7

struct MixerChannel {

     8

	// Mixer

     9

	Mixer *mx;

    10

	bool active;

    11

    12

	// pointer to allocated buffer memory

    13

	int8 *memory;

    14

    15

	// current position in memory

    16

	uint32 pos;

    17

	uint32 frac_pos;

    18

	uint32 frac_speed;

    19

	uint32 samples_left;

    20

    21

	// Mixing volume

    22

	uint volume_left;

    23

	uint volume_right;

    24

    25

	uint flags;

    26

};

    27

    28

struct Mixer {

    29

	uint32 play_rate;

    30

	MixerChannel channels[8];

    31

};

    32

    33

    34

static void mix_int8_to_int16(MixerChannel *sc, int16 *buffer, uint samples)

    35

{

    36

	int8 *b;

    37

	uint32 frac_pos;

    38

	uint32 frac_speed;

    39

	uint volume_left;

    40

	uint volume_right;

    41

    42

	if (samples > sc->samples_left) samples = sc->samples_left;

    43

	sc->samples_left -= samples;

    44

	assert(samples > 0);

    45

    46

	b = sc->memory + sc->pos;

    47

	frac_pos = sc->frac_pos;

    48

	frac_speed = sc->frac_speed;

    49

	volume_left = sc->volume_left;

    50

	volume_right = sc->volume_right;

    51

    52

	if (frac_speed == 0x10000) {

    53

		// Special case when frac_speed is 0x10000

    54

		do {

    55

			buffer[0] += *b * volume_left >> 8;

    56

			buffer[1] += *b * volume_right >> 8;

    57

			b++;

    58

			buffer += 2;

    59

		} while (--samples > 0);

    60

	} else {

    61

		do {

    62

			buffer[0] += *b * volume_left >> 8;

    63

			buffer[1] += *b * volume_right >> 8;

    64

			buffer += 2;

    65

			frac_pos += frac_speed;

    66

			b += frac_pos >> 16;

    67

			frac_pos &= 0xffff;

    68

		} while (--samples > 0);

    69

	}

    70

    71

	sc->frac_pos = frac_pos;

    72

	sc->pos = b - sc->memory;

    73

}

    74

    75

static void MxCloseChannel(MixerChannel *mc)

    76

{

    77

	if (mc->flags & MX_AUTOFREE) free(mc->memory);

    78

	mc->active = false;

    79

	mc->memory = NULL;

    80

}

    81

    82

void MxMixSamples(Mixer *mx, void *buffer, uint samples)

    83

{

    84

	MixerChannel *mc;

    85

    86

	// Clear the buffer

    87

	memset(buffer, 0, sizeof(int16) * 2 * samples);

    88

    89

	// Mix each channel

    90

	for (mc = mx->channels; mc != endof(mx->channels); mc++) {

    91

		if (mc->active) {

    92

			mix_int8_to_int16(mc, buffer, samples);

    93

			if (mc->samples_left == 0) MxCloseChannel(mc);

    94

		}

    95

	}

    96

    97

	#if 0

    98

	{

    99

		static FILE *out = NULL;

   100

		if (out == NULL)

   101

			out = fopen("d:\\dump.raw", "wb");

   102

		fwrite(buffer, samples * 4, 1, out);

   103

	}

   104

	#endif

   105

}

   106

   107

MixerChannel *MxAllocateChannel(Mixer *mx)

   108

{

   109

	MixerChannel *mc;

   110

	for (mc = mx->channels; mc != endof(mx->channels); mc++)

   111

		if (mc->memory == NULL) {

   112

			mc->active = false;

   113

			mc->mx = mx;

   114

			return mc;

   115

		}

   116

	return NULL;

   117

}

   118

   119

void MxSetChannelRawSrc(MixerChannel *mc, int8 *mem, uint size, uint rate, uint flags)

   120

{

   121

	mc->memory = mem;

   122

	mc->flags = flags;

   123

	mc->frac_pos = 0;

   124

	mc->pos = 0;

   125

   126

	mc->frac_speed = (rate << 16) / mc->mx->play_rate;

   127

   128

	// adjust the magnitude to prevent overflow

   129

	while (size & 0xFFFF0000) {

   130

		size >>= 1;

   131

		rate = (rate >> 1) + 1;

   132

	}

   133

   134

	mc->samples_left = size * mc->mx->play_rate / rate;

   135

}

   136

   137

void MxSetChannelVolume(MixerChannel *mc, uint left, uint right)

   138

{

   139

	mc->volume_left = left;

   140

	mc->volume_right = right;

   141

}

   142

   143

   144

void MxActivateChannel(MixerChannel* mc)

   145

{

   146

	mc->active = true;

   147

}

   148

   149

   150

bool MxInitialize(uint rate)

   151

{

   152

	static Mixer mx;

   153

	_mixer = &mx;

   154

	mx.play_rate = rate;

   155

	return true;

   156

}