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

    94

MixerChannel *MxAllocateChannel(void)

    95

{

    96

	MixerChannel *mc;

    97

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

    98

		if (mc->memory == NULL) {

    99

			mc->active = false;

   100

			return mc;

   101

		}

   102

	return NULL;

   103

}

   104

   105

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

   106

{

   107

	mc->memory = mem;

   108

	mc->flags = flags;

   109

	mc->frac_pos = 0;

   110

	mc->pos = 0;

   111

   112

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

   113

   114

	// adjust the magnitude to prevent overflow

   115

	while (size & 0xFFFF0000) {

   116

		size >>= 1;

   117

		rate = (rate >> 1) + 1;

   118

	}

   119

   120

	mc->samples_left = size * _play_rate / rate;

   121

}

   122

   123

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

   124

{

   125

	mc->volume_left = left;

   126

	mc->volume_right = right;

   127

}

   128

   129

   130

void MxActivateChannel(MixerChannel* mc)

   131

{

   132

	mc->active = true;

   133

}

   134

   135

   136

bool MxInitialize(uint rate)

   137

{

   138

	_play_rate = rate;

   139

	return true;

   140

}