1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "mixer.h"

     6

     7

struct MixerChannel {

     8

	bool active;

     9

    10

	// pointer to allocated buffer memory

    11

	int8 *memory;

    12

    13

	// current position in memory

    14

	uint32 pos;

    15

	uint32 frac_pos;

    16

	uint32 frac_speed;

    17

	uint32 samples_left;

    18

    19

	// Mixing volume

    20

	uint volume_left;

    21

	uint volume_right;

    22

    23

	uint flags;

    24

};

    25

    26

static MixerChannel _channels[8];

    27

static uint32 _play_rate;

    28

    29

    30

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

    31

{

    32

	int8 *b;

    33

	uint32 frac_pos;

    34

	uint32 frac_speed;

    35

	uint volume_left;

    36

	uint volume_right;

    37

    38

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

    39

	sc->samples_left -= samples;

    40

	assert(samples > 0);

    41

    42

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

    43

	frac_pos = sc->frac_pos;

    44

	frac_speed = sc->frac_speed;

    45

	volume_left = sc->volume_left;

    46

	volume_right = sc->volume_right;

    47

    48

	if (frac_speed == 0x10000) {

    49

		// Special case when frac_speed is 0x10000

    50

		do {

    51

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

    52

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

    53

			b++;

    54

			buffer += 2;

    55

		} while (--samples > 0);

    56

	} else {

    57

		do {

    58

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

    59

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

    60

			buffer += 2;

    61

			frac_pos += frac_speed;

    62

			b += frac_pos >> 16;

    63

			frac_pos &= 0xffff;

    64

		} while (--samples > 0);

    65

	}

    66

    67

	sc->frac_pos = frac_pos;

    68

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

    69

}

    70

    71

static void MxCloseChannel(MixerChannel *mc)

    72

{

    73

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

    74

	mc->active = false;

    75

	mc->memory = NULL;

    76

}

    77

    78

void MxMixSamples(void *buffer, uint samples)

    79

{

    80

	MixerChannel *mc;

    81

    82

	// Clear the buffer

    83

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

    84

    85

	// Mix each channel

    86

	for (mc = _channels; mc != endof(_channels); mc++) {

    87

		if (mc->active) {

    88

			mix_int8_to_int16(mc, buffer, samples);

    89

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

    90

		}

    91

	}

    92

    93

	#if 0

    94

	{

    95

		static FILE *out = NULL;

    96

		if (out == NULL)

    97

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

    98

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

    99

	}

   100

	#endif

   101

}

   102

   103

MixerChannel *MxAllocateChannel(void)

   104

{

   105

	MixerChannel *mc;

   106

	for (mc = _channels; mc != endof(_channels); mc++)

   107

		if (mc->memory == NULL) {

   108

			mc->active = false;

   109

			return mc;

   110

		}

   111

	return NULL;

   112

}

   113

   114

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

   115

{

   116

	mc->memory = mem;

   117

	mc->flags = flags;

   118

	mc->frac_pos = 0;

   119

	mc->pos = 0;

   120

   121

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

   122

   123

	// adjust the magnitude to prevent overflow

   124

	while (size & 0xFFFF0000) {

   125

		size >>= 1;

   126

		rate = (rate >> 1) + 1;

   127

	}

   128

   129

	mc->samples_left = size * _play_rate / rate;

   130

}

   131

   132

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

   133

{

   134

	mc->volume_left = left;

   135

	mc->volume_right = right;

   136

}

   137

   138

   139

void MxActivateChannel(MixerChannel* mc)

   140

{

   141

	mc->active = true;

   142

}

   143

   144

   145

bool MxInitialize(uint rate)

   146

{

   147

	_play_rate = rate;

   148

	return true;

   149

}