/
SDL_audiocvt.c
1032 lines (873 loc) · 33.1 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2017 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "../SDL_internal.h"
/* Functions for audio drivers to perform runtime conversion of audio format */
#include "SDL_audio.h"
#include "SDL_audio_c.h"
28
#include "SDL_loadso.h"
29
#include "SDL_assert.h"
30
#include "../SDL_dataqueue.h"
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
/* !!! FIXME: wire this up to the configure script, etc. */
#include "SDL_cpuinfo.h"
#define HAVE_SSE3_INTRINSICS 0
#if HAVE_SSE3_INTRINSICS
#include <pmmintrin.h>
#endif
#if HAVE_SSE3_INTRINSICS
/* Effectively mix right and left channels into a single channel */
static void SDLCALL
SDL_ConvertStereoToMono_SSE3(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
float *dst = (float *) cvt->buf;
const float *src = dst;
int i = cvt->len_cvt / 8;
LOG_DEBUG_CONVERT("stereo", "mono (using SSE3)");
SDL_assert(format == AUDIO_F32SYS);
/* We can only do this if dst is aligned to 16 bytes; since src is the
same pointer and it moves by 2, it can't be forcibly aligned. */
if ((((size_t) dst) & 15) == 0) {
/* Aligned! Do SSE blocks as long as we have 16 bytes available. */
const __m128 divby2 = _mm_set1_ps(0.5f);
while (i >= 4) { /* 4 * float32 */
_mm_store_ps(dst, _mm_mul_ps(_mm_hadd_ps(_mm_load_ps(src), _mm_load_ps(src+4)), divby2));
i -= 4; src += 8; dst += 4;
}
}
/* Finish off any leftovers with scalar operations. */
while (i) {
*dst = (src[0] + src[1]) * 0.5f;
dst++; i--; src += 2;
}
cvt->len_cvt /= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
#endif
76
77
/* Effectively mix right and left channels into a single channel */
static void SDLCALL
78
SDL_ConvertStereoToMono(SDL_AudioCVT * cvt, SDL_AudioFormat format)
79
{
80
81
float *dst = (float *) cvt->buf;
const float *src = dst;
82
83
int i;
84
85
86
87
LOG_DEBUG_CONVERT("stereo", "mono");
SDL_assert(format == AUDIO_F32SYS);
for (i = cvt->len_cvt / 8; i; --i, src += 2) {
88
*(dst++) = (src[0] + src[1]) * 0.5f;
89
90
91
92
93
94
95
96
97
}
cvt->len_cvt /= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
98
/* Convert from 5.1 to stereo. Average left and right, discard subwoofer. */
99
static void SDLCALL
100
SDL_Convert51ToStereo(SDL_AudioCVT * cvt, SDL_AudioFormat format)
101
{
102
103
float *dst = (float *) cvt->buf;
const float *src = dst;
104
105
int i;
106
LOG_DEBUG_CONVERT("5.1", "stereo");
107
SDL_assert(format == AUDIO_F32SYS);
108
109
/* this assumes FL+FR+FC+subwoof+BL+BR layout. */
110
for (i = cvt->len_cvt / (sizeof (float) * 6); i; --i, src += 6, dst += 2) {
111
112
113
const double front_center = (double) src[2];
dst[0] = (float) ((src[0] + front_center + src[4]) / 3.0); /* left */
dst[1] = (float) ((src[1] + front_center + src[5]) / 3.0); /* right */
114
115
116
117
118
119
120
121
122
}
cvt->len_cvt /= 3;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
123
/* Convert from 5.1 to quad */
124
static void SDLCALL
125
SDL_Convert51ToQuad(SDL_AudioCVT * cvt, SDL_AudioFormat format)
126
{
127
128
float *dst = (float *) cvt->buf;
const float *src = dst;
129
130
int i;
131
LOG_DEBUG_CONVERT("5.1", "quad");
132
SDL_assert(format == AUDIO_F32SYS);
133
134
/* assumes quad is FL+FR+BL+BR layout and 5.1 is FL+FR+FC+subwoof+BL+BR */
135
for (i = cvt->len_cvt / (sizeof (float) * 6); i; --i, src += 6, dst += 4) {
136
137
138
139
140
141
/* FIXME: this is a good candidate for SIMD. */
const double front_center = (double) src[2];
dst[0] = (float) ((src[0] + front_center) * 0.5); /* FL */
dst[1] = (float) ((src[1] + front_center) * 0.5); /* FR */
dst[2] = (float) ((src[4] + front_center) * 0.5); /* BL */
dst[3] = (float) ((src[5] + front_center) * 0.5); /* BR */
142
143
144
145
146
147
148
149
150
}
cvt->len_cvt /= 6;
cvt->len_cvt *= 4;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
151
152
153
/* Duplicate a mono channel to both stereo channels */
static void SDLCALL
154
SDL_ConvertMonoToStereo(SDL_AudioCVT * cvt, SDL_AudioFormat format)
155
{
156
157
const float *src = (const float *) (cvt->buf + cvt->len_cvt);
float *dst = (float *) (cvt->buf + cvt->len_cvt * 2);
158
159
int i;
160
161
LOG_DEBUG_CONVERT("mono", "stereo");
SDL_assert(format == AUDIO_F32SYS);
162
163
164
165
166
for (i = cvt->len_cvt / sizeof (float); i; --i) {
src--;
dst -= 2;
dst[0] = dst[1] = *src;
167
168
169
170
171
172
173
174
175
176
177
}
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Duplicate a stereo channel to a pseudo-5.1 stream */
static void SDLCALL
178
SDL_ConvertStereoTo51(SDL_AudioCVT * cvt, SDL_AudioFormat format)
179
180
{
int i;
181
182
183
184
185
186
187
188
189
190
191
192
float lf, rf, ce;
const float *src = (const float *) (cvt->buf + cvt->len_cvt);
float *dst = (float *) (cvt->buf + cvt->len_cvt * 3);
LOG_DEBUG_CONVERT("stereo", "5.1");
SDL_assert(format == AUDIO_F32SYS);
for (i = cvt->len_cvt / 8; i; --i) {
dst -= 6;
src -= 2;
lf = src[0];
rf = src[1];
193
194
195
196
197
198
199
ce = (lf + rf) * 0.5f;
dst[0] = lf + (lf - ce); /* FL */
dst[1] = rf + (rf - ce); /* FR */
dst[2] = ce; /* FC */
dst[3] = ce; /* !!! FIXME: wrong! This is the subwoofer. */
dst[4] = lf; /* BL */
dst[5] = rf; /* BR */
200
}
201
202
203
204
205
206
207
208
209
210
cvt->len_cvt *= 3;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Duplicate a stereo channel to a pseudo-4.0 stream */
static void SDLCALL
211
SDL_ConvertStereoToQuad(SDL_AudioCVT * cvt, SDL_AudioFormat format)
212
{
213
214
const float *src = (const float *) (cvt->buf + cvt->len_cvt);
float *dst = (float *) (cvt->buf + cvt->len_cvt * 2);
215
float lf, rf;
216
217
int i;
218
219
220
221
222
223
224
225
LOG_DEBUG_CONVERT("stereo", "quad");
SDL_assert(format == AUDIO_F32SYS);
for (i = cvt->len_cvt / 8; i; --i) {
dst -= 4;
src -= 2;
lf = src[0];
rf = src[1];
226
227
228
229
dst[0] = lf; /* FL */
dst[1] = rf; /* FR */
dst[2] = lf; /* BL */
dst[3] = rf; /* BR */
230
}
231
232
233
234
235
236
237
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
238
239
240
241
242
static int
SDL_ResampleAudioSimple(const int chans, const double rate_incr,
float *last_sample, const float *inbuf,
const int inbuflen, float *outbuf, const int outbuflen)
{
243
const int framelen = chans * (int)sizeof (float);
244
const int total = (inbuflen / framelen);
245
246
const int finalpos = (total * chans) - chans;
const int dest_samples = (int)(((double)total) * rate_incr);
247
248
const double src_incr = 1.0 / rate_incr;
float *dst = outbuf;
249
250
float *target = (dst + (dest_samples * chans));
double idx = 0.0;
251
252
int i;
253
SDL_assert((dest_samples * framelen) <= outbuflen);
254
255
SDL_assert((inbuflen % framelen) == 0);
256
while (dst < target) {
257
const int pos = ((int)idx) * chans;
258
259
const float *src = &inbuf[pos];
SDL_assert(pos <= finalpos);
260
261
262
263
264
265
266
267
for (i = 0; i < chans; i++) {
const float val = *(src++);
*(dst++) = (val + last_sample[i]) * 0.5f;
last_sample[i] = val;
}
idx += src_incr;
}
268
return (int) ((dst - outbuf) * (int)sizeof(float));
269
270
}
271
272
273
274
275
276
277
278
279
int
SDL_ConvertAudio(SDL_AudioCVT * cvt)
{
/* !!! FIXME: (cvt) should be const; stack-copy it here. */
/* !!! FIXME: (actually, we can't...len_cvt needs to be updated. Grr.) */
/* Make sure there's data to convert */
if (cvt->buf == NULL) {
280
return SDL_SetError("No buffer allocated for conversion");
281
}
282
283
284
285
/* Return okay if no conversion is necessary */
cvt->len_cvt = cvt->len;
if (cvt->filters[0] == NULL) {
286
return 0;
287
288
289
290
291
}
/* Set up the conversion and go! */
cvt->filter_index = 0;
cvt->filters[0] (cvt, cvt->src_format);
292
return 0;
293
294
}
295
296
static void SDLCALL
SDL_Convert_Byteswap(SDL_AudioCVT *cvt, SDL_AudioFormat format)
297
{
298
299
300
#if DEBUG_CONVERT
printf("Converting byte order\n");
#endif
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
switch (SDL_AUDIO_BITSIZE(format)) {
#define CASESWAP(b) \
case b: { \
Uint##b *ptr = (Uint##b *) cvt->buf; \
int i; \
for (i = cvt->len_cvt / sizeof (*ptr); i; --i, ++ptr) { \
*ptr = SDL_Swap##b(*ptr); \
} \
break; \
}
CASESWAP(16);
CASESWAP(32);
CASESWAP(64);
#undef CASESWAP
default: SDL_assert(!"unhandled byteswap datatype!"); break;
}
321
322
323
324
325
326
327
328
329
330
if (cvt->filters[++cvt->filter_index]) {
/* flip endian flag for data. */
if (format & SDL_AUDIO_MASK_ENDIAN) {
format &= ~SDL_AUDIO_MASK_ENDIAN;
} else {
format |= SDL_AUDIO_MASK_ENDIAN;
}
cvt->filters[cvt->filter_index](cvt, format);
}
331
332
333
334
}
static int
335
SDL_BuildAudioTypeCVTToFloat(SDL_AudioCVT *cvt, const SDL_AudioFormat src_fmt)
336
{
337
int retval = 0; /* 0 == no conversion necessary. */
338
339
340
341
342
if ((SDL_AUDIO_ISBIGENDIAN(src_fmt) != 0) == (SDL_BYTEORDER == SDL_LIL_ENDIAN)) {
cvt->filters[cvt->filter_index++] = SDL_Convert_Byteswap;
retval = 1; /* added a converter. */
}
343
344
if (!SDL_AUDIO_ISFLOAT(src_fmt)) {
345
346
const Uint16 src_bitsize = SDL_AUDIO_BITSIZE(src_fmt);
const Uint16 dst_bitsize = 32;
347
SDL_AudioFilter filter = NULL;
348
349
350
351
352
switch (src_fmt & ~SDL_AUDIO_MASK_ENDIAN) {
case AUDIO_S8: filter = SDL_Convert_S8_to_F32; break;
case AUDIO_U8: filter = SDL_Convert_U8_to_F32; break;
case AUDIO_S16: filter = SDL_Convert_S16_to_F32; break;
353
case AUDIO_U16: filter = SDL_Convert_U16_to_F32; break;
354
355
case AUDIO_S32: filter = SDL_Convert_S32_to_F32; break;
default: SDL_assert(!"Unexpected audio format!"); break;
356
357
}
358
359
360
361
if (!filter) {
return SDL_SetError("No conversion available for these formats");
}
362
363
364
365
366
367
368
369
cvt->filters[cvt->filter_index++] = filter;
if (src_bitsize < dst_bitsize) {
const int mult = (dst_bitsize / src_bitsize);
cvt->len_mult *= mult;
cvt->len_ratio *= mult;
} else if (src_bitsize > dst_bitsize) {
cvt->len_ratio /= (src_bitsize / dst_bitsize);
}
370
371
retval = 1; /* added a converter. */
372
373
}
374
return retval;
375
376
}
377
378
static int
SDL_BuildAudioTypeCVTFromFloat(SDL_AudioCVT *cvt, const SDL_AudioFormat dst_fmt)
379
{
380
381
382
int retval = 0; /* 0 == no conversion necessary. */
if (!SDL_AUDIO_ISFLOAT(dst_fmt)) {
383
384
const Uint16 dst_bitsize = SDL_AUDIO_BITSIZE(dst_fmt);
const Uint16 src_bitsize = 32;
385
386
387
388
389
SDL_AudioFilter filter = NULL;
switch (dst_fmt & ~SDL_AUDIO_MASK_ENDIAN) {
case AUDIO_S8: filter = SDL_Convert_F32_to_S8; break;
case AUDIO_U8: filter = SDL_Convert_F32_to_U8; break;
case AUDIO_S16: filter = SDL_Convert_F32_to_S16; break;
390
case AUDIO_U16: filter = SDL_Convert_F32_to_U16; break;
391
392
393
394
395
396
397
case AUDIO_S32: filter = SDL_Convert_F32_to_S32; break;
default: SDL_assert(!"Unexpected audio format!"); break;
}
if (!filter) {
return SDL_SetError("No conversion available for these formats");
}
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
cvt->filters[cvt->filter_index++] = filter;
if (src_bitsize < dst_bitsize) {
const int mult = (dst_bitsize / src_bitsize);
cvt->len_mult *= mult;
cvt->len_ratio *= mult;
} else if (src_bitsize > dst_bitsize) {
cvt->len_ratio /= (src_bitsize / dst_bitsize);
}
retval = 1; /* added a converter. */
}
if ((SDL_AUDIO_ISBIGENDIAN(dst_fmt) != 0) == (SDL_BYTEORDER == SDL_LIL_ENDIAN)) {
cvt->filters[cvt->filter_index++] = SDL_Convert_Byteswap;
retval = 1; /* added a converter. */
}
return retval;
416
417
}
418
419
420
421
422
423
424
static void
SDL_ResampleCVT(SDL_AudioCVT *cvt, const int chans, const SDL_AudioFormat format)
{
const float *src = (const float *) cvt->buf;
const int srclen = cvt->len_cvt;
float *dst = (float *) (cvt->buf + srclen);
const int dstlen = (cvt->len * cvt->len_mult) - srclen;
425
float state[8];
426
427
428
SDL_assert(format == AUDIO_F32SYS);
429
SDL_memcpy(state, src, chans*sizeof(*src));
430
431
cvt->len_cvt = SDL_ResampleAudioSimple(chans, cvt->rate_incr, state, src, srclen, dst, dstlen);
432
433
434
435
436
437
438
439
440
441
442
SDL_memcpy(cvt->buf, dst, cvt->len_cvt);
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index](cvt, format);
}
}
/* !!! FIXME: We only have this macro salsa because SDL_AudioCVT doesn't
!!! FIXME: store channel info, so we have to have function entry
!!! FIXME: points for each supported channel count and multiple
!!! FIXME: vs arbitrary. When we rev the ABI, clean this up. */
443
444
#define RESAMPLER_FUNCS(chans) \
static void SDLCALL \
445
446
SDL_ResampleCVT_c##chans(SDL_AudioCVT *cvt, SDL_AudioFormat format) { \
SDL_ResampleCVT(cvt, chans, format); \
447
448
449
450
451
452
453
454
}
RESAMPLER_FUNCS(1)
RESAMPLER_FUNCS(2)
RESAMPLER_FUNCS(4)
RESAMPLER_FUNCS(6)
RESAMPLER_FUNCS(8)
#undef RESAMPLER_FUNCS
455
static SDL_AudioFilter
456
ChooseCVTResampler(const int dst_channels)
457
{
458
459
460
461
462
463
464
switch (dst_channels) {
case 1: return SDL_ResampleCVT_c1;
case 2: return SDL_ResampleCVT_c2;
case 4: return SDL_ResampleCVT_c4;
case 6: return SDL_ResampleCVT_c6;
case 8: return SDL_ResampleCVT_c8;
default: break;
465
466
}
467
return NULL;
468
469
470
471
472
473
474
475
476
477
478
479
}
static int
SDL_BuildAudioResampleCVT(SDL_AudioCVT * cvt, const int dst_channels,
const int src_rate, const int dst_rate)
{
SDL_AudioFilter filter;
if (src_rate == dst_rate) {
return 0; /* no conversion necessary. */
}
480
filter = ChooseCVTResampler(dst_channels);
481
482
483
if (filter == NULL) {
return SDL_SetError("No conversion available for these rates");
}
484
485
486
487
488
489
490
491
492
/* Update (cvt) with filter details... */
cvt->filters[cvt->filter_index++] = filter;
if (src_rate < dst_rate) {
const double mult = ((double) dst_rate) / ((double) src_rate);
cvt->len_mult *= (int) SDL_ceil(mult);
cvt->len_ratio *= mult;
} else {
cvt->len_ratio /= ((double) src_rate) / ((double) dst_rate);
493
494
}
495
496
497
498
/* the buffer is big enough to hold the destination now, but
we need it large enough to hold a separate scratch buffer. */
cvt->len_mult *= 2;
499
return 1; /* added a converter. */
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
}
/* Creates a set of audio filters to convert from one format to another.
Returns -1 if the format conversion is not supported, 0 if there's
no conversion needed, or 1 if the audio filter is set up.
*/
int
SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
SDL_AudioFormat src_fmt, Uint8 src_channels, int src_rate,
SDL_AudioFormat dst_fmt, Uint8 dst_channels, int dst_rate)
{
/* Sanity check target pointer */
if (cvt == NULL) {
return SDL_InvalidParamError("cvt");
}
518
519
520
/* Make sure we zero out the audio conversion before error checking */
SDL_zerop(cvt);
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
/* there are no unsigned types over 16 bits, so catch this up front. */
if ((SDL_AUDIO_BITSIZE(src_fmt) > 16) && (!SDL_AUDIO_ISSIGNED(src_fmt))) {
return SDL_SetError("Invalid source format");
}
if ((SDL_AUDIO_BITSIZE(dst_fmt) > 16) && (!SDL_AUDIO_ISSIGNED(dst_fmt))) {
return SDL_SetError("Invalid destination format");
}
/* prevent possible divisions by zero, etc. */
if ((src_channels == 0) || (dst_channels == 0)) {
return SDL_SetError("Source or destination channels is zero");
}
if ((src_rate == 0) || (dst_rate == 0)) {
return SDL_SetError("Source or destination rate is zero");
}
536
#if DEBUG_CONVERT
537
538
539
540
541
542
543
544
545
546
547
548
549
550
printf("Build format %04x->%04x, channels %u->%u, rate %d->%d\n",
src_fmt, dst_fmt, src_channels, dst_channels, src_rate, dst_rate);
#endif
/* Start off with no conversion necessary */
cvt->src_format = src_fmt;
cvt->dst_format = dst_fmt;
cvt->needed = 0;
cvt->filter_index = 0;
cvt->filters[0] = NULL;
cvt->len_mult = 1;
cvt->len_ratio = 1.0;
cvt->rate_incr = ((double) dst_rate) / ((double) src_rate);
551
552
553
554
555
556
557
558
559
/* Type conversion goes like this now:
- byteswap to CPU native format first if necessary.
- convert to native Float32 if necessary.
- resample and change channel count if necessary.
- convert back to native format.
- byteswap back to foreign format if necessary.
The expectation is we can process data faster in float32
(possibly with SIMD), and making several passes over the same
560
buffer is likely to be CPU cache-friendly, avoiding the
561
562
563
564
biggest performance hit in modern times. Previously we had
(script-generated) custom converters for every data type and
it was a bloat on SDL compile times and final library size. */
565
566
567
568
569
570
571
572
573
574
575
576
/* see if we can skip float conversion entirely. */
if (src_rate == dst_rate && src_channels == dst_channels) {
if (src_fmt == dst_fmt) {
return 0;
}
/* just a byteswap needed? */
if ((src_fmt & ~SDL_AUDIO_MASK_ENDIAN) == (dst_fmt & ~SDL_AUDIO_MASK_ENDIAN)) {
cvt->filters[cvt->filter_index++] = SDL_Convert_Byteswap;
cvt->needed = 1;
return 1;
}
577
578
}
579
/* Convert data types, if necessary. Updates (cvt). */
580
if (SDL_BuildAudioTypeCVTToFloat(cvt, src_fmt) < 0) {
581
582
583
584
585
586
return -1; /* shouldn't happen, but just in case... */
}
/* Channel conversion */
if (src_channels != dst_channels) {
if ((src_channels == 1) && (dst_channels > 1)) {
587
cvt->filters[cvt->filter_index++] = SDL_ConvertMonoToStereo;
588
589
590
591
592
cvt->len_mult *= 2;
src_channels = 2;
cvt->len_ratio *= 2;
}
if ((src_channels == 2) && (dst_channels == 6)) {
593
cvt->filters[cvt->filter_index++] = SDL_ConvertStereoTo51;
594
595
596
597
598
src_channels = 6;
cvt->len_mult *= 3;
cvt->len_ratio *= 3;
}
if ((src_channels == 2) && (dst_channels == 4)) {
599
cvt->filters[cvt->filter_index++] = SDL_ConvertStereoToQuad;
600
601
602
603
604
src_channels = 4;
cvt->len_mult *= 2;
cvt->len_ratio *= 2;
}
while ((src_channels * 2) <= dst_channels) {
605
cvt->filters[cvt->filter_index++] = SDL_ConvertMonoToStereo;
606
607
608
609
610
cvt->len_mult *= 2;
src_channels *= 2;
cvt->len_ratio *= 2;
}
if ((src_channels == 6) && (dst_channels <= 2)) {
611
cvt->filters[cvt->filter_index++] = SDL_Convert51ToStereo;
612
613
614
615
src_channels = 2;
cvt->len_ratio /= 3;
}
if ((src_channels == 6) && (dst_channels == 4)) {
616
cvt->filters[cvt->filter_index++] = SDL_Convert51ToQuad;
617
618
619
620
621
622
623
624
625
src_channels = 4;
cvt->len_ratio /= 2;
}
/* This assumes that 4 channel audio is in the format:
Left {front/back} + Right {front/back}
so converting to L/R stereo works properly.
*/
while (((src_channels % 2) == 0) &&
((src_channels / 2) >= dst_channels)) {
626
627
628
629
630
631
632
633
634
635
636
637
638
639
SDL_AudioFilter filter = NULL;
#if HAVE_SSE3_INTRINSICS
if (SDL_HasSSE3()) {
filter = SDL_ConvertStereoToMono_SSE3;
}
#endif
if (!filter) {
filter = SDL_ConvertStereoToMono;
}
cvt->filters[cvt->filter_index++] = filter;
640
641
642
643
644
645
646
647
648
src_channels /= 2;
cvt->len_ratio /= 2;
}
if (src_channels != dst_channels) {
/* Uh oh.. */ ;
}
}
/* Do rate conversion, if necessary. Updates (cvt). */
649
if (SDL_BuildAudioResampleCVT(cvt, dst_channels, src_rate, dst_rate) < 0) {
650
651
652
return -1; /* shouldn't happen, but just in case... */
}
653
/* Move to final data type. */
654
if (SDL_BuildAudioTypeCVTFromFloat(cvt, dst_fmt) < 0) {
655
return -1; /* shouldn't happen, but just in case... */
656
}
657
658
cvt->needed = (cvt->filter_index != 0);
659
660
661
return (cvt->needed);
}
662
663
664
typedef int (*SDL_ResampleAudioStreamFunc)(SDL_AudioStream *stream, const float *inbuf, const int inbuflen, float *outbuf, const int outbuflen);
typedef void (*SDL_ResetAudioStreamResamplerFunc)(SDL_AudioStream *stream);
typedef void (*SDL_CleanupAudioStreamResamplerFunc)(SDL_AudioStream *stream);
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
struct SDL_AudioStream
{
SDL_AudioCVT cvt_before_resampling;
SDL_AudioCVT cvt_after_resampling;
SDL_DataQueue *queue;
Uint8 *work_buffer;
int work_buffer_len;
Uint8 *resample_buffer;
int resample_buffer_len;
int src_sample_frame_size;
SDL_AudioFormat src_format;
Uint8 src_channels;
int src_rate;
int dst_sample_frame_size;
SDL_AudioFormat dst_format;
Uint8 dst_channels;
int dst_rate;
double rate_incr;
Uint8 pre_resample_channels;
int packetlen;
686
687
688
689
void *resampler_state;
SDL_ResampleAudioStreamFunc resampler_func;
SDL_ResetAudioStreamResamplerFunc reset_resampler_func;
SDL_CleanupAudioStreamResamplerFunc cleanup_resampler_func;
690
691
};
692
#ifdef HAVE_LIBSAMPLERATE_H
693
694
695
static int
SDL_ResampleAudioStream_SRC(SDL_AudioStream *stream, const float *inbuf, const int inbuflen, float *outbuf, const int outbuflen)
{
696
const int framelen = sizeof(float) * stream->pre_resample_channels;
697
SRC_STATE *state = (SRC_STATE *)stream->resampler_state;
698
699
700
SRC_DATA data;
int result;
701
data.data_in = (float *)inbuf; /* Older versions of libsamplerate had a non-const pointer, but didn't write to it */
702
data.input_frames = inbuflen / framelen;
703
704
705
data.input_frames_used = 0;
data.data_out = outbuf;
706
data.output_frames = outbuflen / framelen;
707
708
709
710
data.end_of_input = 0;
data.src_ratio = stream->rate_incr;
711
result = SRC_src_process(state, &data);
712
if (result != 0) {
713
SDL_SetError("src_process() failed: %s", SRC_src_strerror(result));
714
715
716
717
718
719
720
721
722
723
724
725
return 0;
}
/* If this fails, we need to store them off somewhere */
SDL_assert(data.input_frames_used == data.input_frames);
return data.output_frames_gen * (sizeof(float) * stream->pre_resample_channels);
}
static void
SDL_ResetAudioStreamResampler_SRC(SDL_AudioStream *stream)
{
726
SRC_src_reset((SRC_STATE *)stream->resampler_state);
727
728
729
730
731
}
static void
SDL_CleanupAudioStreamResampler_SRC(SDL_AudioStream *stream)
{
732
SRC_STATE *state = (SRC_STATE *)stream->resampler_state;
733
if (state) {
734
SRC_src_delete(state);
735
736
737
738
739
740
741
742
743
744
745
}
stream->resampler_state = NULL;
stream->resampler_func = NULL;
stream->reset_resampler_func = NULL;
stream->cleanup_resampler_func = NULL;
}
static SDL_bool
SetupLibSampleRateResampling(SDL_AudioStream *stream)
{
746
747
int result = 0;
SRC_STATE *state = NULL;
748
749
750
751
752
753
if (SRC_available) {
state = SRC_src_new(SRC_SINC_FASTEST, stream->pre_resample_channels, &result);
if (!state) {
SDL_SetError("src_new() failed: %s", SRC_src_strerror(result));
}
754
755
}
756
757
if (!state) {
SDL_CleanupAudioStreamResampler_SRC(stream);
758
759
760
761
762
763
764
765
766
767
return SDL_FALSE;
}
stream->resampler_state = state;
stream->resampler_func = SDL_ResampleAudioStream_SRC;
stream->reset_resampler_func = SDL_ResetAudioStreamResampler_SRC;
stream->cleanup_resampler_func = SDL_CleanupAudioStreamResampler_SRC;
return SDL_TRUE;
}
768
#endif /* HAVE_LIBSAMPLERATE_H */
769
770
771
772
773
774
775
776
777
778
779
780
781
782
typedef struct
{
SDL_bool resampler_seeded;
float resampler_state[8];
} SDL_AudioStreamResamplerState;
static int
SDL_ResampleAudioStream(SDL_AudioStream *stream, const float *inbuf, const int inbuflen, float *outbuf, const int outbuflen)
{
SDL_AudioStreamResamplerState *state = (SDL_AudioStreamResamplerState*)stream->resampler_state;
const int chans = (int)stream->pre_resample_channels;
783
SDL_assert(chans <= SDL_arraysize(state->resampler_state));
784
785
if (!state->resampler_seeded) {
786
int i;
787
788
789
790
791
792
for (i = 0; i < chans; i++) {
state->resampler_state[i] = inbuf[i];
}
state->resampler_seeded = SDL_TRUE;
}
793
return SDL_ResampleAudioSimple(chans, stream->rate_incr, state->resampler_state, inbuf, inbuflen, outbuf, outbuflen);
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
}
static void
SDL_ResetAudioStreamResampler(SDL_AudioStream *stream)
{
SDL_AudioStreamResamplerState *state = (SDL_AudioStreamResamplerState*)stream->resampler_state;
state->resampler_seeded = SDL_FALSE;
}
static void
SDL_CleanupAudioStreamResampler(SDL_AudioStream *stream)
{
SDL_free(stream->resampler_state);
}
809
810
811
812
813
814
815
SDL_AudioStream *
SDL_NewAudioStream(const SDL_AudioFormat src_format,
const Uint8 src_channels,
const int src_rate,
const SDL_AudioFormat dst_format,
const Uint8 dst_channels,
const int dst_rate)
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
{
const int packetlen = 4096; /* !!! FIXME: good enough for now. */
Uint8 pre_resample_channels;
SDL_AudioStream *retval;
retval = (SDL_AudioStream *) SDL_calloc(1, sizeof (SDL_AudioStream));
if (!retval) {
return NULL;
}
/* If increasing channels, do it after resampling, since we'd just
do more work to resample duplicate channels. If we're decreasing, do
it first so we resample the interpolated data instead of interpolating
the resampled data (!!! FIXME: decide if that works in practice, though!). */
pre_resample_channels = SDL_min(src_channels, dst_channels);
retval->src_sample_frame_size = SDL_AUDIO_BITSIZE(src_format) * src_channels;
retval->src_format = src_format;
retval->src_channels = src_channels;
retval->src_rate = src_rate;
retval->dst_sample_frame_size = SDL_AUDIO_BITSIZE(dst_format) * dst_channels;
retval->dst_format = dst_format;
retval->dst_channels = dst_channels;
retval->dst_rate = dst_rate;
retval->pre_resample_channels = pre_resample_channels;
retval->packetlen = packetlen;
retval->rate_incr = ((double) dst_rate) / ((double) src_rate);
/* Not resampling? It's an easy conversion (and maybe not even that!). */
if (src_rate == dst_rate) {
retval->cvt_before_resampling.needed = SDL_FALSE;
retval->cvt_before_resampling.len_mult = 1;
848
849
if (SDL_BuildAudioCVT(&retval->cvt_after_resampling, src_format, src_channels, dst_rate, dst_format, dst_channels, dst_rate) < 0) {
SDL_FreeAudioStream(retval);
850
851
852
853
854
return NULL; /* SDL_BuildAudioCVT should have called SDL_SetError. */
}
} else {
/* Don't resample at first. Just get us to Float32 format. */
/* !!! FIXME: convert to int32 on devices without hardware float. */
855
856
if (SDL_BuildAudioCVT(&retval->cvt_before_resampling, src_format, src_channels, src_rate, AUDIO_F32SYS, pre_resample_channels, src_rate) < 0) {
SDL_FreeAudioStream(retval);
857
858
859
return NULL; /* SDL_BuildAudioCVT should have called SDL_SetError. */
}
860
#ifdef HAVE_LIBSAMPLERATE_H
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
SetupLibSampleRateResampling(retval);
#endif
if (!retval->resampler_func) {
retval->resampler_state = SDL_calloc(1, sizeof(SDL_AudioStreamResamplerState));
if (!retval->resampler_state) {
SDL_FreeAudioStream(retval);
SDL_OutOfMemory();
return NULL;
}
retval->resampler_func = SDL_ResampleAudioStream;
retval->reset_resampler_func = SDL_ResetAudioStreamResampler;
retval->cleanup_resampler_func = SDL_CleanupAudioStreamResampler;
}
876
/* Convert us to the final format after resampling. */
877
878
if (SDL_BuildAudioCVT(&retval->cvt_after_resampling, AUDIO_F32SYS, pre_resample_channels, dst_rate, dst_format, dst_channels, dst_rate) < 0) {
SDL_FreeAudioStream(retval);
879
880
881
882
883
884
return NULL; /* SDL_BuildAudioCVT should have called SDL_SetError. */
}
}
retval->queue = SDL_NewDataQueue(packetlen, packetlen * 2);
if (!retval->queue) {
885
SDL_FreeAudioStream(retval);
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
return NULL; /* SDL_NewDataQueue should have called SDL_SetError. */
}
return retval;
}
static Uint8 *
EnsureBufferSize(Uint8 **buf, int *len, const int newlen)
{
if (*len < newlen) {
void *ptr = SDL_realloc(*buf, newlen);
if (!ptr) {
SDL_OutOfMemory();
return NULL;
}
*buf = (Uint8 *) ptr;
*len = newlen;
}
return *buf;
}
int
SDL_AudioStreamPut(SDL_AudioStream *stream, const void *buf, const Uint32 _buflen)
{
int buflen = (int) _buflen;
if (!stream) {
return SDL_InvalidParamError("stream");
} else if (!buf) {
return SDL_InvalidParamError("buf");
} else if (buflen == 0) {
return 0; /* nothing to do. */
} else if ((buflen % stream->src_sample_frame_size) != 0) {
return SDL_SetError("Can't add partial sample frames");
}
if (stream->cvt_before_resampling.needed) {
const int workbuflen = buflen * stream->cvt_before_resampling.len_mult; /* will be "* 1" if not needed */
Uint8 *workbuf = EnsureBufferSize(&stream->work_buffer, &stream->work_buffer_len, workbuflen);
if (workbuf == NULL) {
return -1; /* probably out of memory. */
}
SDL_memcpy(workbuf, buf, buflen);
stream->cvt_before_resampling.buf = workbuf;
stream->cvt_before_resampling.len = buflen;
if (SDL_ConvertAudio(&stream->cvt_before_resampling) == -1) {
return -1; /* uhoh! */
}
buf = workbuf;
buflen = stream->cvt_before_resampling.len_cvt;
}
if (stream->dst_rate != stream->src_rate) {
const int workbuflen = buflen * ((int) SDL_ceil(stream->rate_incr));
float *workbuf = (float *) EnsureBufferSize(&stream->resample_buffer, &stream->resample_buffer_len, workbuflen);
if (workbuf == NULL) {
return -1; /* probably out of memory. */
}
944
buflen = stream->resampler_func(stream, (float *) buf, buflen, workbuf, workbuflen);
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
buf = workbuf;
}
if (stream->cvt_after_resampling.needed) {
const int workbuflen = buflen * stream->cvt_before_resampling.len_mult; /* will be "* 1" if not needed */
Uint8 *workbuf;
if (buf == stream->resample_buffer) {
workbuf = EnsureBufferSize(&stream->resample_buffer, &stream->resample_buffer_len, workbuflen);
} else {
const int inplace = (buf == stream->work_buffer);
workbuf = EnsureBufferSize(&stream->work_buffer, &stream->work_buffer_len, workbuflen);
if (workbuf && !inplace) {
SDL_memcpy(workbuf, buf, buflen);
}
}
if (workbuf == NULL) {
return -1; /* probably out of memory. */
}
stream->cvt_after_resampling.buf = workbuf;
stream->cvt_after_resampling.len = buflen;
if (SDL_ConvertAudio(&stream->cvt_after_resampling) == -1) {
return -1; /* uhoh! */
}
buf = workbuf;
buflen = stream->cvt_after_resampling.len_cvt;
}
return SDL_WriteToDataQueue(stream->queue, buf, buflen);
}
void
SDL_AudioStreamClear(SDL_AudioStream *stream)
{
if (!stream) {
SDL_InvalidParamError("stream");
} else {
SDL_ClearDataQueue(stream->queue, stream->packetlen * 2);
985
986
987
if (stream->reset_resampler_func) {
stream->reset_resampler_func(stream);
}
988
989
990
991
992
993
}
}
/* get converted/resampled data from the stream */
int
994
SDL_AudioStreamGet(SDL_AudioStream *stream, void *buf, const Uint32 len)
995
996
997
998
999
1000
{
if (!stream) {
return SDL_InvalidParamError("stream");
} else if (!buf) {
return SDL_InvalidParamError("buf");
} else if (len == 0) {