mirror of
https://github.com/libretro/scummvm.git
synced 2025-02-21 19:51:49 +00:00
Rename:
- FlacInputStream -> FlacStream - VorbisInputStream -> VorbisStream - MP3InputStream -> MP3Stream svn-id: r47842
This commit is contained in:
Johannes Schickel
parent
c040eeca44
commit
9c1a42f9f5
@ -82,7 +82,7 @@ namespace Audio {
|
||||
static const uint MAX_OUTPUT_CHANNELS = 2;
|
||||
|
||||
|
||||
class FlacInputStream : public SeekableAudioStream {
|
||||
class FlacStream : public SeekableAudioStream {
|
||||
protected:
|
||||
Common::SeekableReadStream *_inStream;
|
||||
bool _disposeAfterUse;
|
||||
@ -124,8 +124,8 @@ protected:
|
||||
|
||||
|
||||
public:
|
||||
FlacInputStream(Common::SeekableReadStream *inStream, bool dispose);
|
||||
virtual ~FlacInputStream();
|
||||
FlacStream(Common::SeekableReadStream *inStream, bool dispose);
|
||||
virtual ~FlacStream();
|
||||
|
||||
int readBuffer(int16 *buffer, const int numSamples);
|
||||
|
||||
@ -179,7 +179,7 @@ private:
|
||||
static void convertBuffersMono8Bit(SampleType* bufDestination, const FLAC__int32 *inChannels[], uint numSamples, const uint numChannels, const uint8 numBits);
|
||||
};
|
||||
|
||||
FlacInputStream::FlacInputStream(Common::SeekableReadStream *inStream, bool dispose)
|
||||
FlacStream::FlacStream(Common::SeekableReadStream *inStream, bool dispose)
|
||||
#ifdef LEGACY_FLAC
|
||||
: _decoder(::FLAC__seekable_stream_decoder_new()),
|
||||
#else
|
||||
@ -189,7 +189,7 @@ FlacInputStream::FlacInputStream(Common::SeekableReadStream *inStream, bool disp
|
||||
_disposeAfterUse(dispose),
|
||||
_length(0, 1000), _lastSample(0),
|
||||
_outBuffer(NULL), _requestedSamples(0), _lastSampleWritten(false),
|
||||
_methodConvertBuffers(&FlacInputStream::convertBuffersGeneric)
|
||||
_methodConvertBuffers(&FlacStream::convertBuffersGeneric)
|
||||
{
|
||||
assert(_inStream);
|
||||
memset(&_streaminfo, 0, sizeof(_streaminfo));
|
||||
@ -197,32 +197,32 @@ FlacInputStream::FlacInputStream(Common::SeekableReadStream *inStream, bool disp
|
||||
_sampleCache.bufReadPos = NULL;
|
||||
_sampleCache.bufFill = 0;
|
||||
|
||||
_methodConvertBuffers = &FlacInputStream::convertBuffersGeneric;
|
||||
_methodConvertBuffers = &FlacStream::convertBuffersGeneric;
|
||||
|
||||
bool success;
|
||||
#ifdef LEGACY_FLAC
|
||||
::FLAC__seekable_stream_decoder_set_read_callback(_decoder, &FlacInputStream::callWrapRead);
|
||||
::FLAC__seekable_stream_decoder_set_seek_callback(_decoder, &FlacInputStream::callWrapSeek);
|
||||
::FLAC__seekable_stream_decoder_set_tell_callback(_decoder, &FlacInputStream::callWrapTell);
|
||||
::FLAC__seekable_stream_decoder_set_length_callback(_decoder, &FlacInputStream::callWrapLength);
|
||||
::FLAC__seekable_stream_decoder_set_eof_callback(_decoder, &FlacInputStream::callWrapEOF);
|
||||
::FLAC__seekable_stream_decoder_set_write_callback(_decoder, &FlacInputStream::callWrapWrite);
|
||||
::FLAC__seekable_stream_decoder_set_metadata_callback(_decoder, &FlacInputStream::callWrapMetadata);
|
||||
::FLAC__seekable_stream_decoder_set_error_callback(_decoder, &FlacInputStream::callWrapError);
|
||||
::FLAC__seekable_stream_decoder_set_read_callback(_decoder, &FlacStream::callWrapRead);
|
||||
::FLAC__seekable_stream_decoder_set_seek_callback(_decoder, &FlacStream::callWrapSeek);
|
||||
::FLAC__seekable_stream_decoder_set_tell_callback(_decoder, &FlacStream::callWrapTell);
|
||||
::FLAC__seekable_stream_decoder_set_length_callback(_decoder, &FlacStream::callWrapLength);
|
||||
::FLAC__seekable_stream_decoder_set_eof_callback(_decoder, &FlacStream::callWrapEOF);
|
||||
::FLAC__seekable_stream_decoder_set_write_callback(_decoder, &FlacStream::callWrapWrite);
|
||||
::FLAC__seekable_stream_decoder_set_metadata_callback(_decoder, &FlacStream::callWrapMetadata);
|
||||
::FLAC__seekable_stream_decoder_set_error_callback(_decoder, &FlacStream::callWrapError);
|
||||
::FLAC__seekable_stream_decoder_set_client_data(_decoder, (void*)this);
|
||||
|
||||
success = (::FLAC__seekable_stream_decoder_init(_decoder) == FLAC__SEEKABLE_STREAM_DECODER_OK);
|
||||
#else
|
||||
success = (::FLAC__stream_decoder_init_stream(
|
||||
_decoder,
|
||||
&FlacInputStream::callWrapRead,
|
||||
&FlacInputStream::callWrapSeek,
|
||||
&FlacInputStream::callWrapTell,
|
||||
&FlacInputStream::callWrapLength,
|
||||
&FlacInputStream::callWrapEOF,
|
||||
&FlacInputStream::callWrapWrite,
|
||||
&FlacInputStream::callWrapMetadata,
|
||||
&FlacInputStream::callWrapError,
|
||||
&FlacStream::callWrapRead,
|
||||
&FlacStream::callWrapSeek,
|
||||
&FlacStream::callWrapTell,
|
||||
&FlacStream::callWrapLength,
|
||||
&FlacStream::callWrapEOF,
|
||||
&FlacStream::callWrapWrite,
|
||||
&FlacStream::callWrapMetadata,
|
||||
&FlacStream::callWrapError,
|
||||
(void*)this
|
||||
) == FLAC__STREAM_DECODER_INIT_STATUS_OK);
|
||||
#endif
|
||||
@ -234,10 +234,10 @@ FlacInputStream::FlacInputStream(Common::SeekableReadStream *inStream, bool disp
|
||||
}
|
||||
}
|
||||
|
||||
warning("FlacInputStream: could not create audio stream");
|
||||
warning("FlacStream: could not create audio stream");
|
||||
}
|
||||
|
||||
FlacInputStream::~FlacInputStream() {
|
||||
FlacStream::~FlacStream() {
|
||||
if (_decoder != NULL) {
|
||||
#ifdef LEGACY_FLAC
|
||||
(void) ::FLAC__seekable_stream_decoder_finish(_decoder);
|
||||
@ -251,7 +251,7 @@ FlacInputStream::~FlacInputStream() {
|
||||
delete _inStream;
|
||||
}
|
||||
|
||||
inline FLAC__StreamDecoderState FlacInputStream::getStreamDecoderState() const {
|
||||
inline FLAC__StreamDecoderState FlacStream::getStreamDecoderState() const {
|
||||
assert(_decoder != NULL);
|
||||
#ifdef LEGACY_FLAC
|
||||
return ::FLAC__seekable_stream_decoder_get_stream_decoder_state(_decoder);
|
||||
@ -260,7 +260,7 @@ inline FLAC__StreamDecoderState FlacInputStream::getStreamDecoderState() const {
|
||||
#endif
|
||||
}
|
||||
|
||||
inline bool FlacInputStream::processSingleBlock() {
|
||||
inline bool FlacStream::processSingleBlock() {
|
||||
assert(_decoder != NULL);
|
||||
#ifdef LEGACY_FLAC
|
||||
return 0 != ::FLAC__seekable_stream_decoder_process_single(_decoder);
|
||||
@ -269,7 +269,7 @@ inline bool FlacInputStream::processSingleBlock() {
|
||||
#endif
|
||||
}
|
||||
|
||||
inline bool FlacInputStream::processUntilEndOfMetadata() {
|
||||
inline bool FlacStream::processUntilEndOfMetadata() {
|
||||
assert(_decoder != NULL);
|
||||
#ifdef LEGACY_FLAC
|
||||
return 0 != ::FLAC__seekable_stream_decoder_process_until_end_of_metadata(_decoder);
|
||||
@ -278,7 +278,7 @@ inline bool FlacInputStream::processUntilEndOfMetadata() {
|
||||
#endif
|
||||
}
|
||||
|
||||
bool FlacInputStream::seekAbsolute(FLAC__uint64 sample) {
|
||||
bool FlacStream::seekAbsolute(FLAC__uint64 sample) {
|
||||
assert(_decoder != NULL);
|
||||
#ifdef LEGACY_FLAC
|
||||
const bool result = (0 != ::FLAC__seekable_stream_decoder_seek_absolute(_decoder, sample));
|
||||
@ -291,7 +291,7 @@ bool FlacInputStream::seekAbsolute(FLAC__uint64 sample) {
|
||||
return result;
|
||||
}
|
||||
|
||||
bool FlacInputStream::seek(const Timestamp &where) {
|
||||
bool FlacStream::seek(const Timestamp &where) {
|
||||
_sampleCache.bufFill = 0;
|
||||
_sampleCache.bufReadPos = NULL;
|
||||
// FLAC uses the sample pair number, thus we always use "false" for the isStereo parameter
|
||||
@ -299,11 +299,11 @@ bool FlacInputStream::seek(const Timestamp &where) {
|
||||
return seekAbsolute((FLAC__uint64)convertTimeToStreamPos(where, getRate(), false).totalNumberOfFrames());
|
||||
}
|
||||
|
||||
int FlacInputStream::readBuffer(int16 *buffer, const int numSamples) {
|
||||
int FlacStream::readBuffer(int16 *buffer, const int numSamples) {
|
||||
const uint numChannels = getChannels();
|
||||
|
||||
if (numChannels == 0) {
|
||||
warning("FlacInputStream: Stream not sucessfully initialised, cant playback");
|
||||
warning("FlacStream: Stream not sucessfully initialised, cant playback");
|
||||
return -1; // streaminfo wasnt read!
|
||||
}
|
||||
|
||||
@ -355,7 +355,7 @@ int FlacInputStream::readBuffer(int16 *buffer, const int numSamples) {
|
||||
break;
|
||||
default:
|
||||
decoderOk = false;
|
||||
warning("FlacInputStream: An error occured while decoding. DecoderState is: %s",
|
||||
warning("FlacStream: An error occured while decoding. DecoderState is: %s",
|
||||
FLAC__StreamDecoderStateString[getStreamDecoderState()]);
|
||||
}
|
||||
|
||||
@ -369,7 +369,7 @@ int FlacInputStream::readBuffer(int16 *buffer, const int numSamples) {
|
||||
return decoderOk ? samples : -1;
|
||||
}
|
||||
|
||||
inline ::FLAC__SeekableStreamDecoderReadStatus FlacInputStream::callbackRead(FLAC__byte buffer[], FLAC_size_t *bytes) {
|
||||
inline ::FLAC__SeekableStreamDecoderReadStatus FlacStream::callbackRead(FLAC__byte buffer[], FLAC_size_t *bytes) {
|
||||
if (*bytes == 0) {
|
||||
#ifdef LEGACY_FLAC
|
||||
return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR; /* abort to avoid a deadlock */
|
||||
@ -396,8 +396,8 @@ inline ::FLAC__SeekableStreamDecoderReadStatus FlacInputStream::callbackRead(FLA
|
||||
#endif
|
||||
}
|
||||
|
||||
void FlacInputStream::setBestConvertBufferMethod() {
|
||||
PFCONVERTBUFFERS tempMethod = &FlacInputStream::convertBuffersGeneric;
|
||||
void FlacStream::setBestConvertBufferMethod() {
|
||||
PFCONVERTBUFFERS tempMethod = &FlacStream::convertBuffersGeneric;
|
||||
|
||||
const uint numChannels = getChannels();
|
||||
const uint8 numBits = (uint8)_streaminfo.bits_per_sample;
|
||||
@ -407,21 +407,21 @@ void FlacInputStream::setBestConvertBufferMethod() {
|
||||
|
||||
if (numChannels == 1) {
|
||||
if (numBits == 8)
|
||||
tempMethod = &FlacInputStream::convertBuffersMono8Bit;
|
||||
tempMethod = &FlacStream::convertBuffersMono8Bit;
|
||||
if (numBits == BUFTYPE_BITS)
|
||||
tempMethod = &FlacInputStream::convertBuffersMonoNS;
|
||||
tempMethod = &FlacStream::convertBuffersMonoNS;
|
||||
} else if (numChannels == 2) {
|
||||
if (numBits == 8)
|
||||
tempMethod = &FlacInputStream::convertBuffersStereo8Bit;
|
||||
tempMethod = &FlacStream::convertBuffersStereo8Bit;
|
||||
if (numBits == BUFTYPE_BITS)
|
||||
tempMethod = &FlacInputStream::convertBuffersStereoNS;
|
||||
tempMethod = &FlacStream::convertBuffersStereoNS;
|
||||
} /* else ... */
|
||||
|
||||
_methodConvertBuffers = tempMethod;
|
||||
}
|
||||
|
||||
// 1 channel, no scaling
|
||||
void FlacInputStream::convertBuffersMonoNS(SampleType* bufDestination, const FLAC__int32 *inChannels[], uint numSamples, const uint numChannels, const uint8 numBits) {
|
||||
void FlacStream::convertBuffersMonoNS(SampleType* bufDestination, const FLAC__int32 *inChannels[], uint numSamples, const uint numChannels, const uint8 numBits) {
|
||||
assert(numChannels == 1);
|
||||
assert(numBits == BUFTYPE_BITS);
|
||||
|
||||
@ -446,7 +446,7 @@ void FlacInputStream::convertBuffersMonoNS(SampleType* bufDestination, const FLA
|
||||
}
|
||||
|
||||
// 1 channel, scaling from 8Bit
|
||||
void FlacInputStream::convertBuffersMono8Bit(SampleType* bufDestination, const FLAC__int32 *inChannels[], uint numSamples, const uint numChannels, const uint8 numBits) {
|
||||
void FlacStream::convertBuffersMono8Bit(SampleType* bufDestination, const FLAC__int32 *inChannels[], uint numSamples, const uint numChannels, const uint8 numBits) {
|
||||
assert(numChannels == 1);
|
||||
assert(numBits == 8);
|
||||
assert(8 < BUFTYPE_BITS);
|
||||
@ -472,7 +472,7 @@ void FlacInputStream::convertBuffersMono8Bit(SampleType* bufDestination, const F
|
||||
}
|
||||
|
||||
// 2 channels, no scaling
|
||||
void FlacInputStream::convertBuffersStereoNS(SampleType* bufDestination, const FLAC__int32 *inChannels[], uint numSamples, const uint numChannels, const uint8 numBits) {
|
||||
void FlacStream::convertBuffersStereoNS(SampleType* bufDestination, const FLAC__int32 *inChannels[], uint numSamples, const uint numChannels, const uint8 numBits) {
|
||||
assert(numChannels == 2);
|
||||
assert(numBits == BUFTYPE_BITS);
|
||||
assert(numSamples % 2 == 0); // must be integral multiply of channels
|
||||
@ -505,7 +505,7 @@ void FlacInputStream::convertBuffersStereoNS(SampleType* bufDestination, const F
|
||||
}
|
||||
|
||||
// 2 channels, scaling from 8Bit
|
||||
void FlacInputStream::convertBuffersStereo8Bit(SampleType* bufDestination, const FLAC__int32 *inChannels[], uint numSamples, const uint numChannels, const uint8 numBits) {
|
||||
void FlacStream::convertBuffersStereo8Bit(SampleType* bufDestination, const FLAC__int32 *inChannels[], uint numSamples, const uint numChannels, const uint8 numBits) {
|
||||
assert(numChannels == 2);
|
||||
assert(numBits == 8);
|
||||
assert(numSamples % 2 == 0); // must be integral multiply of channels
|
||||
@ -538,7 +538,7 @@ void FlacInputStream::convertBuffersStereo8Bit(SampleType* bufDestination, const
|
||||
}
|
||||
|
||||
// all Purpose-conversion - slowest of em all
|
||||
void FlacInputStream::convertBuffersGeneric(SampleType* bufDestination, const FLAC__int32 *inChannels[], uint numSamples, const uint numChannels, const uint8 numBits) {
|
||||
void FlacStream::convertBuffersGeneric(SampleType* bufDestination, const FLAC__int32 *inChannels[], uint numSamples, const uint numChannels, const uint8 numBits) {
|
||||
assert(numSamples % numChannels == 0); // must be integral multiply of channels
|
||||
|
||||
if (numBits < BUFTYPE_BITS) {
|
||||
@ -565,7 +565,7 @@ void FlacInputStream::convertBuffersGeneric(SampleType* bufDestination, const FL
|
||||
assert(numSamples == 0); // dint copy too many samples
|
||||
}
|
||||
|
||||
inline ::FLAC__StreamDecoderWriteStatus FlacInputStream::callbackWrite(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]) {
|
||||
inline ::FLAC__StreamDecoderWriteStatus FlacStream::callbackWrite(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]) {
|
||||
assert(frame->header.channels == _streaminfo.channels);
|
||||
assert(frame->header.sample_rate == _streaminfo.sample_rate);
|
||||
assert(frame->header.bits_per_sample == _streaminfo.bits_per_sample);
|
||||
@ -625,7 +625,7 @@ inline ::FLAC__StreamDecoderWriteStatus FlacInputStream::callbackWrite(const ::F
|
||||
return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
|
||||
}
|
||||
|
||||
inline ::FLAC__SeekableStreamDecoderSeekStatus FlacInputStream::callbackSeek(FLAC__uint64 absoluteByteOffset) {
|
||||
inline ::FLAC__SeekableStreamDecoderSeekStatus FlacStream::callbackSeek(FLAC__uint64 absoluteByteOffset) {
|
||||
_inStream->seek(absoluteByteOffset, SEEK_SET);
|
||||
const bool result = (absoluteByteOffset == (FLAC__uint64)_inStream->pos());
|
||||
|
||||
@ -636,7 +636,7 @@ inline ::FLAC__SeekableStreamDecoderSeekStatus FlacInputStream::callbackSeek(FLA
|
||||
#endif
|
||||
}
|
||||
|
||||
inline ::FLAC__SeekableStreamDecoderTellStatus FlacInputStream::callbackTell(FLAC__uint64 *absoluteByteOffset) {
|
||||
inline ::FLAC__SeekableStreamDecoderTellStatus FlacStream::callbackTell(FLAC__uint64 *absoluteByteOffset) {
|
||||
*absoluteByteOffset = static_cast<FLAC__uint64>(_inStream->pos());
|
||||
#ifdef LEGACY_FLAC
|
||||
return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK;
|
||||
@ -645,7 +645,7 @@ inline ::FLAC__SeekableStreamDecoderTellStatus FlacInputStream::callbackTell(FLA
|
||||
#endif
|
||||
}
|
||||
|
||||
inline ::FLAC__SeekableStreamDecoderLengthStatus FlacInputStream::callbackLength(FLAC__uint64 *streamLength) {
|
||||
inline ::FLAC__SeekableStreamDecoderLengthStatus FlacStream::callbackLength(FLAC__uint64 *streamLength) {
|
||||
*streamLength = static_cast<FLAC__uint64>(_inStream->size());
|
||||
#ifdef LEGACY_FLAC
|
||||
return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK;
|
||||
@ -654,69 +654,69 @@ inline ::FLAC__SeekableStreamDecoderLengthStatus FlacInputStream::callbackLength
|
||||
#endif
|
||||
}
|
||||
|
||||
inline bool FlacInputStream::callbackEOF() {
|
||||
inline bool FlacStream::callbackEOF() {
|
||||
return _inStream->eos();
|
||||
}
|
||||
|
||||
|
||||
inline void FlacInputStream::callbackMetadata(const ::FLAC__StreamMetadata *metadata) {
|
||||
inline void FlacStream::callbackMetadata(const ::FLAC__StreamMetadata *metadata) {
|
||||
assert(_decoder != NULL);
|
||||
assert(metadata->type == FLAC__METADATA_TYPE_STREAMINFO); // others arent really interesting
|
||||
|
||||
_streaminfo = metadata->data.stream_info;
|
||||
setBestConvertBufferMethod(); // should be set after getting stream-information. FLAC always parses the info first
|
||||
}
|
||||
inline void FlacInputStream::callbackError(::FLAC__StreamDecoderErrorStatus status) {
|
||||
inline void FlacStream::callbackError(::FLAC__StreamDecoderErrorStatus status) {
|
||||
// some of these are non-critical-Errors
|
||||
debug(1, "FlacInputStream: An error occured while decoding. DecoderState is: %s",
|
||||
debug(1, "FlacStream: An error occured while decoding. DecoderState is: %s",
|
||||
FLAC__StreamDecoderErrorStatusString[status]);
|
||||
}
|
||||
|
||||
/* Static Callback Wrappers */
|
||||
::FLAC__SeekableStreamDecoderReadStatus FlacInputStream::callWrapRead(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], FLAC_size_t *bytes, void *clientData) {
|
||||
FlacInputStream *instance = (FlacInputStream *)clientData;
|
||||
::FLAC__SeekableStreamDecoderReadStatus FlacStream::callWrapRead(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], FLAC_size_t *bytes, void *clientData) {
|
||||
FlacStream *instance = (FlacStream *)clientData;
|
||||
assert(0 != instance);
|
||||
return instance->callbackRead(buffer, bytes);
|
||||
}
|
||||
|
||||
::FLAC__SeekableStreamDecoderSeekStatus FlacInputStream::callWrapSeek(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absoluteByteOffset, void *clientData) {
|
||||
FlacInputStream *instance = (FlacInputStream *)clientData;
|
||||
::FLAC__SeekableStreamDecoderSeekStatus FlacStream::callWrapSeek(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absoluteByteOffset, void *clientData) {
|
||||
FlacStream *instance = (FlacStream *)clientData;
|
||||
assert(0 != instance);
|
||||
return instance->callbackSeek(absoluteByteOffset);
|
||||
}
|
||||
|
||||
::FLAC__SeekableStreamDecoderTellStatus FlacInputStream::callWrapTell(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absoluteByteOffset, void *clientData) {
|
||||
FlacInputStream *instance = (FlacInputStream *)clientData;
|
||||
::FLAC__SeekableStreamDecoderTellStatus FlacStream::callWrapTell(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absoluteByteOffset, void *clientData) {
|
||||
FlacStream *instance = (FlacStream *)clientData;
|
||||
assert(0 != instance);
|
||||
return instance->callbackTell(absoluteByteOffset);
|
||||
}
|
||||
|
||||
::FLAC__SeekableStreamDecoderLengthStatus FlacInputStream::callWrapLength(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *streamLength, void *clientData) {
|
||||
FlacInputStream *instance = (FlacInputStream *)clientData;
|
||||
::FLAC__SeekableStreamDecoderLengthStatus FlacStream::callWrapLength(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *streamLength, void *clientData) {
|
||||
FlacStream *instance = (FlacStream *)clientData;
|
||||
assert(0 != instance);
|
||||
return instance->callbackLength(streamLength);
|
||||
}
|
||||
|
||||
FLAC__bool FlacInputStream::callWrapEOF(const ::FLAC__SeekableStreamDecoder *decoder, void *clientData) {
|
||||
FlacInputStream *instance = (FlacInputStream *)clientData;
|
||||
FLAC__bool FlacStream::callWrapEOF(const ::FLAC__SeekableStreamDecoder *decoder, void *clientData) {
|
||||
FlacStream *instance = (FlacStream *)clientData;
|
||||
assert(0 != instance);
|
||||
return instance->callbackEOF();
|
||||
}
|
||||
|
||||
::FLAC__StreamDecoderWriteStatus FlacInputStream::callWrapWrite(const ::FLAC__SeekableStreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *clientData) {
|
||||
FlacInputStream *instance = (FlacInputStream *)clientData;
|
||||
::FLAC__StreamDecoderWriteStatus FlacStream::callWrapWrite(const ::FLAC__SeekableStreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *clientData) {
|
||||
FlacStream *instance = (FlacStream *)clientData;
|
||||
assert(0 != instance);
|
||||
return instance->callbackWrite(frame, buffer);
|
||||
}
|
||||
|
||||
void FlacInputStream::callWrapMetadata(const ::FLAC__SeekableStreamDecoder *decoder, const ::FLAC__StreamMetadata *metadata, void *clientData) {
|
||||
FlacInputStream *instance = (FlacInputStream *)clientData;
|
||||
void FlacStream::callWrapMetadata(const ::FLAC__SeekableStreamDecoder *decoder, const ::FLAC__StreamMetadata *metadata, void *clientData) {
|
||||
FlacStream *instance = (FlacStream *)clientData;
|
||||
assert(0 != instance);
|
||||
instance->callbackMetadata(metadata);
|
||||
}
|
||||
|
||||
void FlacInputStream::callWrapError(const ::FLAC__SeekableStreamDecoder *decoder, ::FLAC__StreamDecoderErrorStatus status, void *clientData) {
|
||||
FlacInputStream *instance = (FlacInputStream *)clientData;
|
||||
void FlacStream::callWrapError(const ::FLAC__SeekableStreamDecoder *decoder, ::FLAC__StreamDecoderErrorStatus status, void *clientData) {
|
||||
FlacStream *instance = (FlacStream *)clientData;
|
||||
assert(0 != instance);
|
||||
instance->callbackError(status);
|
||||
}
|
||||
@ -729,7 +729,7 @@ void FlacInputStream::callWrapError(const ::FLAC__SeekableStreamDecoder *decoder
|
||||
SeekableAudioStream *makeFlacStream(
|
||||
Common::SeekableReadStream *stream,
|
||||
DisposeAfterUse::Flag disposeAfterUse) {
|
||||
SeekableAudioStream *s = new FlacInputStream(stream, disposeAfterUse);
|
||||
SeekableAudioStream *s = new FlacStream(stream, disposeAfterUse);
|
||||
if (s && s->endOfData()) {
|
||||
delete s;
|
||||
return 0;
|
||||
|
||||
@ -45,7 +45,7 @@ namespace Audio {
|
||||
#pragma mark -
|
||||
|
||||
|
||||
class MP3InputStream : public SeekableAudioStream {
|
||||
class MP3Stream : public SeekableAudioStream {
|
||||
protected:
|
||||
enum State {
|
||||
MP3_STATE_INIT, // Need to init the decoder
|
||||
@ -74,9 +74,9 @@ protected:
|
||||
byte _buf[BUFFER_SIZE + MAD_BUFFER_GUARD];
|
||||
|
||||
public:
|
||||
MP3InputStream(Common::SeekableReadStream *inStream,
|
||||
MP3Stream(Common::SeekableReadStream *inStream,
|
||||
DisposeAfterUse::Flag dispose);
|
||||
~MP3InputStream();
|
||||
~MP3Stream();
|
||||
|
||||
int readBuffer(int16 *buffer, const int numSamples);
|
||||
|
||||
@ -95,7 +95,7 @@ protected:
|
||||
void deinitStream();
|
||||
};
|
||||
|
||||
MP3InputStream::MP3InputStream(Common::SeekableReadStream *inStream, DisposeAfterUse::Flag dispose) :
|
||||
MP3Stream::MP3Stream(Common::SeekableReadStream *inStream, DisposeAfterUse::Flag dispose) :
|
||||
_inStream(inStream),
|
||||
_disposeAfterUse(dispose),
|
||||
_posInFrame(0),
|
||||
@ -126,14 +126,14 @@ MP3InputStream::MP3InputStream(Common::SeekableReadStream *inStream, DisposeAfte
|
||||
decodeMP3Data();
|
||||
}
|
||||
|
||||
MP3InputStream::~MP3InputStream() {
|
||||
MP3Stream::~MP3Stream() {
|
||||
deinitStream();
|
||||
|
||||
if (_disposeAfterUse == DisposeAfterUse::YES)
|
||||
delete _inStream;
|
||||
}
|
||||
|
||||
void MP3InputStream::decodeMP3Data() {
|
||||
void MP3Stream::decodeMP3Data() {
|
||||
do {
|
||||
if (_state == MP3_STATE_INIT)
|
||||
initStream();
|
||||
@ -154,10 +154,10 @@ void MP3InputStream::decodeMP3Data() {
|
||||
// Note: we will occasionally see MAD_ERROR_BADDATAPTR errors here.
|
||||
// These are normal and expected (caused by our frame skipping (i.e. "seeking")
|
||||
// code above).
|
||||
debug(6, "MP3InputStream: Recoverable error in mad_frame_decode (%s)", mad_stream_errorstr(&_stream));
|
||||
debug(6, "MP3Stream: Recoverable error in mad_frame_decode (%s)", mad_stream_errorstr(&_stream));
|
||||
continue;
|
||||
} else {
|
||||
warning("MP3InputStream: Unrecoverable error in mad_frame_decode (%s)", mad_stream_errorstr(&_stream));
|
||||
warning("MP3Stream: Unrecoverable error in mad_frame_decode (%s)", mad_stream_errorstr(&_stream));
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -173,7 +173,7 @@ void MP3InputStream::decodeMP3Data() {
|
||||
_state = MP3_STATE_EOS;
|
||||
}
|
||||
|
||||
void MP3InputStream::readMP3Data() {
|
||||
void MP3Stream::readMP3Data() {
|
||||
uint32 remaining = 0;
|
||||
|
||||
// Give up immediately if we already used up all data in the stream
|
||||
@ -203,7 +203,7 @@ void MP3InputStream::readMP3Data() {
|
||||
mad_stream_buffer(&_stream, _buf, size + remaining);
|
||||
}
|
||||
|
||||
bool MP3InputStream::seek(const Timestamp &where) {
|
||||
bool MP3Stream::seek(const Timestamp &where) {
|
||||
if (where == _length) {
|
||||
_state = MP3_STATE_EOS;
|
||||
return true;
|
||||
@ -225,7 +225,7 @@ bool MP3InputStream::seek(const Timestamp &where) {
|
||||
return (_state != MP3_STATE_EOS);
|
||||
}
|
||||
|
||||
void MP3InputStream::initStream() {
|
||||
void MP3Stream::initStream() {
|
||||
if (_state != MP3_STATE_INIT)
|
||||
deinitStream();
|
||||
|
||||
@ -246,7 +246,7 @@ void MP3InputStream::initStream() {
|
||||
readMP3Data();
|
||||
}
|
||||
|
||||
void MP3InputStream::readHeader() {
|
||||
void MP3Stream::readHeader() {
|
||||
if (_state != MP3_STATE_READY)
|
||||
return;
|
||||
|
||||
@ -265,10 +265,10 @@ void MP3InputStream::readHeader() {
|
||||
readMP3Data(); // Read more data
|
||||
continue;
|
||||
} else if (MAD_RECOVERABLE(_stream.error)) {
|
||||
debug(6, "MP3InputStream: Recoverable error in mad_header_decode (%s)", mad_stream_errorstr(&_stream));
|
||||
debug(6, "MP3Stream: Recoverable error in mad_header_decode (%s)", mad_stream_errorstr(&_stream));
|
||||
continue;
|
||||
} else {
|
||||
warning("MP3InputStream: Unrecoverable error in mad_header_decode (%s)", mad_stream_errorstr(&_stream));
|
||||
warning("MP3Stream: Unrecoverable error in mad_header_decode (%s)", mad_stream_errorstr(&_stream));
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -282,7 +282,7 @@ void MP3InputStream::readHeader() {
|
||||
_state = MP3_STATE_EOS;
|
||||
}
|
||||
|
||||
void MP3InputStream::deinitStream() {
|
||||
void MP3Stream::deinitStream() {
|
||||
if (_state == MP3_STATE_INIT)
|
||||
return;
|
||||
|
||||
@ -308,7 +308,7 @@ static inline int scale_sample(mad_fixed_t sample) {
|
||||
return sample >> (MAD_F_FRACBITS + 1 - 16);
|
||||
}
|
||||
|
||||
int MP3InputStream::readBuffer(int16 *buffer, const int numSamples) {
|
||||
int MP3Stream::readBuffer(int16 *buffer, const int numSamples) {
|
||||
int samples = 0;
|
||||
// Keep going as long as we have input available
|
||||
while (samples < numSamples && _state != MP3_STATE_EOS) {
|
||||
@ -339,7 +339,7 @@ SeekableAudioStream *makeMP3Stream(
|
||||
Common::SeekableReadStream *stream,
|
||||
DisposeAfterUse::Flag disposeAfterUse) {
|
||||
// TODO: Properly check whether creating the MP3 stream succeeded.
|
||||
return new MP3InputStream(stream, disposeAfterUse);
|
||||
return new MP3Stream(stream, disposeAfterUse);
|
||||
}
|
||||
|
||||
} // End of namespace Audio
|
||||
|
||||
@ -65,7 +65,7 @@ static int seek_stream_wrap(void *datasource, ogg_int64_t offset, int whence) {
|
||||
}
|
||||
|
||||
static int close_stream_wrap(void *datasource) {
|
||||
// Do nothing -- we leave it up to the VorbisInputStream to free memory as appropriate.
|
||||
// Do nothing -- we leave it up to the VorbisStream to free memory as appropriate.
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -85,7 +85,7 @@ static ov_callbacks g_stream_wrap = {
|
||||
#pragma mark -
|
||||
|
||||
|
||||
class VorbisInputStream : public SeekableAudioStream {
|
||||
class VorbisStream : public SeekableAudioStream {
|
||||
protected:
|
||||
Common::SeekableReadStream *_inStream;
|
||||
DisposeAfterUse::Flag _disposeAfterUse;
|
||||
@ -103,8 +103,8 @@ protected:
|
||||
|
||||
public:
|
||||
// startTime / duration are in milliseconds
|
||||
VorbisInputStream(Common::SeekableReadStream *inStream, DisposeAfterUse::Flag dispose);
|
||||
~VorbisInputStream();
|
||||
VorbisStream(Common::SeekableReadStream *inStream, DisposeAfterUse::Flag dispose);
|
||||
~VorbisStream();
|
||||
|
||||
int readBuffer(int16 *buffer, const int numSamples);
|
||||
|
||||
@ -118,7 +118,7 @@ protected:
|
||||
bool refill();
|
||||
};
|
||||
|
||||
VorbisInputStream::VorbisInputStream(Common::SeekableReadStream *inStream, DisposeAfterUse::Flag dispose) :
|
||||
VorbisStream::VorbisStream(Common::SeekableReadStream *inStream, DisposeAfterUse::Flag dispose) :
|
||||
_inStream(inStream),
|
||||
_disposeAfterUse(dispose),
|
||||
_length(0, 1000),
|
||||
@ -146,13 +146,13 @@ VorbisInputStream::VorbisInputStream(Common::SeekableReadStream *inStream, Dispo
|
||||
#endif
|
||||
}
|
||||
|
||||
VorbisInputStream::~VorbisInputStream() {
|
||||
VorbisStream::~VorbisStream() {
|
||||
ov_clear(&_ovFile);
|
||||
if (_disposeAfterUse == DisposeAfterUse::YES)
|
||||
delete _inStream;
|
||||
}
|
||||
|
||||
int VorbisInputStream::readBuffer(int16 *buffer, const int numSamples) {
|
||||
int VorbisStream::readBuffer(int16 *buffer, const int numSamples) {
|
||||
int samples = 0;
|
||||
while (samples < numSamples && _pos < _bufferEnd) {
|
||||
const int len = MIN(numSamples - samples, (int)(_bufferEnd - _pos));
|
||||
@ -168,7 +168,7 @@ int VorbisInputStream::readBuffer(int16 *buffer, const int numSamples) {
|
||||
return samples;
|
||||
}
|
||||
|
||||
bool VorbisInputStream::seek(const Timestamp &where) {
|
||||
bool VorbisStream::seek(const Timestamp &where) {
|
||||
// Vorbisfile uses the sample pair number, thus we always use "false" for the isStereo parameter
|
||||
// of the convertTimeToStreamPos helper.
|
||||
int res = ov_pcm_seek(&_ovFile, convertTimeToStreamPos(where, getRate(), false).totalNumberOfFrames());
|
||||
@ -181,7 +181,7 @@ bool VorbisInputStream::seek(const Timestamp &where) {
|
||||
return refill();
|
||||
}
|
||||
|
||||
bool VorbisInputStream::refill() {
|
||||
bool VorbisStream::refill() {
|
||||
// Read the samples
|
||||
uint len_left = sizeof(_buffer);
|
||||
char *read_pos = (char *)_buffer;
|
||||
@ -244,7 +244,7 @@ bool VorbisInputStream::refill() {
|
||||
SeekableAudioStream *makeVorbisStream(
|
||||
Common::SeekableReadStream *stream,
|
||||
DisposeAfterUse::Flag disposeAfterUse) {
|
||||
SeekableAudioStream *s = new VorbisInputStream(stream, disposeAfterUse);
|
||||
SeekableAudioStream *s = new VorbisStream(stream, disposeAfterUse);
|
||||
if (s && s->endOfData()) {
|
||||
delete s;
|
||||
return 0;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user