1

/* $Id$ */

     2

     3

/** @file mixer.cpp Mixing of sound samples. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "mixer.h"

     8

#include "core/math_func.hpp"

     9

    10

struct MixerChannel {

    11

	bool active;

    12

    13

	/* pointer to allocated buffer memory */

    14

	int8 *memory;

    15

    16

	/* current position in memory */

    17

	uint32 pos;

    18

	uint32 frac_pos;

    19

	uint32 frac_speed;

    20

	uint32 samples_left;

    21

    22

	/* Mixing volume */

    23

	int volume_left;

    24

	int volume_right;

    25

    26

	uint flags;

    27

};

    28

    29

static MixerChannel _channels[8];

    30

static uint32 _play_rate;

    31

    32

/**

    33

 * The theoretical maximum volume for a single sound sample. Multiple sound

    34

 * samples should not exceed this limit as it will sound too loud. It also

    35

 * stops overflowing when too many sounds are played at the same time, which

    36

 * causes an even worse sound quality.

    37

 */

    38

static const int MAX_VOLUME = 128 * 128;

    39

    40

    41

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

    42

{

    43

	int8 *b;

    44

	uint32 frac_pos;

    45

	uint32 frac_speed;

    46

	int volume_left;

    47

	int volume_right;

    48

    49

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

    50

	sc->samples_left -= samples;

    51

	assert(samples > 0);

    52

    53

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

    54

	frac_pos = sc->frac_pos;

    55

	frac_speed = sc->frac_speed;

    56

	volume_left = sc->volume_left;

    57

	volume_right = sc->volume_right;

    58

    59

	if (frac_speed == 0x10000) {

    60

		/* Special case when frac_speed is 0x10000 */

    61

		do {

    62

			buffer[0] = Clamp(buffer[0] + (*b * volume_left  >> 8), -MAX_VOLUME, MAX_VOLUME);

    63

			buffer[1] = Clamp(buffer[1] + (*b * volume_right >> 8), -MAX_VOLUME, MAX_VOLUME);

    64

			b++;

    65

			buffer += 2;

    66

		} while (--samples > 0);

    67

	} else {

    68

		do {

    69

			buffer[0] = Clamp(buffer[0] + (*b * volume_left  >> 8), -MAX_VOLUME, MAX_VOLUME);

    70

			buffer[1] = Clamp(buffer[1] + (*b * volume_right >> 8), -MAX_VOLUME, MAX_VOLUME);

    71

			buffer += 2;

    72

			frac_pos += frac_speed;

    73

			b += frac_pos >> 16;

    74

			frac_pos &= 0xffff;

    75

		} while (--samples > 0);

    76

	}

    77

    78

	sc->frac_pos = frac_pos;

    79

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

    80

}

    81

    82

static void MxCloseChannel(MixerChannel *mc)

    83

{

    84

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

    85

	mc->active = false;

    86

	mc->memory = NULL;

    87

}

    88

    89

void MxMixSamples(void *buffer, uint samples)

    90

{

    91

	MixerChannel *mc;

    92

    93

	/* Clear the buffer */

    94

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

    95

    96

	/* Mix each channel */

    97

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

    98

		if (mc->active) {

    99

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

   100

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

   101

		}

   102

	}

   103

}

   104

   105

MixerChannel *MxAllocateChannel()

   106

{

   107

	MixerChannel *mc;

   108

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

   109

		if (mc->memory == NULL) {

   110

			mc->active = false;

   111

			return mc;

   112

		}

   113

	return NULL;

   114

}

   115

   116

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

   117

{

   118

	mc->memory = mem;

   119

	mc->flags = flags;

   120

	mc->frac_pos = 0;

   121

	mc->pos = 0;

   122

   123

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

   124

   125

	/* adjust the magnitude to prevent overflow */

   126

	while (size & ~0xFFFF) {

   127

		size >>= 1;

   128

		rate = (rate >> 1) + 1;

   129

	}

   130

   131

	mc->samples_left = (uint)size * _play_rate / rate;

   132

}

   133

   134

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

   135

{

   136

	mc->volume_left = left;

   137

	mc->volume_right = right;

   138

}

   139

   140

   141

void MxActivateChannel(MixerChannel* mc)

   142

{

   143

	mc->active = true;

   144

}

   145

   146

   147

bool MxInitialize(uint rate)

   148

{

   149

	_play_rate = rate;

   150

	return true;

   151

}