1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
/* 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$
*
*/
#ifndef SOUND_AUDIOSTREAM_H
#define SOUND_AUDIOSTREAM_H
#include "common/util.h"
#include "common/scummsys.h"
namespace Audio {
/**
* Generic audio input stream. Subclasses of this are used to feed arbitrary
* sampled audio data into ScummVM's audio mixer.
*/
class AudioStream {
public:
virtual ~AudioStream() {}
/**
* Fill the given buffer with up to numSamples samples.
* Returns the actual number of samples read, or -1 if
* a critical error occured (note: you *must* check if
* this value is less than what you requested, this can
* happen when the stream is fully used up).
*
* Data has to be in native endianess, 16 bit per sample, signed.
* For stereo stream, buffer will be filled with interleaved
* left and right channel samples, starting with a left sample.
* Furthermore, the samples in the left and right are summed up.
* So if you request 4 samples from a stereo stream, you will get
* a total of two left channel and two right channel samples.
*/
virtual int readBuffer(int16 *buffer, const int numSamples) = 0;
/** Is this a stereo stream? */
virtual bool isStereo() const = 0;
/**
* End of data reached? If this returns true, it means that at this
* time there is no data available in the stream. However there may be
* more data in the future.
* This is used by e.g. a rate converter to decide whether to keep on
* converting data or stop.
*/
virtual bool endOfData() const = 0;
/**
* End of stream reached? If this returns true, it means that all data
* in this stream is used up and no additional data will appear in it
* in the future.
* This is used by the mixer to decide whether a given stream shall be
* removed from the list of active streams (and thus be destroyed).
* By default this maps to endOfData()
*/
virtual bool endOfStream() const { return endOfData(); }
/** Sample rate of the stream. */
virtual int getRate() const = 0;
/**
* Tries to load a file by trying all available formats.
* In case of an error, the file handle will be closed, but deleting
* it is still the responsibilty of the caller.
* @param basename a filename without an extension
* @param startTime the (optional) time offset in milliseconds from which to start playback
* @param duration the (optional) time in milliseconds specifying how long to play
* @param numLoops how often the data shall be looped (0 = infinite)
* @return an Audiostream ready to use in case of success;
* NULL in case of an error (e.g. invalid/nonexisting file)
*/
static AudioStream* openStreamFile(const Common::String &basename, uint32 startTime = 0, uint32 duration = 0, uint numLoops = 1);
};
/**
* Factory function for a raw linear AudioStream, which will simply treat all data
* in the buffer described by ptr and len as raw sample data in the specified
* format. It will then simply pass this data directly to the mixer, after converting
* it to the sample format used by the mixer (i.e. 16 bit signed native endian).
* Optionally supports (infinite) looping of a portion of the data.
*/
AudioStream *makeLinearInputStream(const byte *ptr, uint32 len, int rate, byte flags, uint loopStart, uint loopEnd);
/**
* An audio stream to which additional data can be appended on-the-fly.
* Used by SMUSH, iMuseDigital, and the Kyrandia 3 VQA player.
*/
class AppendableAudioStream : public Audio::AudioStream {
public:
/**
* Queue another audio data buffer for playback. The stream
* will playback all queued buffers, in the order they were
* queued. After all data contained in them has been played,
* the buffer will be delete[]'d (so make sure to allocate them
* with new[], not with malloc).
*/
virtual void queueBuffer(byte *data, uint32 size) = 0;
/**
* Mark the stream as finished, that is, signal that no further data
* will be appended to it. Only after this has been done can the
* AppendableAudioStream ever 'end' (
*/
virtual void finish() = 0;
};
/**
* Factory function for an AppendableAudioStream. The rate and flags
* parameters are analog to those used in makeLinearInputStream.
*/
AppendableAudioStream *makeAppendableAudioStream(int rate, byte flags);
} // End of namespace Audio
#endif
|
