mirror of
https://github.com/OpenMW/openmw.git
synced 2025-01-24 18:23:54 +00:00
119 lines
2.8 KiB
C++
119 lines
2.8 KiB
C++
#include "input_audiere.h"
|
|
#include <assert.h>
|
|
|
|
// Exception handling
|
|
class Audiere_Exception : public std::exception
|
|
{
|
|
std::string msg;
|
|
|
|
public:
|
|
|
|
Audiere_Exception(const std::string &m) : msg(m) {}
|
|
~Audiere_Exception() throw() {}
|
|
virtual const char* what() const throw() { return msg.c_str(); }
|
|
};
|
|
|
|
static void fail(const std::string &msg)
|
|
{
|
|
throw Audiere_Exception("Audiere exception: " + msg);
|
|
}
|
|
|
|
using namespace audiere;
|
|
using namespace Mangle::Sound;
|
|
|
|
// --- InputManager ---
|
|
|
|
InputSource *AudiereInput::load(const std::string &file)
|
|
{ return new AudiereSource(file); }
|
|
|
|
// --- InputSource ---
|
|
|
|
AudiereSource::AudiereSource(const std::string &file)
|
|
{
|
|
SampleSourcePtr sample = OpenSampleSource(file.c_str());
|
|
if(!sample)
|
|
fail("Couldn't load file " + file);
|
|
|
|
buf = CreateSampleBuffer(sample);
|
|
}
|
|
|
|
InputStream *AudiereSource::getStream()
|
|
{
|
|
return new AudiereStream(buf->openStream());
|
|
}
|
|
|
|
// --- InputStream ---
|
|
|
|
AudiereStream::AudiereStream(SampleSourcePtr _sample)
|
|
: sample(_sample), pullSize(0)
|
|
{
|
|
assert(sample);
|
|
|
|
SampleFormat fmt;
|
|
int channels, rate;
|
|
sample->getFormat(channels, rate, fmt);
|
|
|
|
// Calculate the size of one frame
|
|
frameSize = GetSampleSize(fmt) * channels;
|
|
|
|
// Make sure that our pullover hack will work. Increase this size if
|
|
// this doesn't work in all cases.
|
|
assert(frameSize <= PSIZE);
|
|
}
|
|
|
|
void AudiereStream::getInfo(int32_t *rate, int32_t *channels, int32_t *bits)
|
|
{
|
|
SampleFormat fmt;
|
|
sample->getFormat(*channels, *rate, fmt);
|
|
if(fmt == SF_U8)
|
|
*bits = 8;
|
|
else if(fmt == SF_S16)
|
|
*bits = 16;
|
|
else assert(0);
|
|
}
|
|
|
|
/*
|
|
Get data. Since Audiere operates with frames, not bytes, there's a
|
|
little conversion magic going on here. We need to make sure we're
|
|
reading a whole number of frames - if not, we need to store the
|
|
remainding part of the last frame and remember it for the next read
|
|
operation.
|
|
|
|
*/
|
|
uint32_t AudiereStream::getData(void *_data, uint32_t length)
|
|
{
|
|
char *data = (char*)_data;
|
|
|
|
// Move the remains from the last operation first
|
|
if(pullSize)
|
|
{
|
|
// pullSize is how much was stored the last time, so skip that.
|
|
memcpy(data, pullOver+pullSize, PSIZE-pullSize);
|
|
length -= pullSize;
|
|
data += pullSize;
|
|
}
|
|
|
|
// Determine the overshoot up front
|
|
pullSize = length % frameSize;
|
|
|
|
// Number of whole frames
|
|
int frames = length / frameSize;
|
|
|
|
// Read the data
|
|
int res = sample->read(frames, data);
|
|
|
|
// Are we missing data? If res<length and we're at the end of the
|
|
// stream, then this doesn't apply.
|
|
if(res == frames && pullSize &&
|
|
// Read one more sample
|
|
(sample->read(1, pullOver) != 0))
|
|
{
|
|
// Now, move as much of it as we can fit into the output
|
|
// data
|
|
memcpy(data+length-pullSize, pullOver, pullSize);
|
|
}
|
|
else pullSize = 0;
|
|
|
|
// Return the total number of bytes stored
|
|
return frameSize*res + pullSize;
|
|
}
|