mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-28 04:34:50 +00:00
336 lines
8.3 KiB
C++
336 lines
8.3 KiB
C++
/* 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 "sound/vorbis.h"
|
|
|
|
#ifdef USE_VORBIS
|
|
|
|
#include "common/debug.h"
|
|
#include "common/stream.h"
|
|
#include "common/util.h"
|
|
|
|
#include "sound/audiostream.h"
|
|
#include "sound/audiocd.h"
|
|
|
|
#ifdef USE_TREMOR
|
|
#ifdef __GP32__ // GP32 uses custom libtremor
|
|
#include <ivorbisfile.h>
|
|
#else
|
|
#include <tremor/ivorbisfile.h>
|
|
#endif
|
|
#else
|
|
#include <vorbis/vorbisfile.h>
|
|
#endif
|
|
|
|
|
|
namespace Audio {
|
|
|
|
// These are wrapper functions to allow using a SeekableReadStream object to
|
|
// provide data to the OggVorbis_File object.
|
|
|
|
static size_t read_stream_wrap(void *ptr, size_t size, size_t nmemb, void *datasource) {
|
|
Common::SeekableReadStream *stream = (Common::SeekableReadStream *)datasource;
|
|
|
|
uint32 result = stream->read(ptr, size * nmemb);
|
|
|
|
return result / size;
|
|
}
|
|
|
|
static int seek_stream_wrap(void *datasource, ogg_int64_t offset, int whence) {
|
|
Common::SeekableReadStream *stream = (Common::SeekableReadStream *)datasource;
|
|
stream->seek((int32)offset, whence);
|
|
return stream->pos();
|
|
}
|
|
|
|
static int close_stream_wrap(void *datasource) {
|
|
// Do nothing -- we leave it up to the VorbisInputStream to free memory as appropriate.
|
|
return 0;
|
|
}
|
|
|
|
static long tell_stream_wrap(void *datasource) {
|
|
Common::SeekableReadStream *stream = (Common::SeekableReadStream *)datasource;
|
|
return stream->pos();
|
|
}
|
|
|
|
static ov_callbacks g_stream_wrap = {
|
|
read_stream_wrap, seek_stream_wrap, close_stream_wrap, tell_stream_wrap
|
|
};
|
|
|
|
|
|
|
|
#pragma mark -
|
|
#pragma mark --- Ogg Vorbis stream ---
|
|
#pragma mark -
|
|
|
|
|
|
class VorbisInputStream : public AudioStream {
|
|
protected:
|
|
Common::SeekableReadStream *_inStream;
|
|
bool _disposeAfterUse;
|
|
|
|
bool _isStereo;
|
|
int _rate;
|
|
uint _numLoops;
|
|
const uint _totalNumLoops;
|
|
|
|
#ifdef USE_TREMOR
|
|
ogg_int64_t _startTime;
|
|
ogg_int64_t _endTime;
|
|
#else
|
|
double _startTime;
|
|
double _endTime;
|
|
#endif
|
|
|
|
OggVorbis_File _ovFile;
|
|
|
|
int16 _buffer[4096];
|
|
const int16 *_bufferEnd;
|
|
const int16 *_pos;
|
|
|
|
public:
|
|
// startTime / duration are in milliseconds
|
|
VorbisInputStream(Common::SeekableReadStream *inStream, bool dispose, uint startTime = 0, uint endTime = 0, uint numLoops = 1);
|
|
~VorbisInputStream();
|
|
|
|
int readBuffer(int16 *buffer, const int numSamples);
|
|
|
|
bool endOfData() const { return _pos >= _bufferEnd; }
|
|
bool isStereo() const { return _isStereo; }
|
|
int getRate() const { return _rate; }
|
|
|
|
int32 getTotalPlayTime() const {
|
|
if (!_totalNumLoops)
|
|
return AudioStream::kUnknownPlayTime;
|
|
|
|
#ifdef USE_TREMOR
|
|
return (_endTime - _startTime) * _totalNumLoops;
|
|
#else
|
|
return (int32)((_endTime - _startTime) * 1000.0) * _totalNumLoops;
|
|
#endif
|
|
}
|
|
|
|
protected:
|
|
bool refill();
|
|
};
|
|
|
|
VorbisInputStream::VorbisInputStream(Common::SeekableReadStream *inStream, bool dispose, uint startTime, uint endTime, uint numLoops) :
|
|
_inStream(inStream),
|
|
_disposeAfterUse(dispose),
|
|
_numLoops(numLoops),
|
|
_totalNumLoops(numLoops),
|
|
_bufferEnd(_buffer + ARRAYSIZE(_buffer)) {
|
|
|
|
int res = ov_open_callbacks(inStream, &_ovFile, NULL, 0, g_stream_wrap);
|
|
if (res < 0) {
|
|
warning("Could not create Vorbis stream (%d)", res);
|
|
_pos = _bufferEnd;
|
|
return;
|
|
}
|
|
|
|
#ifdef USE_TREMOR
|
|
/* TODO: Symbian may have to use scumm_fixdfdi here? To quote:
|
|
"SumthinWicked says: fixing "relocation truncated to fit: ARM_26 __fixdfdi" during linking on GCC, see portdefs.h"
|
|
*/
|
|
|
|
// In Tremor, the ov_time_seek() and ov_time_seek_page() calls take seeking
|
|
// positions in milliseconds as 64 bit integers, rather than in seconds as
|
|
// doubles as in Vorbisfile.
|
|
ogg_int64_t totalTime;
|
|
_startTime = startTime;
|
|
_endTime = endTime;
|
|
#else
|
|
double totalTime;
|
|
_startTime = startTime / 1000.0;
|
|
_endTime = endTime / 1000.0;
|
|
#endif
|
|
|
|
// If endTime was 0, or is past the end of the file, set it to the maximal time possible
|
|
totalTime = ov_time_total(&_ovFile, -1);
|
|
if (_endTime == 0 || _endTime > totalTime)
|
|
_endTime = totalTime;
|
|
|
|
// If the specified time range is empty, abort early.
|
|
if (_startTime >= _endTime) {
|
|
_pos = _bufferEnd;
|
|
return;
|
|
}
|
|
|
|
// Seek to the start position
|
|
res = ov_time_seek(&_ovFile, _startTime);
|
|
if (res < 0) {
|
|
warning("Error seeking in Vorbis stream (%d)", res);
|
|
_pos = _bufferEnd;
|
|
return;
|
|
}
|
|
|
|
// Read in initial data
|
|
if (!refill())
|
|
return;
|
|
|
|
// Setup some header information
|
|
_isStereo = ov_info(&_ovFile, -1)->channels >= 2;
|
|
_rate = ov_info(&_ovFile, -1)->rate;
|
|
}
|
|
|
|
VorbisInputStream::~VorbisInputStream() {
|
|
ov_clear(&_ovFile);
|
|
if (_disposeAfterUse)
|
|
delete _inStream;
|
|
}
|
|
|
|
int VorbisInputStream::readBuffer(int16 *buffer, const int numSamples) {
|
|
int res, samples = 0;
|
|
while (samples < numSamples && _pos < _bufferEnd) {
|
|
const int len = MIN(numSamples - samples, (int)(_bufferEnd - _pos));
|
|
memcpy(buffer, _pos, len * 2);
|
|
buffer += len;
|
|
_pos += len;
|
|
samples += len;
|
|
if (_pos >= _bufferEnd) {
|
|
if (!refill())
|
|
break;
|
|
|
|
// If we are still out of data, and also past the end of specified
|
|
// time range, check whether looping is enabled...
|
|
if (_pos >= _bufferEnd && ov_time_tell(&_ovFile) >= _endTime) {
|
|
if (_numLoops != 1) {
|
|
// If looping is on and there are loops left, rewind to the start
|
|
if (_numLoops != 0)
|
|
_numLoops--;
|
|
|
|
res = ov_time_seek(&_ovFile, _startTime);
|
|
if (res < 0) {
|
|
warning("Error seeking in Vorbis stream (%d)", res);
|
|
_pos = _bufferEnd;
|
|
break;
|
|
}
|
|
|
|
if (!refill())
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return samples;
|
|
}
|
|
|
|
bool VorbisInputStream::refill() {
|
|
// Read the samples
|
|
int res;
|
|
uint len_left = sizeof(_buffer);
|
|
char *read_pos = (char *)_buffer;
|
|
|
|
while (len_left > 0) {
|
|
if (ov_time_tell(&_ovFile) >= _endTime) {
|
|
// If looping is on and there are loops left, rewind to the start
|
|
if (_numLoops == 1)
|
|
break; // Last loop, abort
|
|
if (_numLoops != 0)
|
|
_numLoops--;
|
|
res = ov_time_seek(&_ovFile, _startTime);
|
|
if (res < 0) {
|
|
warning("Error seeking in Vorbis stream (%d)", res);
|
|
_pos = _bufferEnd;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
long result;
|
|
#ifdef USE_TREMOR
|
|
// Tremor ov_read() always returns data as signed 16 bit interleaved PCM
|
|
// in host byte order. As such, it does not take arguments to request
|
|
// specific signedness, byte order or bit depth as in Vorbisfile.
|
|
result = ov_read(&_ovFile, read_pos, len_left,
|
|
NULL);
|
|
#else
|
|
#ifdef SCUMM_BIG_ENDIAN
|
|
result = ov_read(&_ovFile, read_pos, len_left,
|
|
1,
|
|
2, // 16 bit
|
|
1, // signed
|
|
NULL);
|
|
#else
|
|
result = ov_read(&_ovFile, read_pos, len_left,
|
|
0,
|
|
2, // 16 bit
|
|
1, // signed
|
|
NULL);
|
|
#endif
|
|
#endif
|
|
if (result == OV_HOLE) {
|
|
// Possibly recoverable, just warn about it
|
|
warning("Corrupted data in Vorbis file");
|
|
} else if (result == 0) {
|
|
warning("End of file while reading from Vorbis file");
|
|
_pos = _bufferEnd;
|
|
return false;
|
|
} else if (result < 0) {
|
|
warning("Error reading from Vorbis stream (%d)", int(result));
|
|
_pos = _bufferEnd;
|
|
// Don't delete it yet, that causes problems in
|
|
// the CD player emulation code.
|
|
return false;
|
|
} else {
|
|
len_left -= result;
|
|
read_pos += result;
|
|
}
|
|
}
|
|
|
|
_pos = _buffer;
|
|
_bufferEnd = (int16 *)read_pos;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
#pragma mark --- Ogg Vorbis factory functions ---
|
|
#pragma mark -
|
|
|
|
|
|
AudioStream *makeVorbisStream(
|
|
Common::SeekableReadStream *stream,
|
|
bool disposeAfterUse,
|
|
uint32 startTime,
|
|
uint32 duration,
|
|
uint numLoops) {
|
|
|
|
uint32 endTime = duration ? (startTime + duration) : 0;
|
|
|
|
VorbisInputStream *input = new VorbisInputStream(stream, disposeAfterUse, startTime, endTime, numLoops);
|
|
|
|
if (input->endOfData()) {
|
|
delete input;
|
|
return 0;
|
|
}
|
|
|
|
return input;
|
|
}
|
|
|
|
|
|
} // End of namespace Audio
|
|
|
|
#endif // #ifdef USE_VORBIS
|