/
SDL_audiocvt.c
1683 lines (1434 loc) · 57.4 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2019 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
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 */
25
26
27
/* FIXME: Channel weights when converting from more channels to fewer may need to be adjusted, see https://msdn.microsoft.com/en-us/library/windows/desktop/ff819070(v=vs.85).aspx
*/
28
#include "SDL.h"
29
30
31
#include "SDL_audio.h"
#include "SDL_audio_c.h"
32
#include "SDL_loadso.h"
33
#include "SDL_assert.h"
34
#include "../SDL_dataqueue.h"
35
36
#include "SDL_cpuinfo.h"
37
38
#define DEBUG_AUDIOSTREAM 0
39
40
#ifdef __SSE3__
#define HAVE_SSE3_INTRINSICS 1
41
42
43
#endif
#if HAVE_SSE3_INTRINSICS
44
/* Convert from stereo to mono. Average left and right. */
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
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
79
/* Convert from stereo to mono. Average left and right. */
80
static void SDLCALL
81
SDL_ConvertStereoToMono(SDL_AudioCVT * cvt, SDL_AudioFormat format)
82
{
83
84
float *dst = (float *) cvt->buf;
const float *src = dst;
85
86
int i;
87
88
89
90
LOG_DEBUG_CONVERT("stereo", "mono");
SDL_assert(format == AUDIO_F32SYS);
for (i = cvt->len_cvt / 8; i; --i, src += 2) {
91
*(dst++) = (src[0] + src[1]) * 0.5f;
92
93
94
95
96
97
98
99
100
}
cvt->len_cvt /= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
101
/* Convert from 5.1 to stereo. Average left and right, distribute center, discard LFE. */
102
static void SDLCALL
103
SDL_Convert51ToStereo(SDL_AudioCVT * cvt, SDL_AudioFormat format)
104
{
105
106
float *dst = (float *) cvt->buf;
const float *src = dst;
107
108
int i;
109
LOG_DEBUG_CONVERT("5.1", "stereo");
110
SDL_assert(format == AUDIO_F32SYS);
111
112
/* SDL's 5.1 layout: FL+FR+FC+LFE+BL+BR */
113
for (i = cvt->len_cvt / (sizeof (float) * 6); i; --i, src += 6, dst += 2) {
114
115
116
const float front_center_distributed = src[2] * 0.5f;
dst[0] = (src[0] + front_center_distributed + src[4]) / 2.5f; /* left */
dst[1] = (src[1] + front_center_distributed + src[5]) / 2.5f; /* right */
117
118
119
120
121
122
123
124
125
}
cvt->len_cvt /= 3;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/* Convert from quad to stereo. Average left and right. */
static void SDLCALL
SDL_ConvertQuadToStereo(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
float *dst = (float *) cvt->buf;
const float *src = dst;
int i;
LOG_DEBUG_CONVERT("quad", "stereo");
SDL_assert(format == AUDIO_F32SYS);
for (i = cvt->len_cvt / (sizeof (float) * 4); i; --i, src += 4, dst += 2) {
dst[0] = (src[0] + src[2]) * 0.5f; /* left */
dst[1] = (src[1] + src[3]) * 0.5f; /* right */
}
142
cvt->len_cvt /= 2;
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
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Convert from 7.1 to 5.1. Distribute sides across front and back. */
static void SDLCALL
SDL_Convert71To51(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
float *dst = (float *) cvt->buf;
const float *src = dst;
int i;
LOG_DEBUG_CONVERT("7.1", "5.1");
SDL_assert(format == AUDIO_F32SYS);
for (i = cvt->len_cvt / (sizeof (float) * 8); i; --i, src += 8, dst += 6) {
const float surround_left_distributed = src[6] * 0.5f;
const float surround_right_distributed = src[7] * 0.5f;
dst[0] = (src[0] + surround_left_distributed) / 1.5f; /* FL */
dst[1] = (src[1] + surround_right_distributed) / 1.5f; /* FR */
dst[2] = src[2] / 1.5f; /* CC */
dst[3] = src[3] / 1.5f; /* LFE */
dst[4] = (src[4] + surround_left_distributed) / 1.5f; /* BL */
dst[5] = (src[5] + surround_right_distributed) / 1.5f; /* BR */
}
cvt->len_cvt /= 8;
cvt->len_cvt *= 6;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Convert from 5.1 to quad. Distribute center across front, discard LFE. */
180
static void SDLCALL
181
SDL_Convert51ToQuad(SDL_AudioCVT * cvt, SDL_AudioFormat format)
182
{
183
184
float *dst = (float *) cvt->buf;
const float *src = dst;
185
186
int i;
187
LOG_DEBUG_CONVERT("5.1", "quad");
188
SDL_assert(format == AUDIO_F32SYS);
189
190
191
/* SDL's 4.0 layout: FL+FR+BL+BR */
/* SDL's 5.1 layout: FL+FR+FC+LFE+BL+BR */
192
for (i = cvt->len_cvt / (sizeof (float) * 6); i; --i, src += 6, dst += 4) {
193
194
195
196
197
const float front_center_distributed = src[2] * 0.5f;
dst[0] = (src[0] + front_center_distributed) / 1.5f; /* FL */
dst[1] = (src[1] + front_center_distributed) / 1.5f; /* FR */
dst[2] = src[4] / 1.5f; /* BL */
dst[3] = src[5] / 1.5f; /* BR */
198
199
200
201
202
203
204
205
206
}
cvt->len_cvt /= 6;
cvt->len_cvt *= 4;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
207
208
/* Upmix mono to stereo (by duplication) */
209
static void SDLCALL
210
SDL_ConvertMonoToStereo(SDL_AudioCVT * cvt, SDL_AudioFormat format)
211
{
212
213
const float *src = (const float *) (cvt->buf + cvt->len_cvt);
float *dst = (float *) (cvt->buf + cvt->len_cvt * 2);
214
215
int i;
216
217
LOG_DEBUG_CONVERT("mono", "stereo");
SDL_assert(format == AUDIO_F32SYS);
218
219
220
221
222
for (i = cvt->len_cvt / sizeof (float); i; --i) {
src--;
dst -= 2;
dst[0] = dst[1] = *src;
223
224
225
226
227
228
229
230
231
}
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
232
/* Upmix stereo to a pseudo-5.1 stream */
233
static void SDLCALL
234
SDL_ConvertStereoTo51(SDL_AudioCVT * cvt, SDL_AudioFormat format)
235
236
{
int i;
237
238
239
240
241
242
243
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);
244
for (i = cvt->len_cvt / (sizeof(float) * 2); i; --i) {
245
246
247
248
dst -= 6;
src -= 2;
lf = src[0];
rf = src[1];
249
ce = (lf + rf) * 0.5f;
250
/* !!! FIXME: FL and FR may clip */
251
252
253
dst[0] = lf + (lf - ce); /* FL */
dst[1] = rf + (rf - ce); /* FR */
dst[2] = ce; /* FC */
254
dst[3] = 0; /* LFE (only meant for special LFE effects) */
255
256
dst[4] = lf; /* BL */
dst[5] = rf; /* BR */
257
}
258
259
260
261
262
263
264
265
cvt->len_cvt *= 3;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
/* Upmix quad to a pseudo-5.1 stream */
static void SDLCALL
SDL_ConvertQuadTo51(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
int i;
float lf, rf, lb, rb, ce;
const float *src = (const float *) (cvt->buf + cvt->len_cvt);
float *dst = (float *) (cvt->buf + cvt->len_cvt * 3 / 2);
LOG_DEBUG_CONVERT("quad", "5.1");
SDL_assert(format == AUDIO_F32SYS);
SDL_assert(cvt->len_cvt % (sizeof(float) * 4) == 0);
for (i = cvt->len_cvt / (sizeof(float) * 4); i; --i) {
dst -= 6;
src -= 4;
lf = src[0];
rf = src[1];
lb = src[2];
rb = src[3];
ce = (lf + rf) * 0.5f;
/* !!! FIXME: FL and FR may clip */
dst[0] = lf + (lf - ce); /* FL */
dst[1] = rf + (rf - ce); /* FR */
dst[2] = ce; /* FC */
dst[3] = 0; /* LFE (only meant for special LFE effects) */
dst[4] = lb; /* BL */
dst[5] = rb; /* BR */
}
cvt->len_cvt = cvt->len_cvt * 3 / 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
/* Upmix stereo to a pseudo-4.0 stream (by duplication) */
304
static void SDLCALL
305
SDL_ConvertStereoToQuad(SDL_AudioCVT * cvt, SDL_AudioFormat format)
306
{
307
308
const float *src = (const float *) (cvt->buf + cvt->len_cvt);
float *dst = (float *) (cvt->buf + cvt->len_cvt * 2);
309
float lf, rf;
310
311
int i;
312
313
314
LOG_DEBUG_CONVERT("stereo", "quad");
SDL_assert(format == AUDIO_F32SYS);
315
for (i = cvt->len_cvt / (sizeof(float) * 2); i; --i) {
316
317
318
319
dst -= 4;
src -= 2;
lf = src[0];
rf = src[1];
320
321
322
323
dst[0] = lf; /* FL */
dst[1] = rf; /* FR */
dst[2] = lf; /* BL */
dst[3] = rf; /* BR */
324
}
325
326
327
328
329
330
331
cvt->len_cvt *= 2;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
/* Upmix 5.1 to 7.1 */
static void SDLCALL
SDL_Convert51To71(SDL_AudioCVT * cvt, SDL_AudioFormat format)
{
float lf, rf, lb, rb, ls, rs;
int i;
const float *src = (const float *) (cvt->buf + cvt->len_cvt);
float *dst = (float *) (cvt->buf + cvt->len_cvt * 4 / 3);
LOG_DEBUG_CONVERT("5.1", "7.1");
SDL_assert(format == AUDIO_F32SYS);
SDL_assert(cvt->len_cvt % (sizeof(float) * 6) == 0);
for (i = cvt->len_cvt / (sizeof(float) * 6); i; --i) {
dst -= 8;
src -= 6;
lf = src[0];
rf = src[1];
lb = src[4];
rb = src[5];
ls = (lf + lb) * 0.5f;
rs = (rf + rb) * 0.5f;
/* !!! FIXME: these four may clip */
lf += lf - ls;
rf += rf - ls;
lb += lb - ls;
rb += rb - ls;
dst[3] = src[3]; /* LFE */
dst[2] = src[2]; /* FC */
dst[7] = rs; /* SR */
dst[6] = ls; /* SL */
dst[5] = rb; /* BR */
dst[4] = lb; /* BL */
dst[1] = rf; /* FR */
dst[0] = lf; /* FL */
}
cvt->len_cvt = cvt->len_cvt * 4 / 3;
if (cvt->filters[++cvt->filter_index]) {
cvt->filters[cvt->filter_index] (cvt, format);
}
}
377
378
/* SDL's resampler uses a "bandlimited interpolation" algorithm:
https://ccrma.stanford.edu/~jos/resample/ */
379
380
381
382
383
#define RESAMPLER_ZERO_CROSSINGS 5
#define RESAMPLER_BITS_PER_SAMPLE 16
#define RESAMPLER_SAMPLES_PER_ZERO_CROSSING (1 << ((RESAMPLER_BITS_PER_SAMPLE / 2) + 1))
#define RESAMPLER_FILTER_SIZE ((RESAMPLER_SAMPLES_PER_ZERO_CROSSING * RESAMPLER_ZERO_CROSSINGS) + 1)
384
385
386
387
388
389
390
391
392
393
394
395
396
397
/* This is a "modified" bessel function, so you can't use POSIX j0() */
static double
bessel(const double x)
{
const double xdiv2 = x / 2.0;
double i0 = 1.0f;
double f = 1.0f;
int i = 1;
while (SDL_TRUE) {
const double diff = SDL_pow(xdiv2, i * 2) / SDL_pow(f, 2);
if (diff < 1.0e-21f) {
break;
398
}
399
400
401
402
i0 += diff;
i++;
f *= (double) i;
}
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
return i0;
}
/* build kaiser table with cardinal sine applied to it, and array of differences between elements. */
static void
kaiser_and_sinc(float *table, float *diffs, const int tablelen, const double beta)
{
const int lenm1 = tablelen - 1;
const int lenm1div2 = lenm1 / 2;
int i;
table[0] = 1.0f;
for (i = 1; i < tablelen; i++) {
const double kaiser = bessel(beta * SDL_sqrt(1.0 - SDL_pow(((i - lenm1) / 2.0) / lenm1div2, 2.0))) / bessel(beta);
table[tablelen - i] = (float) kaiser;
419
420
}
421
422
423
424
425
426
for (i = 1; i < tablelen; i++) {
const float x = (((float) i) / ((float) RESAMPLER_SAMPLES_PER_ZERO_CROSSING)) * ((float) M_PI);
table[i] *= SDL_sinf(x) / x;
diffs[i - 1] = table[i] - table[i - 1];
}
diffs[lenm1] = 0.0f;
427
428
}
429
430
431
432
433
434
435
static SDL_SpinLock ResampleFilterSpinlock = 0;
static float *ResamplerFilter = NULL;
static float *ResamplerFilterDifference = NULL;
int
SDL_PrepareResampleFilter(void)
436
{
437
438
439
440
441
442
443
444
445
446
447
SDL_AtomicLock(&ResampleFilterSpinlock);
if (!ResamplerFilter) {
/* if dB > 50, beta=(0.1102 * (dB - 8.7)), according to Matlab. */
const double dB = 80.0;
const double beta = 0.1102 * (dB - 8.7);
const size_t alloclen = RESAMPLER_FILTER_SIZE * sizeof (float);
ResamplerFilter = (float *) SDL_malloc(alloclen);
if (!ResamplerFilter) {
SDL_AtomicUnlock(&ResampleFilterSpinlock);
return SDL_OutOfMemory();
448
449
}
450
451
452
453
454
455
ResamplerFilterDifference = (float *) SDL_malloc(alloclen);
if (!ResamplerFilterDifference) {
SDL_free(ResamplerFilter);
ResamplerFilter = NULL;
SDL_AtomicUnlock(&ResampleFilterSpinlock);
return SDL_OutOfMemory();
456
}
457
kaiser_and_sinc(ResamplerFilter, ResamplerFilterDifference, RESAMPLER_FILTER_SIZE, beta);
458
}
459
460
SDL_AtomicUnlock(&ResampleFilterSpinlock);
return 0;
461
462
}
463
464
void
SDL_FreeResampleFilter(void)
465
{
466
467
468
469
470
SDL_free(ResamplerFilter);
SDL_free(ResamplerFilterDifference);
ResamplerFilter = NULL;
ResamplerFilterDifference = NULL;
}
471
472
473
474
static int
ResamplerPadding(const int inrate, const int outrate)
{
475
476
477
478
479
480
if (inrate == outrate) {
return 0;
} else if (inrate > outrate) {
return (int) SDL_ceil(((float) (RESAMPLER_SAMPLES_PER_ZERO_CROSSING * inrate) / ((float) outrate)));
}
return RESAMPLER_SAMPLES_PER_ZERO_CROSSING;
481
}
482
483
/* lpadding and rpadding are expected to be buffers of (ResamplePadding(inrate, outrate) * chans * sizeof (float)) bytes. */
484
485
static int
SDL_ResampleAudio(const int chans, const int inrate, const int outrate,
486
487
488
const float *lpadding, const float *rpadding,
const float *inbuf, const int inbuflen,
float *outbuf, const int outbuflen)
489
{
490
const double finrate = (double) inrate;
491
492
const double outtimeincr = 1.0 / ((float) outrate);
const double ratio = ((float) outrate) / ((float) inrate);
493
const int paddinglen = ResamplerPadding(inrate, outrate);
494
495
496
497
const int framelen = chans * (int)sizeof (float);
const int inframes = inbuflen / framelen;
const int wantedoutframes = (int) ((inbuflen / framelen) * ratio); /* outbuflen isn't total to write, it's total available. */
const int maxoutframes = outbuflen / framelen;
498
const int outframes = SDL_min(wantedoutframes, maxoutframes);
499
float *dst = outbuf;
500
double outtime = 0.0;
501
502
503
504
int i, j, chan;
for (i = 0; i < outframes; i++) {
const int srcindex = (int) (outtime * inrate);
505
506
507
const double intime = ((double) srcindex) / finrate;
const double innexttime = ((double) (srcindex + 1)) / finrate;
const double interpolation1 = 1.0 - ((innexttime - outtime) / (innexttime - intime));
508
const int filterindex1 = (int) (interpolation1 * RESAMPLER_SAMPLES_PER_ZERO_CROSSING);
509
const double interpolation2 = 1.0 - interpolation1;
510
const int filterindex2 = (int) (interpolation2 * RESAMPLER_SAMPLES_PER_ZERO_CROSSING);
511
512
513
514
515
516
517
518
for (chan = 0; chan < chans; chan++) {
float outsample = 0.0f;
/* do this twice to calculate the sample, once for the "left wing" and then same for the right. */
/* !!! FIXME: do both wings in one loop */
for (j = 0; (filterindex1 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)) < RESAMPLER_FILTER_SIZE; j++) {
const int srcframe = srcindex - j;
519
520
/* !!! FIXME: we can bubble this conditional out of here by doing a pre loop. */
const float insample = (srcframe < 0) ? lpadding[((paddinglen + srcframe) * chans) + chan] : inbuf[(srcframe * chans) + chan];
521
outsample += (float)(insample * (ResamplerFilter[filterindex1 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)] + (interpolation1 * ResamplerFilterDifference[filterindex1 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)])));
522
}
523
524
525
for (j = 0; (filterindex2 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)) < RESAMPLER_FILTER_SIZE; j++) {
const int srcframe = srcindex + 1 + j;
526
527
/* !!! FIXME: we can bubble this conditional out of here by doing a post loop. */
const float insample = (srcframe >= inframes) ? rpadding[((srcframe - inframes) * chans) + chan] : inbuf[(srcframe * chans) + chan];
528
outsample += (float)(insample * (ResamplerFilter[filterindex2 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)] + (interpolation2 * ResamplerFilterDifference[filterindex2 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)])));
529
530
531
532
}
*(dst++) = outsample;
}
533
outtime += outtimeincr;
534
535
}
536
537
return outframes * chans * sizeof (float);
}
538
539
540
541
542
543
544
545
546
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) {
547
return SDL_SetError("No buffer allocated for conversion");
548
}
549
550
551
552
/* Return okay if no conversion is necessary */
cvt->len_cvt = cvt->len;
if (cvt->filters[0] == NULL) {
553
return 0;
554
555
556
557
558
}
/* Set up the conversion and go! */
cvt->filter_index = 0;
cvt->filters[0] (cvt, cvt->src_format);
559
return 0;
560
561
}
562
563
static void SDLCALL
SDL_Convert_Byteswap(SDL_AudioCVT *cvt, SDL_AudioFormat format)
564
{
565
566
567
#if DEBUG_CONVERT
printf("Converting byte order\n");
#endif
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
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;
}
588
589
590
591
592
593
594
595
596
597
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);
}
598
599
}
600
601
602
603
604
605
606
607
608
609
610
611
612
static int
SDL_AddAudioCVTFilter(SDL_AudioCVT *cvt, const SDL_AudioFilter filter)
{
if (cvt->filter_index >= SDL_AUDIOCVT_MAX_FILTERS) {
return SDL_SetError("Too many filters needed for conversion, exceeded maximum of %d", SDL_AUDIOCVT_MAX_FILTERS);
}
if (filter == NULL) {
return SDL_SetError("Audio filter pointer is NULL");
}
cvt->filters[cvt->filter_index++] = filter;
cvt->filters[cvt->filter_index] = NULL; /* Moving terminator */
return 0;
}
613
614
static int
615
SDL_BuildAudioTypeCVTToFloat(SDL_AudioCVT *cvt, const SDL_AudioFormat src_fmt)
616
{
617
int retval = 0; /* 0 == no conversion necessary. */
618
619
if ((SDL_AUDIO_ISBIGENDIAN(src_fmt) != 0) == (SDL_BYTEORDER == SDL_LIL_ENDIAN)) {
620
621
622
if (SDL_AddAudioCVTFilter(cvt, SDL_Convert_Byteswap) < 0) {
return -1;
}
623
624
retval = 1; /* added a converter. */
}
625
626
if (!SDL_AUDIO_ISFLOAT(src_fmt)) {
627
628
const Uint16 src_bitsize = SDL_AUDIO_BITSIZE(src_fmt);
const Uint16 dst_bitsize = 32;
629
SDL_AudioFilter filter = NULL;
630
631
632
633
634
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;
635
case AUDIO_U16: filter = SDL_Convert_U16_to_F32; break;
636
637
case AUDIO_S32: filter = SDL_Convert_S32_to_F32; break;
default: SDL_assert(!"Unexpected audio format!"); break;
638
639
}
640
if (!filter) {
641
return SDL_SetError("No conversion from source format to float available");
642
643
}
644
645
646
if (SDL_AddAudioCVTFilter(cvt, filter) < 0) {
return -1;
}
647
648
649
650
651
652
653
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);
}
654
655
retval = 1; /* added a converter. */
656
657
}
658
return retval;
659
660
}
661
662
static int
SDL_BuildAudioTypeCVTFromFloat(SDL_AudioCVT *cvt, const SDL_AudioFormat dst_fmt)
663
{
664
665
666
int retval = 0; /* 0 == no conversion necessary. */
if (!SDL_AUDIO_ISFLOAT(dst_fmt)) {
667
668
const Uint16 dst_bitsize = SDL_AUDIO_BITSIZE(dst_fmt);
const Uint16 src_bitsize = 32;
669
670
671
672
673
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;
674
case AUDIO_U16: filter = SDL_Convert_F32_to_U16; break;
675
676
677
678
679
case AUDIO_S32: filter = SDL_Convert_F32_to_S32; break;
default: SDL_assert(!"Unexpected audio format!"); break;
}
if (!filter) {
680
return SDL_SetError("No conversion from float to destination format available");
681
}
682
683
684
685
if (SDL_AddAudioCVTFilter(cvt, filter) < 0) {
return -1;
}
686
687
688
689
690
691
692
693
694
695
696
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)) {
697
698
699
if (SDL_AddAudioCVTFilter(cvt, SDL_Convert_Byteswap) < 0) {
return -1;
}
700
701
702
703
retval = 1; /* added a converter. */
}
return retval;
704
705
}
706
707
708
static void
SDL_ResampleCVT(SDL_AudioCVT *cvt, const int chans, const SDL_AudioFormat format)
{
709
710
711
/* !!! FIXME in 2.1: there are ten slots in the filter list, and the theoretical maximum we use is six (seven with NULL terminator).
!!! FIXME in 2.1: We need to store data for this resampler, because the cvt structure doesn't store the original sample rates,
!!! FIXME in 2.1: so we steal the ninth and tenth slot. :( */
712
713
const int inrate = (int) (size_t) cvt->filters[SDL_AUDIOCVT_MAX_FILTERS-1];
const int outrate = (int) (size_t) cvt->filters[SDL_AUDIOCVT_MAX_FILTERS];
714
715
const float *src = (const float *) cvt->buf;
const int srclen = cvt->len_cvt;
716
717
718
719
720
/*float *dst = (float *) cvt->buf;
const int dstlen = (cvt->len * cvt->len_mult);*/
/* !!! FIXME: remove this if we can get the resampler to work in-place again. */
float *dst = (float *) (cvt->buf + srclen);
const int dstlen = (cvt->len * cvt->len_mult) - srclen;
721
722
const int requestedpadding = ResamplerPadding(inrate, outrate);
int paddingsamples;
723
float *padding;
724
725
if (requestedpadding < SDL_MAX_SINT32 / chans) {
726
727
728
729
paddingsamples = requestedpadding * chans;
} else {
paddingsamples = 0;
}
730
731
SDL_assert(format == AUDIO_F32SYS);
732
/* we keep no streaming state here, so pad with silence on both ends. */
733
padding = (float *) SDL_calloc(paddingsamples ? paddingsamples : 1, sizeof (float));
734
735
736
737
if (!padding) {
SDL_OutOfMemory();
return;
}
738
739
cvt->len_cvt = SDL_ResampleAudio(chans, inrate, outrate, padding, padding, src, srclen, dst, dstlen);
740
741
SDL_free(padding);
742
743
SDL_memmove(cvt->buf, dst, cvt->len_cvt); /* !!! FIXME: remove this if we can get the resampler to work in-place again. */
744
745
746
747
748
749
750
751
752
753
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. */
754
755
#define RESAMPLER_FUNCS(chans) \
static void SDLCALL \
756
757
SDL_ResampleCVT_c##chans(SDL_AudioCVT *cvt, SDL_AudioFormat format) { \
SDL_ResampleCVT(cvt, chans, format); \
758
759
760
761
762
763
764
765
}
RESAMPLER_FUNCS(1)
RESAMPLER_FUNCS(2)
RESAMPLER_FUNCS(4)
RESAMPLER_FUNCS(6)
RESAMPLER_FUNCS(8)
#undef RESAMPLER_FUNCS
766
static SDL_AudioFilter
767
ChooseCVTResampler(const int dst_channels)
768
{
769
770
771
772
773
774
775
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;
776
777
}
778
return NULL;
779
780
781
782
783
784
785
786
787
788
789
790
}
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. */
}
791
filter = ChooseCVTResampler(dst_channels);
792
793
794
if (filter == NULL) {
return SDL_SetError("No conversion available for these rates");
}
795
796
797
798
799
if (SDL_PrepareResampleFilter() < 0) {
return -1;
}
800
/* Update (cvt) with filter details... */
801
802
803
if (SDL_AddAudioCVTFilter(cvt, filter) < 0) {
return -1;
}
804
805
806
807
808
809
810
811
812
813
/* !!! FIXME in 2.1: there are ten slots in the filter list, and the theoretical maximum we use is six (seven with NULL terminator).
!!! FIXME in 2.1: We need to store data for this resampler, because the cvt structure doesn't store the original sample rates,
!!! FIXME in 2.1: so we steal the ninth and tenth slot. :( */
if (cvt->filter_index >= (SDL_AUDIOCVT_MAX_FILTERS-2)) {
return SDL_SetError("Too many filters needed for conversion, exceeded maximum of %d", SDL_AUDIOCVT_MAX_FILTERS-2);
}
cvt->filters[SDL_AUDIOCVT_MAX_FILTERS-1] = (SDL_AudioFilter) (size_t) src_rate;
cvt->filters[SDL_AUDIOCVT_MAX_FILTERS] = (SDL_AudioFilter) (size_t) dst_rate;
814
815
816
817
818
819
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);
820
821
}
822
823
824
825
826
/* !!! FIXME: remove this if we can get the resampler to work in-place again. */
/* 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;
827
return 1; /* added a converter. */
828
829
}
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
static SDL_bool
SDL_SupportedAudioFormat(const SDL_AudioFormat fmt)
{
switch (fmt) {
case AUDIO_U8:
case AUDIO_S8:
case AUDIO_U16LSB:
case AUDIO_S16LSB:
case AUDIO_U16MSB:
case AUDIO_S16MSB:
case AUDIO_S32LSB:
case AUDIO_S32MSB:
case AUDIO_F32LSB:
case AUDIO_F32MSB:
return SDL_TRUE; /* supported. */
default:
break;
}
return SDL_FALSE; /* unsupported. */
}
static SDL_bool
SDL_SupportedChannelCount(const int channels)
{
switch (channels) {
case 1: /* mono */
case 2: /* stereo */
case 4: /* quad */
case 6: /* 5.1 */
861
862
case 8: /* 7.1 */
return SDL_TRUE; /* supported. */
863
864
865
866
867
868
869
870
default:
break;
}
return SDL_FALSE; /* unsupported. */
}
871
872
/* Creates a set of audio filters to convert from one format to another.
873
874
Returns 0 if no conversion is needed, 1 if the audio filter is set up,
or -1 if an error like invalid parameter, unsupported format, etc. occurred.
875
876
877
878
879
880
881
882
883
884
885
886
*/
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");
}
887
888
889
/* Make sure we zero out the audio conversion before error checking */
SDL_zerop(cvt);
890
if (!SDL_SupportedAudioFormat(src_fmt)) {
891
return SDL_SetError("Invalid source format");
892
} else if (!SDL_SupportedAudioFormat(dst_fmt)) {
893
return SDL_SetError("Invalid destination format");
894
895
896
897
} else if (!SDL_SupportedChannelCount(src_channels)) {
return SDL_SetError("Invalid source channels");
} else if (!SDL_SupportedChannelCount(dst_channels)) {
return SDL_SetError("Invalid destination channels");
898
899
900
901
} else if (src_rate <= 0) {
return SDL_SetError("Source rate is equal to or less than zero");
} else if (dst_rate <= 0) {
return SDL_SetError("Destination rate is equal to or less than zero");
902
} else if (src_rate >= SDL_MAX_SINT32 / RESAMPLER_SAMPLES_PER_ZERO_CROSSING) {
903
return SDL_SetError("Source rate is too high");
904
} else if (dst_rate >= SDL_MAX_SINT32 / RESAMPLER_SAMPLES_PER_ZERO_CROSSING) {
905
return SDL_SetError("Destination rate is too high");
906
907
}
908
#if DEBUG_CONVERT
909
910
911
912
913
914
915
916
917
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;
918
SDL_zero(cvt->filters);
919
920
921
922
cvt->len_mult = 1;
cvt->len_ratio = 1.0;
cvt->rate_incr = ((double) dst_rate) / ((double) src_rate);
923
924
925
/* Make sure we've chosen audio conversion functions (MMX, scalar, etc.) */
SDL_ChooseAudioConverters();
926
927
928
929
930
931
932
933
934
/* 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
935
buffer is likely to be CPU cache-friendly, avoiding the
936
937
938
939
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. */
940
941
942
943
944
945
946
947
/* 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)) {
948
949
950
if (SDL_AddAudioCVTFilter(cvt, SDL_Convert_Byteswap) < 0) {
return -1;
}
951
952
953
cvt->needed = 1;
return 1;
}
954
955
}
956
/* Convert data types, if necessary. Updates (cvt). */
957
if (SDL_BuildAudioTypeCVTToFloat(cvt, src_fmt) < 0) {
958
959
960
961
return -1; /* shouldn't happen, but just in case... */
}
/* Channel conversion */
962
963
964
if (src_channels < dst_channels) {
/* Upmixing */
/* Mono -> Stereo [-> ...] */
965
if ((src_channels == 1) && (dst_channels > 1)) {
966
967
968
if (SDL_AddAudioCVTFilter(cvt, SDL_ConvertMonoToStereo) < 0) {
return -1;
}
969
970
971
972
cvt->len_mult *= 2;
src_channels = 2;
cvt->len_ratio *= 2;
}
973
974
/* [Mono ->] Stereo -> 5.1 [-> 7.1] */
if ((src_channels == 2) && (dst_channels >= 6)) {
975
976
977
if (SDL_AddAudioCVTFilter(cvt, SDL_ConvertStereoTo51) < 0) {
return -1;
}
978
979
980
981
src_channels = 6;
cvt->len_mult *= 3;
cvt->len_ratio *= 3;
}
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* Quad -> 5.1 [-> 7.1] */
if ((src_channels == 4) && (dst_channels >= 6)) {
if (SDL_AddAudioCVTFilter(cvt, SDL_ConvertQuadTo51) < 0) {
return -1;
}
src_channels = 6;
cvt->len_mult = (cvt->len_mult * 3 + 1) / 2;
cvt->len_ratio *= 1.5;
}
/* [[Mono ->] Stereo ->] 5.1 -> 7.1 */
if ((src_channels == 6) && (dst_channels == 8)) {
if (SDL_AddAudioCVTFilter(cvt, SDL_Convert51To71) < 0) {
return -1;
}
src_channels = 8;
cvt->len_mult = (cvt->len_mult * 4 + 2) / 3;
/* Should be numerically exact with every valid input to this
function */
cvt->len_ratio = cvt->len_ratio * 4 / 3;