SDL 2.0
SDL_mixer.c File Reference
#include "../SDL_internal.h"
#include "SDL_cpuinfo.h"
#include "SDL_timer.h"
#include "SDL_audio.h"
#include "SDL_sysaudio.h"
+ Include dependency graph for SDL_mixer.c:

Go to the source code of this file.

Macros

#define ADJUST_VOLUME(s, v)   (s = (s*v)/SDL_MIX_MAXVOLUME)
 
#define ADJUST_VOLUME_U8(s, v)   (s = (((s-128)*v)/SDL_MIX_MAXVOLUME)+128)
 

Functions

void SDL_MixAudioFormat (Uint8 *dst, const Uint8 *src, SDL_AudioFormat format, Uint32 len, int volume)
 

Variables

static const Uint8 mix8 []
 

Macro Definition Documentation

◆ ADJUST_VOLUME

#define ADJUST_VOLUME (   s,
  v 
)    (s = (s*v)/SDL_MIX_MAXVOLUME)

Definition at line 85 of file SDL_mixer.c.

◆ ADJUST_VOLUME_U8

#define ADJUST_VOLUME_U8 (   s,
  v 
)    (s = (((s-128)*v)/SDL_MIX_MAXVOLUME)+128)

Definition at line 86 of file SDL_mixer.c.

Function Documentation

◆ SDL_MixAudioFormat()

void SDL_MixAudioFormat ( Uint8 dst,
const Uint8 src,
SDL_AudioFormat  format,
Uint32  len,
int  volume 
)

This works like SDL_MixAudio(), but you specify the audio format instead of using the format of audio device 1. Thus it can be used when no audio device is open at all.

Definition at line 90 of file SDL_mixer.c.

92{
93 if (volume == 0) {
94 return;
95 }
96
97 switch (format) {
98
99 case AUDIO_U8:
100 {
101#if defined(__GNUC__) && defined(__M68000__) && !defined(__mcoldfire__) && defined(SDL_ASSEMBLY_ROUTINES)
102 SDL_MixAudio_m68k_U8((char *) dst, (char *) src,
103 (unsigned long) len, (long) volume,
104 (char *) mix8);
105#else
106 Uint8 src_sample;
107
108 while (len--) {
109 src_sample = *src;
110 ADJUST_VOLUME_U8(src_sample, volume);
111 *dst = mix8[*dst + src_sample];
112 ++dst;
113 ++src;
114 }
115#endif
116 }
117 break;
118
119 case AUDIO_S8:
120 {
121 Sint8 *dst8, *src8;
122 Sint8 src_sample;
123 int dst_sample;
124 const int max_audioval = ((1 << (8 - 1)) - 1);
125 const int min_audioval = -(1 << (8 - 1));
126
127 src8 = (Sint8 *) src;
128 dst8 = (Sint8 *) dst;
129 while (len--) {
130 src_sample = *src8;
131 ADJUST_VOLUME(src_sample, volume);
132 dst_sample = *dst8 + src_sample;
133 if (dst_sample > max_audioval) {
134 *dst8 = max_audioval;
135 } else if (dst_sample < min_audioval) {
136 *dst8 = min_audioval;
137 } else {
138 *dst8 = dst_sample;
139 }
140 ++dst8;
141 ++src8;
142 }
143 }
144 break;
145
146 case AUDIO_S16LSB:
147 {
148 Sint16 src1, src2;
149 int dst_sample;
150 const int max_audioval = ((1 << (16 - 1)) - 1);
151 const int min_audioval = -(1 << (16 - 1));
152
153 len /= 2;
154 while (len--) {
155 src1 = ((src[1]) << 8 | src[0]);
156 ADJUST_VOLUME(src1, volume);
157 src2 = ((dst[1]) << 8 | dst[0]);
158 src += 2;
159 dst_sample = src1 + src2;
160 if (dst_sample > max_audioval) {
161 dst_sample = max_audioval;
162 } else if (dst_sample < min_audioval) {
163 dst_sample = min_audioval;
164 }
165 dst[0] = dst_sample & 0xFF;
166 dst_sample >>= 8;
167 dst[1] = dst_sample & 0xFF;
168 dst += 2;
169 }
170 }
171 break;
172
173 case AUDIO_S16MSB:
174 {
175#if defined(__GNUC__) && defined(__M68000__) && !defined(__mcoldfire__) && defined(SDL_ASSEMBLY_ROUTINES)
176 SDL_MixAudio_m68k_S16MSB((short *) dst, (short *) src,
177 (unsigned long) len, (long) volume);
178#else
179 Sint16 src1, src2;
180 int dst_sample;
181 const int max_audioval = ((1 << (16 - 1)) - 1);
182 const int min_audioval = -(1 << (16 - 1));
183
184 len /= 2;
185 while (len--) {
186 src1 = ((src[0]) << 8 | src[1]);
187 ADJUST_VOLUME(src1, volume);
188 src2 = ((dst[0]) << 8 | dst[1]);
189 src += 2;
190 dst_sample = src1 + src2;
191 if (dst_sample > max_audioval) {
192 dst_sample = max_audioval;
193 } else if (dst_sample < min_audioval) {
194 dst_sample = min_audioval;
195 }
196 dst[1] = dst_sample & 0xFF;
197 dst_sample >>= 8;
198 dst[0] = dst_sample & 0xFF;
199 dst += 2;
200 }
201#endif
202 }
203 break;
204
205 case AUDIO_U16LSB:
206 {
207 Uint16 src1, src2;
208 int dst_sample;
209 const int max_audioval = 0xFFFF;
210
211 len /= 2;
212 while (len--) {
213 src1 = ((src[1]) << 8 | src[0]);
214 ADJUST_VOLUME(src1, volume);
215 src2 = ((dst[1]) << 8 | dst[0]);
216 src += 2;
217 dst_sample = src1 + src2;
218 if (dst_sample > max_audioval) {
219 dst_sample = max_audioval;
220 }
221 dst[0] = dst_sample & 0xFF;
222 dst_sample >>= 8;
223 dst[1] = dst_sample & 0xFF;
224 dst += 2;
225 }
226 }
227 break;
228
229 case AUDIO_U16MSB:
230 {
231 Uint16 src1, src2;
232 int dst_sample;
233 const int max_audioval = 0xFFFF;
234
235 len /= 2;
236 while (len--) {
237 src1 = ((src[0]) << 8 | src[1]);
238 ADJUST_VOLUME(src1, volume);
239 src2 = ((dst[0]) << 8 | dst[1]);
240 src += 2;
241 dst_sample = src1 + src2;
242 if (dst_sample > max_audioval) {
243 dst_sample = max_audioval;
244 }
245 dst[1] = dst_sample & 0xFF;
246 dst_sample >>= 8;
247 dst[0] = dst_sample & 0xFF;
248 dst += 2;
249 }
250 }
251 break;
252
253 case AUDIO_S32LSB:
254 {
255 const Uint32 *src32 = (Uint32 *) src;
256 Uint32 *dst32 = (Uint32 *) dst;
257 Sint64 src1, src2;
258 Sint64 dst_sample;
259 const Sint64 max_audioval = ((((Sint64) 1) << (32 - 1)) - 1);
260 const Sint64 min_audioval = -(((Sint64) 1) << (32 - 1));
261
262 len /= 4;
263 while (len--) {
264 src1 = (Sint64) ((Sint32) SDL_SwapLE32(*src32));
265 src32++;
266 ADJUST_VOLUME(src1, volume);
267 src2 = (Sint64) ((Sint32) SDL_SwapLE32(*dst32));
268 dst_sample = src1 + src2;
269 if (dst_sample > max_audioval) {
270 dst_sample = max_audioval;
271 } else if (dst_sample < min_audioval) {
272 dst_sample = min_audioval;
273 }
274 *(dst32++) = SDL_SwapLE32((Uint32) ((Sint32) dst_sample));
275 }
276 }
277 break;
278
279 case AUDIO_S32MSB:
280 {
281 const Uint32 *src32 = (Uint32 *) src;
282 Uint32 *dst32 = (Uint32 *) dst;
283 Sint64 src1, src2;
284 Sint64 dst_sample;
285 const Sint64 max_audioval = ((((Sint64) 1) << (32 - 1)) - 1);
286 const Sint64 min_audioval = -(((Sint64) 1) << (32 - 1));
287
288 len /= 4;
289 while (len--) {
290 src1 = (Sint64) ((Sint32) SDL_SwapBE32(*src32));
291 src32++;
292 ADJUST_VOLUME(src1, volume);
293 src2 = (Sint64) ((Sint32) SDL_SwapBE32(*dst32));
294 dst_sample = src1 + src2;
295 if (dst_sample > max_audioval) {
296 dst_sample = max_audioval;
297 } else if (dst_sample < min_audioval) {
298 dst_sample = min_audioval;
299 }
300 *(dst32++) = SDL_SwapBE32((Uint32) ((Sint32) dst_sample));
301 }
302 }
303 break;
304
305 case AUDIO_F32LSB:
306 {
307 const float fmaxvolume = 1.0f / ((float) SDL_MIX_MAXVOLUME);
308 const float fvolume = (float) volume;
309 const float *src32 = (float *) src;
310 float *dst32 = (float *) dst;
311 float src1, src2;
312 double dst_sample;
313 /* !!! FIXME: are these right? */
314 const double max_audioval = 3.402823466e+38F;
315 const double min_audioval = -3.402823466e+38F;
316
317 len /= 4;
318 while (len--) {
319 src1 = ((SDL_SwapFloatLE(*src32) * fvolume) * fmaxvolume);
320 src2 = SDL_SwapFloatLE(*dst32);
321 src32++;
322
323 dst_sample = ((double) src1) + ((double) src2);
324 if (dst_sample > max_audioval) {
325 dst_sample = max_audioval;
326 } else if (dst_sample < min_audioval) {
327 dst_sample = min_audioval;
328 }
329 *(dst32++) = SDL_SwapFloatLE((float) dst_sample);
330 }
331 }
332 break;
333
334 case AUDIO_F32MSB:
335 {
336 const float fmaxvolume = 1.0f / ((float) SDL_MIX_MAXVOLUME);
337 const float fvolume = (float) volume;
338 const float *src32 = (float *) src;
339 float *dst32 = (float *) dst;
340 float src1, src2;
341 double dst_sample;
342 /* !!! FIXME: are these right? */
343 const double max_audioval = 3.402823466e+38F;
344 const double min_audioval = -3.402823466e+38F;
345
346 len /= 4;
347 while (len--) {
348 src1 = ((SDL_SwapFloatBE(*src32) * fvolume) * fmaxvolume);
349 src2 = SDL_SwapFloatBE(*dst32);
350 src32++;
351
352 dst_sample = ((double) src1) + ((double) src2);
353 if (dst_sample > max_audioval) {
354 dst_sample = max_audioval;
355 } else if (dst_sample < min_audioval) {
356 dst_sample = min_audioval;
357 }
358 *(dst32++) = SDL_SwapFloatBE((float) dst_sample);
359 }
360 }
361 break;
362
363 default: /* If this happens... FIXME! */
364 SDL_SetError("SDL_MixAudioFormat(): unknown audio format");
365 return;
366 }
367}
#define AUDIO_U16LSB
Definition: SDL_audio.h:91
#define AUDIO_S16LSB
Definition: SDL_audio.h:92
#define AUDIO_F32MSB
Definition: SDL_audio.h:113
#define AUDIO_S32MSB
Definition: SDL_audio.h:104
#define AUDIO_S16MSB
Definition: SDL_audio.h:94
#define AUDIO_U16MSB
Definition: SDL_audio.h:93
#define AUDIO_U8
Definition: SDL_audio.h:89
#define AUDIO_S8
Definition: SDL_audio.h:90
#define AUDIO_S32LSB
Definition: SDL_audio.h:103
#define SDL_MIX_MAXVOLUME
Definition: SDL_audio.h:649
#define AUDIO_F32LSB
Definition: SDL_audio.h:112
#define SDL_SetError
#define SDL_SwapFloatBE(X)
Definition: SDL_endian.h:239
#define SDL_SwapLE32(X)
Definition: SDL_endian.h:233
#define SDL_SwapBE32(X)
Definition: SDL_endian.h:237
#define SDL_SwapFloatLE(X)
Definition: SDL_endian.h:235
#define ADJUST_VOLUME_U8(s, v)
Definition: SDL_mixer.c:86
#define ADJUST_VOLUME(s, v)
Definition: SDL_mixer.c:85
static const Uint8 mix8[]
Definition: SDL_mixer.c:34
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
GLenum src
GLenum GLsizei len
GLenum GLenum dst
int8_t Sint8
Definition: SDL_stdinc.h:173
uint32_t Uint32
Definition: SDL_stdinc.h:203
int32_t Sint32
Definition: SDL_stdinc.h:197
int16_t Sint16
Definition: SDL_stdinc.h:185
uint16_t Uint16
Definition: SDL_stdinc.h:191
uint8_t Uint8
Definition: SDL_stdinc.h:179
int64_t Sint64
Definition: SDL_stdinc.h:210

References ADJUST_VOLUME, ADJUST_VOLUME_U8, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_S8, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8, mix8, SDL_MIX_MAXVOLUME, SDL_SetError, SDL_SwapBE32, SDL_SwapFloatBE, SDL_SwapFloatLE, and SDL_SwapLE32.

Variable Documentation

◆ mix8

const Uint8 mix8[]
static

Definition at line 34 of file SDL_mixer.c.

Referenced by SDL_MixAudioFormat().