1

/* $Id$ */

     2

     3

/** @file mixer.cpp*/

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "mixer.h"

     8

     9

struct MixerChannel {

    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

static MixerChannel _channels[8];

    29

static uint32 _play_rate;

    30

    31

    32

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

    33

{

    34

	int8 *b;

    35

	uint32 frac_pos;

    36

	uint32 frac_speed;

    37

	uint volume_left;

    38

	uint volume_right;

    39

    40

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

    41

	sc->samples_left -= samples;

    42

	assert(samples > 0);

    43

    44

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

    45

	frac_pos = sc->frac_pos;

    46

	frac_speed = sc->frac_speed;

    47

	volume_left = sc->volume_left;

    48

	volume_right = sc->volume_right;

    49

    50

	if (frac_speed == 0x10000) {

    51

		/* Special case when frac_speed is 0x10000 */

    52

		do {

    53

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

    54

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

    55

			b++;

    56

			buffer += 2;

    57

		} while (--samples > 0);

    58

	} else {

    59

		do {

    60

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

    61

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

    62

			buffer += 2;

    63

			frac_pos += frac_speed;

    64

			b += frac_pos >> 16;

    65

			frac_pos &= 0xffff;

    66

		} while (--samples > 0);

    67

	}

    68

    69

	sc->frac_pos = frac_pos;

    70

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

    71

}

    72

    73

static void MxCloseChannel(MixerChannel *mc)

    74

{

    75

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

    76

	mc->active = false;

    77

	mc->memory = NULL;

    78

}

    79

    80

void MxMixSamples(void *buffer, uint samples)

    81

{

    82

	MixerChannel *mc;

    83

    84

	/* Clear the buffer */

    85

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

    86

    87

	/* Mix each channel */

    88

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

    89

		if (mc->active) {

    90

			mix_int8_to_int16(mc, (int16*)buffer, samples);

    91

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

    92

		}

    93

	}

    94

}

    95

    96

MixerChannel *MxAllocateChannel()

    97

{

    98

	MixerChannel *mc;

    99

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

   100

		if (mc->memory == NULL) {

   101

			mc->active = false;

   102

			return mc;

   103

		}

   104

	return NULL;

   105

}

   106

   107

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

   108

{

   109

	mc->memory = mem;

   110

	mc->flags = flags;

   111

	mc->frac_pos = 0;

   112

	mc->pos = 0;

   113

   114

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

   115

   116

	/* adjust the magnitude to prevent overflow */

   117

	while (size & 0xFFFF0000) {

   118

		size >>= 1;

   119

		rate = (rate >> 1) + 1;

   120

	}

   121

   122

	mc->samples_left = size * _play_rate / rate;

   123

}

   124

   125

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

   126

{

   127

	mc->volume_left = left;

   128

	mc->volume_right = right;

   129

}

   130

   131

   132

void MxActivateChannel(MixerChannel* mc)

   133

{

   134

	mc->active = true;

   135

}

   136

   137

   138

bool MxInitialize(uint rate)

   139

{

   140

	_play_rate = rate;

   141

	return true;

   142

}