Revision 2dd1dd53000918abba04156845fce2f50182657e authored by Sven Hesse on 30 July 2007, 19:54:51 UTC, committed by Sven Hesse on 30 July 2007, 19:54:51 UTC
svn-id: r28338
1 parent 3cddad3
mixer.cpp
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
#include "common/stdafx.h"
#include "common/file.h"
#include "common/util.h"
#include "common/system.h"
#include "sound/mixer.h"
#include "sound/rate.h"
#include "sound/audiostream.h"
namespace Audio {
#pragma mark -
#pragma mark --- Channel classes ---
#pragma mark -
/**
* Channels used by the sound mixer.
*/
class Channel {
public:
const Mixer::SoundType _type;
SoundHandle _handle;
private:
Mixer *_mixer;
bool _autofreeStream;
bool _permanent;
byte _volume;
int8 _balance;
int _pauseLevel;
int _id;
uint32 _samplesConsumed;
uint32 _samplesDecoded;
uint32 _mixerTimeStamp;
protected:
RateConverter *_converter;
AudioStream *_input;
public:
Channel(Mixer *mixer, Mixer::SoundType type, AudioStream *input, bool autofreeStream, bool reverseStereo = false, int id = -1, bool permanent = false);
virtual ~Channel();
void mix(int16 *data, uint len);
bool isPermanent() const {
return _permanent;
}
bool isFinished() const {
return _input->endOfStream();
}
void pause(bool paused) {
//assert((paused && _pauseLevel >= 0) || (!paused && _pauseLevel));
if (paused)
_pauseLevel++;
else if (_pauseLevel > 0)
_pauseLevel--;
}
bool isPaused() {
return _pauseLevel != 0;
}
void setVolume(const byte volume) {
_volume = volume;
}
void setBalance(const int8 balance) {
_balance = balance;
}
int getId() const {
return _id;
}
uint32 getElapsedTime();
};
#pragma mark -
#pragma mark --- Mixer ---
#pragma mark -
Mixer::Mixer() {
_syst = g_system;
_handleSeed = 0;
int i = 0;
for (i = 0; i < ARRAYSIZE(_volumeForSoundType); i++)
_volumeForSoundType[i] = kMaxMixerVolume;
for (i = 0; i != NUM_CHANNELS; i++)
_channels[i] = 0;
_mixerReady = false;
}
Mixer::~Mixer() {
for (int i = 0; i != NUM_CHANNELS; i++)
delete _channels[i];
}
uint Mixer::getOutputRate() const {
return (uint)_syst->getOutputSampleRate();
}
void Mixer::insertChannel(SoundHandle *handle, Channel *chan) {
int index = -1;
for (int i = 0; i != NUM_CHANNELS; i++) {
if (_channels[i] == 0) {
index = i;
break;
}
}
if (index == -1) {
warning("Mixer::out of mixer slots");
delete chan;
return;
}
_channels[index] = chan;
chan->_handle._val = index + (_handleSeed * NUM_CHANNELS);
_handleSeed++;
if (handle) {
*handle = chan->_handle;
}
}
void Mixer::playRaw(
SoundType type,
SoundHandle *handle,
void *sound,
uint32 size, uint rate, byte flags,
int id, byte volume, int8 balance,
uint32 loopStart, uint32 loopEnd) {
// Create the input stream
AudioStream *input = makeLinearInputStream((byte *)sound, size, rate, flags, loopStart, loopEnd);
// Play it
playInputStream(type, handle, input, id, volume, balance, true, false, ((flags & Mixer::FLAG_REVERSE_STEREO) != 0));
}
void Mixer::playInputStream(
SoundType type,
SoundHandle *handle,
AudioStream *input,
int id, byte volume, int8 balance,
bool autofreeStream,
bool permanent,
bool reverseStereo) {
Common::StackLock lock(_mutex);
if (input == 0) {
warning("input stream is 0");
return;
}
// Prevent duplicate sounds
if (id != -1) {
for (int i = 0; i != NUM_CHANNELS; i++)
if (_channels[i] != 0 && _channels[i]->getId() == id) {
if (autofreeStream)
delete input;
return;
}
}
// Create the channel
Channel *chan = new Channel(this, type, input, autofreeStream, reverseStereo, id, permanent);
chan->setVolume(volume);
chan->setBalance(balance);
insertChannel(handle, chan);
}
void Mixer::mix(int16 *buf, uint len) {
Common::StackLock lock(_mutex);
// Since the mixer callback has been called, the mixer must be ready...
_mixerReady = true;
// zero the buf
memset(buf, 0, 2 * len * sizeof(int16));
// mix all channels
for (int i = 0; i != NUM_CHANNELS; i++)
if (_channels[i]) {
if (_channels[i]->isFinished()) {
delete _channels[i];
_channels[i] = 0;
} else if (!_channels[i]->isPaused())
_channels[i]->mix(buf, len);
}
}
void Mixer::mixCallback(void *s, byte *samples, int len) {
assert(s);
assert(samples);
// Len is the number of bytes in the buffer; we divide it by
// four to get the number of samples (stereo 16 bit).
((Mixer *)s)->mix((int16 *)samples, len >> 2);
}
void Mixer::stopAll() {
Common::StackLock lock(_mutex);
for (int i = 0; i != NUM_CHANNELS; i++) {
if (_channels[i] != 0 && !_channels[i]->isPermanent()) {
delete _channels[i];
_channels[i] = 0;
}
}
}
void Mixer::stopID(int id) {
Common::StackLock lock(_mutex);
for (int i = 0; i != NUM_CHANNELS; i++) {
if (_channels[i] != 0 && _channels[i]->getId() == id) {
delete _channels[i];
_channels[i] = 0;
}
}
}
void Mixer::stopHandle(SoundHandle handle) {
Common::StackLock lock(_mutex);
// Simply ignore stop requests for handles of sounds that already terminated
const int index = handle._val % NUM_CHANNELS;
if (!_channels[index] || _channels[index]->_handle._val != handle._val)
return;
delete _channels[index];
_channels[index] = 0;
}
void Mixer::setChannelVolume(SoundHandle handle, byte volume) {
Common::StackLock lock(_mutex);
const int index = handle._val % NUM_CHANNELS;
if (!_channels[index] || _channels[index]->_handle._val != handle._val)
return;
_channels[index]->setVolume(volume);
}
void Mixer::setChannelBalance(SoundHandle handle, int8 balance) {
Common::StackLock lock(_mutex);
const int index = handle._val % NUM_CHANNELS;
if (!_channels[index] || _channels[index]->_handle._val != handle._val)
return;
_channels[index]->setBalance(balance);
}
uint32 Mixer::getSoundElapsedTime(SoundHandle handle) {
Common::StackLock lock(_mutex);
const int index = handle._val % NUM_CHANNELS;
if (!_channels[index] || _channels[index]->_handle._val != handle._val)
return 0;
return _channels[index]->getElapsedTime();
}
void Mixer::pauseAll(bool paused) {
Common::StackLock lock(_mutex);
for (int i = 0; i != NUM_CHANNELS; i++) {
if (_channels[i] != 0) {
_channels[i]->pause(paused);
}
}
}
void Mixer::pauseID(int id, bool paused) {
Common::StackLock lock(_mutex);
for (int i = 0; i != NUM_CHANNELS; i++) {
if (_channels[i] != 0 && _channels[i]->getId() == id) {
_channels[i]->pause(paused);
return;
}
}
}
void Mixer::pauseHandle(SoundHandle handle, bool paused) {
Common::StackLock lock(_mutex);
// Simply ignore (un)pause requests for sounds that already terminated
const int index = handle._val % NUM_CHANNELS;
if (!_channels[index] || _channels[index]->_handle._val != handle._val)
return;
_channels[index]->pause(paused);
}
bool Mixer::isSoundIDActive(int id) {
Common::StackLock lock(_mutex);
for (int i = 0; i != NUM_CHANNELS; i++)
if (_channels[i] && _channels[i]->getId() == id)
return true;
return false;
}
int Mixer::getSoundID(SoundHandle handle) {
Common::StackLock lock(_mutex);
const int index = handle._val % NUM_CHANNELS;
if (_channels[index] && _channels[index]->_handle._val == handle._val)
return _channels[index]->getId();
return 0;
}
bool Mixer::isSoundHandleActive(SoundHandle handle) {
Common::StackLock lock(_mutex);
const int index = handle._val % NUM_CHANNELS;
return _channels[index] && _channels[index]->_handle._val == handle._val;
}
bool Mixer::hasActiveChannelOfType(SoundType type) {
Common::StackLock lock(_mutex);
for (int i = 0; i != NUM_CHANNELS; i++)
if (_channels[i] && _channels[i]->_type == type)
return true;
return false;
}
void Mixer::setVolumeForSoundType(SoundType type, int volume) {
assert(0 <= type && type < ARRAYSIZE(_volumeForSoundType));
// Check range
if (volume > kMaxMixerVolume)
volume = kMaxMixerVolume;
else if (volume < 0)
volume = 0;
// TODO: Maybe we should do logarithmic (not linear) volume
// scaling? See also Player_V2::setMasterVolume
_volumeForSoundType[type] = volume;
}
int Mixer::getVolumeForSoundType(SoundType type) const {
assert(0 <= type && type < ARRAYSIZE(_volumeForSoundType));
return _volumeForSoundType[type];
}
#pragma mark -
#pragma mark --- Channel implementations ---
#pragma mark -
Channel::Channel(Mixer *mixer, Mixer::SoundType type, AudioStream *input,
bool autofreeStream, bool reverseStereo, int id, bool permanent)
: _type(type), _mixer(mixer), _autofreeStream(autofreeStream),
_volume(Mixer::kMaxChannelVolume), _balance(0), _pauseLevel(0), _id(id), _samplesConsumed(0),
_samplesDecoded(0), _mixerTimeStamp(0), _converter(0), _input(input), _permanent(permanent) {
assert(mixer);
assert(input);
// Get a rate converter instance
_converter = makeRateConverter(_input->getRate(), mixer->getOutputRate(), _input->isStereo(), reverseStereo);
}
Channel::~Channel() {
delete _converter;
if (_autofreeStream)
delete _input;
}
/* len indicates the number of sample *pairs*. So a value of
10 means that the buffer contains twice 10 sample, each
16 bits, for a total of 40 bytes.
*/
void Channel::mix(int16 *data, uint len) {
assert(_input);
if (_input->endOfData()) {
// TODO: call drain method
} else {
assert(_converter);
// From the channel balance/volume and the global volume, we compute
// the effective volume for the left and right channel. Note the
// slightly odd divisor: the 255 reflects the fact that the maximal
// value for _volume is 255, while the 127 is there because the
// balance value ranges from -127 to 127. The mixer (music/sound)
// volume is in the range 0 - kMaxMixerVolume.
// Hence, the vol_l/vol_r values will be in that range, too
int vol = _mixer->getVolumeForSoundType(_type) * _volume;
st_volume_t vol_l, vol_r;
if (_balance == 0) {
vol_l = vol / Mixer::kMaxChannelVolume;
vol_r = vol / Mixer::kMaxChannelVolume;
} else if (_balance < 0) {
vol_l = vol / Mixer::kMaxChannelVolume;
vol_r = ((127 + _balance) * vol) / (Mixer::kMaxChannelVolume * 127);
} else {
vol_l = ((127 - _balance) * vol) / (Mixer::kMaxChannelVolume * 127);
vol_r = vol / Mixer::kMaxChannelVolume;
}
_samplesConsumed = _samplesDecoded;
_mixerTimeStamp = g_system->getMillis();
_converter->flow(*_input, data, len, vol_l, vol_r);
_samplesDecoded += len;
}
}
uint32 Channel::getElapsedTime() {
if (_mixerTimeStamp == 0)
return 0;
// Convert the number of samples into a time duration. To avoid
// overflow, this has to be done in a somewhat non-obvious way.
uint rate = _mixer->getOutputRate();
uint32 seconds = _samplesConsumed / rate;
uint32 milliseconds = (1000 * (_samplesConsumed % rate)) / rate;
uint32 delta = g_system->getMillis() - _mixerTimeStamp;
// In theory it would seem like a good idea to limit the approximation
// so that it never exceeds the theoretical upper bound set by
// _samplesDecoded. Meanwhile, back in the real world, doing so makes
// the Broken Sword cutscenes noticeably jerkier. I guess the mixer
// isn't invoked at the regular intervals that I first imagined.
// FIXME: This won't work very well if the sound is paused.
return 1000 * seconds + milliseconds + delta;
}
} // End of namespace Audio
![swh spinner](/static/img/swh-spinner.gif)
Computing file changes ...