blob: ae634cf0b55d6fd757e144da1d766b9777b530cb (
plain)
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
|
#ifndef __JE_SOURCE_SDL_H__
#define __JE_SOURCE_SDL_H__
#include "../../core/configuration.h"
#if defined(jin_audio) && (jin_audio == jin_audio_sdl)
#include <vector>
#include <queue>
#include <stack>
#include <exception>
#include "../source.h"
namespace JinEngine
{
namespace Audio
{
namespace SDL
{
typedef struct SDLSourceCommand;
class SDLSourceManager;
///
/// Audio source SDL implementation.
///
class SDLSource : public Source
{
public:
///
/// Source constructor.
///
SDLSource();
///
///
///
SDLSource(const char* file);
///
///
///
SDLSource(void* mem, size_t size);
///
/// Source destructor.
///
~SDLSource();
///
/// Play source.
///
void play() override;
///
/// Stop source.
///
void stop() override;
///
/// Pause source.
///
void pause() override;
///
/// Resume source.
///
void resume() override;
///
/// Rewind source.
///
void rewind() override;
///
/// Return if the source is stopped.
///
/// @return True if the source is stopped, otherwise return false.
///
bool isStopped() const override;
///
/// Return if the source is paused.
///
/// @return True if the source is paused(, otherwise return false.
///
bool isPaused() const override;
///
/// Set pitch.
///
/// @param pitch Pitch of source.
///
void setPitch(float pitch) override;
///
/// Set volume.
///
/// @param volume Volume of source.
///
void setVolume(float volume) override;
///
/// Set source loop.
///
/// @param loop Looping or not.
///
void setLoop(bool loop) override;
///
/// Set source rate.
///
/// @param rate Rate of source.
///
void setRate(float rate) override;
///
/// Handle a specific command.
///
/// @param manager Audio manager.
/// @param cmd Source commad.
///
inline void handle(SDLSourceManager* manager, SDLSourceCommand* cmd);
///
/// Process decoded source data.
///
/// @param buffer Source data.
/// @param size Data size.
///
inline void process(void* buffer, size_t size);
protected:
///
/// Decode wav file.
///
/// @param mem Wav file data.
/// @param size Wav data size.
///
void decode_wav(void* mem, int size);
///
/// Decode ogg file.
///
/// @param mem ogg file data.
/// @param size ogg data size.
///
void decode_ogg(void* mem, int size);
///
/// Check source state.
///
/// @param state State to be checked.
/// @return True if state is given state, otherwise return false.
///
inline bool is(int state) const
{
return (status.state & state) == state;
}
// Source data.
struct {
const void* data; // Ƶ
int length; // dataֽڳ
const void* end; // dataβ = (unsigned char*)data + size
int samplerate; // Ƶ
unsigned char bitdepth; // ÿsampleıس
int samples; // sample = size / (bitdepth / 8)
unsigned char channels; // channel1(mono)2(stereo)
} raw;
// Procedure controller variable.
struct {
int pos; // ǰŵsample
int pitch; // pitch
int state; // ǰ״̬
bool loop; // loop or not
float volume; //
} status;
};
///
/// Source manager.
///
class SDLSourceManager : public Object
{
public:
///
/// Get manager singleton.
///
/// @return Singleton of SDL source manager.
///
static SDLSourceManager* get();
///
/// Process commands.
///
void processCommands();
///
/// Process sources.
///
/// @param buffer Source data.
/// @param size Size of source data.
///
void processSources(void* buffer, size_t size);
///
/// Clear source queue.
///
/// This function will stop all sources.
///
void removeAllSource();
///
/// Remove specific source.
///
/// @param source SDL audio source.
///
void removeSource(SDLSource* source);
///
/// Push specific source into queue.
///
/// @param source SDL audio source.
///
void pushSource(SDLSource* source);
///
/// Get command from queue.
///
/// @return Command at first place.
///
SDLSourceCommand* getCommand();
///
/// Push command.
///
/// @param cmd Spcific command.
///
void pushCommand(SDLSourceCommand* cmd);
private:
std::queue<SDLSourceCommand*> commands;
std::stack<SDLSourceCommand*> commandsPool;
std::vector<SDLSource*> sources; // processing sources
static SDLSourceManager* manager;
};
class SourceException : public Object, public std::exception
{
const char* what() const throw ()
{
return "Load Source Exception";
}
};
} // namespace SDL
} // namespace Audio
} // namespace JinEngine
#endif // (jin_audio) && (jin_audio == jin_audio_sdl)
#endif // __JE_SOURCE_SDL_H__
|
