zenilib: zenilib/jni/external/sdl/src/audio/SDL_audiotypecvt.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
SDL_audiotypecvt.c
Go to the documentation of this file.
1 /* DO NOT EDIT! This file is generated by sdlgenaudiocvt.pl */
2 /*
3 Simple DirectMedia Layer
4 Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
5
6 This software is provided 'as-is', without any express or implied
7 warranty. In no event will the authors be held liable for any damages
8 arising from the use of this software.
9
10 Permission is granted to anyone to use this software for any purpose,
11 including commercial applications, and to alter it and redistribute it
12 freely, subject to the following restrictions:
13
14 1. The origin of this software must not be misrepresented; you must not
15 claim that you wrote the original software. If you use this software
16 in a product, an acknowledgment in the product documentation would be
17 appreciated but is not required.
18 2. Altered source versions must be plainly marked as such, and must not be
19 misrepresented as being the original software.
20 3. This notice may not be removed or altered from any source distribution.
21 */
22
23 #include "SDL_config.h"
24 #include "SDL_audio.h"
25 #include "SDL_audio_c.h"
26
27 #ifndef DEBUG_CONVERT
28 #define DEBUG_CONVERT 0
29 #endif
30
31
32 /* If you can guarantee your data and need space, you can eliminate code... */
33
34 /* Just build the arbitrary resamplers if you're saving code space. */
35 #ifndef LESS_RESAMPLERS
36 #define LESS_RESAMPLERS 0
37 #endif
38
39 /* Don't build any resamplers if you're REALLY saving code space. */
40 #ifndef NO_RESAMPLERS
41 #define NO_RESAMPLERS 0
42 #endif
43
44 /* Don't build any type converters if you're saving code space. */
45 #ifndef NO_CONVERTERS
46 #define NO_CONVERTERS 0
47 #endif
48
49
50 /* *INDENT-OFF* */
51
52 #define DIVBY127 0.0078740157480315f
53 #define DIVBY32767 3.05185094759972e-05f
54 #define DIVBY2147483647 4.6566128752458e-10f
55
56 #if !NO_CONVERTERS
57
58 static void SDLCALL
59 SDL_Convert_U8_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
60 {
61 int i;
62 const Uint8 *src;
63 Sint8 *dst;
64
65 #if DEBUG_CONVERT
66 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S8.\n");
67 #endif
68
69 src = (const Uint8 *) cvt->buf;
70 dst = (Sint8 *) cvt->buf;
71 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, ++src, ++dst) {
72 const Sint8 val = ((*src) ^ 0x80);
73 *dst = ((Sint8) val);
74 }
75
76 if (cvt->filters[++cvt->filter_index]) {
77 cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
78 }
79 }
80
81 static void SDLCALL
82 SDL_Convert_U8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
83 {
84 int i;
85 const Uint8 *src;
86 Uint16 *dst;
87
88 #if DEBUG_CONVERT
89 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16LSB.\n");
90 #endif
91
92 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
93 dst = ((Uint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
94 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
95 const Uint16 val = (((Uint16) *src) << 8);
96 *dst = SDL_SwapLE16(val);
97 }
98
99 cvt->len_cvt *= 2;
100 if (cvt->filters[++cvt->filter_index]) {
101 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
102 }
103 }
104
105 static void SDLCALL
106 SDL_Convert_U8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
107 {
108 int i;
109 const Uint8 *src;
110 Sint16 *dst;
111
112 #if DEBUG_CONVERT
113 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16LSB.\n");
114 #endif
115
116 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
117 dst = ((Sint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
118 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
119 const Sint16 val = (((Sint16) ((*src) ^ 0x80)) << 8);
120 *dst = ((Sint16) SDL_SwapLE16(val));
121 }
122
123 cvt->len_cvt *= 2;
124 if (cvt->filters[++cvt->filter_index]) {
125 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
126 }
127 }
128
129 static void SDLCALL
130 SDL_Convert_U8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
131 {
132 int i;
133 const Uint8 *src;
134 Uint16 *dst;
135
136 #if DEBUG_CONVERT
137 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16MSB.\n");
138 #endif
139
140 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
141 dst = ((Uint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
142 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
143 const Uint16 val = (((Uint16) *src) << 8);
144 *dst = SDL_SwapBE16(val);
145 }
146
147 cvt->len_cvt *= 2;
148 if (cvt->filters[++cvt->filter_index]) {
149 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
150 }
151 }
152
153 static void SDLCALL
154 SDL_Convert_U8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
155 {
156 int i;
157 const Uint8 *src;
158 Sint16 *dst;
159
160 #if DEBUG_CONVERT
161 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16MSB.\n");
162 #endif
163
164 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
165 dst = ((Sint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
166 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
167 const Sint16 val = (((Sint16) ((*src) ^ 0x80)) << 8);
168 *dst = ((Sint16) SDL_SwapBE16(val));
169 }
170
171 cvt->len_cvt *= 2;
172 if (cvt->filters[++cvt->filter_index]) {
173 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
174 }
175 }
176
177 static void SDLCALL
178 SDL_Convert_U8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
179 {
180 int i;
181 const Uint8 *src;
182 Sint32 *dst;
183
184 #if DEBUG_CONVERT
185 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32LSB.\n");
186 #endif
187
188 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
189 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 4)) - 1;
190 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
191 const Sint32 val = (((Sint32) ((*src) ^ 0x80)) << 24);
192 *dst = ((Sint32) SDL_SwapLE32(val));
193 }
194
195 cvt->len_cvt *= 4;
196 if (cvt->filters[++cvt->filter_index]) {
197 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
198 }
199 }
200
201 static void SDLCALL
202 SDL_Convert_U8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
203 {
204 int i;
205 const Uint8 *src;
206 Sint32 *dst;
207
208 #if DEBUG_CONVERT
209 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32MSB.\n");
210 #endif
211
212 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
213 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 4)) - 1;
214 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
215 const Sint32 val = (((Sint32) ((*src) ^ 0x80)) << 24);
216 *dst = ((Sint32) SDL_SwapBE32(val));
217 }
218
219 cvt->len_cvt *= 4;
220 if (cvt->filters[++cvt->filter_index]) {
221 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
222 }
223 }
224
225 static void SDLCALL
226 SDL_Convert_U8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
227 {
228 int i;
229 const Uint8 *src;
230 float *dst;
231
232 #if DEBUG_CONVERT
233 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32LSB.\n");
234 #endif
235
236 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
237 dst = ((float *) (cvt->buf + cvt->len_cvt * 4)) - 1;
238 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
239 const float val = ((((float) *src) * DIVBY127) - 1.0f);
240 *dst = SDL_SwapFloatLE(val);
241 }
242
243 cvt->len_cvt *= 4;
244 if (cvt->filters[++cvt->filter_index]) {
245 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
246 }
247 }
248
249 static void SDLCALL
250 SDL_Convert_U8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
251 {
252 int i;
253 const Uint8 *src;
254 float *dst;
255
256 #if DEBUG_CONVERT
257 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32MSB.\n");
258 #endif
259
260 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
261 dst = ((float *) (cvt->buf + cvt->len_cvt * 4)) - 1;
262 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
263 const float val = ((((float) *src) * DIVBY127) - 1.0f);
264 *dst = SDL_SwapFloatBE(val);
265 }
266
267 cvt->len_cvt *= 4;
268 if (cvt->filters[++cvt->filter_index]) {
269 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
270 }
271 }
272
273 static void SDLCALL
274 SDL_Convert_S8_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
275 {
276 int i;
277 const Uint8 *src;
278 Uint8 *dst;
279
280 #if DEBUG_CONVERT
281 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U8.\n");
282 #endif
283
284 src = (const Uint8 *) cvt->buf;
285 dst = (Uint8 *) cvt->buf;
286 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, ++src, ++dst) {
287 const Uint8 val = ((((Sint8) *src)) ^ 0x80);
288 *dst = val;
289 }
290
291 if (cvt->filters[++cvt->filter_index]) {
292 cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
293 }
294 }
295
296 static void SDLCALL
297 SDL_Convert_S8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
298 {
299 int i;
300 const Uint8 *src;
301 Uint16 *dst;
302
303 #if DEBUG_CONVERT
304 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16LSB.\n");
305 #endif
306
307 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
308 dst = ((Uint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
309 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
310 const Uint16 val = (((Uint16) ((((Sint8) *src)) ^ 0x80)) << 8);
311 *dst = SDL_SwapLE16(val);
312 }
313
314 cvt->len_cvt *= 2;
315 if (cvt->filters[++cvt->filter_index]) {
316 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
317 }
318 }
319
320 static void SDLCALL
321 SDL_Convert_S8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
322 {
323 int i;
324 const Uint8 *src;
325 Sint16 *dst;
326
327 #if DEBUG_CONVERT
328 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16LSB.\n");
329 #endif
330
331 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
332 dst = ((Sint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
333 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
334 const Sint16 val = (((Sint16) ((Sint8) *src)) << 8);
335 *dst = ((Sint16) SDL_SwapLE16(val));
336 }
337
338 cvt->len_cvt *= 2;
339 if (cvt->filters[++cvt->filter_index]) {
340 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
341 }
342 }
343
344 static void SDLCALL
345 SDL_Convert_S8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
346 {
347 int i;
348 const Uint8 *src;
349 Uint16 *dst;
350
351 #if DEBUG_CONVERT
352 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16MSB.\n");
353 #endif
354
355 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
356 dst = ((Uint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
357 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
358 const Uint16 val = (((Uint16) ((((Sint8) *src)) ^ 0x80)) << 8);
359 *dst = SDL_SwapBE16(val);
360 }
361
362 cvt->len_cvt *= 2;
363 if (cvt->filters[++cvt->filter_index]) {
364 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
365 }
366 }
367
368 static void SDLCALL
369 SDL_Convert_S8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
370 {
371 int i;
372 const Uint8 *src;
373 Sint16 *dst;
374
375 #if DEBUG_CONVERT
376 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16MSB.\n");
377 #endif
378
379 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
380 dst = ((Sint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
381 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
382 const Sint16 val = (((Sint16) ((Sint8) *src)) << 8);
383 *dst = ((Sint16) SDL_SwapBE16(val));
384 }
385
386 cvt->len_cvt *= 2;
387 if (cvt->filters[++cvt->filter_index]) {
388 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
389 }
390 }
391
392 static void SDLCALL
393 SDL_Convert_S8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
394 {
395 int i;
396 const Uint8 *src;
397 Sint32 *dst;
398
399 #if DEBUG_CONVERT
400 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32LSB.\n");
401 #endif
402
403 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
404 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 4)) - 1;
405 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
406 const Sint32 val = (((Sint32) ((Sint8) *src)) << 24);
407 *dst = ((Sint32) SDL_SwapLE32(val));
408 }
409
410 cvt->len_cvt *= 4;
411 if (cvt->filters[++cvt->filter_index]) {
412 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
413 }
414 }
415
416 static void SDLCALL
417 SDL_Convert_S8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
418 {
419 int i;
420 const Uint8 *src;
421 Sint32 *dst;
422
423 #if DEBUG_CONVERT
424 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32MSB.\n");
425 #endif
426
427 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
428 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 4)) - 1;
429 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
430 const Sint32 val = (((Sint32) ((Sint8) *src)) << 24);
431 *dst = ((Sint32) SDL_SwapBE32(val));
432 }
433
434 cvt->len_cvt *= 4;
435 if (cvt->filters[++cvt->filter_index]) {
436 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
437 }
438 }
439
440 static void SDLCALL
441 SDL_Convert_S8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
442 {
443 int i;
444 const Uint8 *src;
445 float *dst;
446
447 #if DEBUG_CONVERT
448 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32LSB.\n");
449 #endif
450
451 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
452 dst = ((float *) (cvt->buf + cvt->len_cvt * 4)) - 1;
453 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
454 const float val = (((float) ((Sint8) *src)) * DIVBY127);
455 *dst = SDL_SwapFloatLE(val);
456 }
457
458 cvt->len_cvt *= 4;
459 if (cvt->filters[++cvt->filter_index]) {
460 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
461 }
462 }
463
464 static void SDLCALL
465 SDL_Convert_S8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
466 {
467 int i;
468 const Uint8 *src;
469 float *dst;
470
471 #if DEBUG_CONVERT
472 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32MSB.\n");
473 #endif
474
475 src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
476 dst = ((float *) (cvt->buf + cvt->len_cvt * 4)) - 1;
477 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
478 const float val = (((float) ((Sint8) *src)) * DIVBY127);
479 *dst = SDL_SwapFloatBE(val);
480 }
481
482 cvt->len_cvt *= 4;
483 if (cvt->filters[++cvt->filter_index]) {
484 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
485 }
486 }
487
488 static void SDLCALL
489 SDL_Convert_U16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
490 {
491 int i;
492 const Uint16 *src;
493 Uint8 *dst;
494
495 #if DEBUG_CONVERT
496 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_U8.\n");
497 #endif
498
499 src = (const Uint16 *) cvt->buf;
500 dst = (Uint8 *) cvt->buf;
501 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
502 const Uint8 val = ((Uint8) (SDL_SwapLE16(*src) >> 8));
503 *dst = val;
504 }
505
506 cvt->len_cvt /= 2;
507 if (cvt->filters[++cvt->filter_index]) {
508 cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
509 }
510 }
511
512 static void SDLCALL
513 SDL_Convert_U16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
514 {
515 int i;
516 const Uint16 *src;
517 Sint8 *dst;
518
519 #if DEBUG_CONVERT
520 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S8.\n");
521 #endif
522
523 src = (const Uint16 *) cvt->buf;
524 dst = (Sint8 *) cvt->buf;
525 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
526 const Sint8 val = ((Sint8) (((SDL_SwapLE16(*src)) ^ 0x8000) >> 8));
527 *dst = ((Sint8) val);
528 }
529
530 cvt->len_cvt /= 2;
531 if (cvt->filters[++cvt->filter_index]) {
532 cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
533 }
534 }
535
536 static void SDLCALL
537 SDL_Convert_U16LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
538 {
539 int i;
540 const Uint16 *src;
541 Sint16 *dst;
542
543 #if DEBUG_CONVERT
544 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S16LSB.\n");
545 #endif
546
547 src = (const Uint16 *) cvt->buf;
548 dst = (Sint16 *) cvt->buf;
549 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
550 const Sint16 val = ((SDL_SwapLE16(*src)) ^ 0x8000);
551 *dst = ((Sint16) SDL_SwapLE16(val));
552 }
553
554 if (cvt->filters[++cvt->filter_index]) {
555 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
556 }
557 }
558
559 static void SDLCALL
560 SDL_Convert_U16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
561 {
562 int i;
563 const Uint16 *src;
564 Uint16 *dst;
565
566 #if DEBUG_CONVERT
567 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_U16MSB.\n");
568 #endif
569
570 src = (const Uint16 *) cvt->buf;
571 dst = (Uint16 *) cvt->buf;
572 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
573 const Uint16 val = SDL_SwapLE16(*src);
574 *dst = SDL_SwapBE16(val);
575 }
576
577 if (cvt->filters[++cvt->filter_index]) {
578 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
579 }
580 }
581
582 static void SDLCALL
583 SDL_Convert_U16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
584 {
585 int i;
586 const Uint16 *src;
587 Sint16 *dst;
588
589 #if DEBUG_CONVERT
590 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S16MSB.\n");
591 #endif
592
593 src = (const Uint16 *) cvt->buf;
594 dst = (Sint16 *) cvt->buf;
595 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
596 const Sint16 val = ((SDL_SwapLE16(*src)) ^ 0x8000);
597 *dst = ((Sint16) SDL_SwapBE16(val));
598 }
599
600 if (cvt->filters[++cvt->filter_index]) {
601 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
602 }
603 }
604
605 static void SDLCALL
606 SDL_Convert_U16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
607 {
608 int i;
609 const Uint16 *src;
610 Sint32 *dst;
611
612 #if DEBUG_CONVERT
613 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32LSB.\n");
614 #endif
615
616 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
617 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
618 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
619 const Sint32 val = (((Sint32) ((SDL_SwapLE16(*src)) ^ 0x8000)) << 16);
620 *dst = ((Sint32) SDL_SwapLE32(val));
621 }
622
623 cvt->len_cvt *= 2;
624 if (cvt->filters[++cvt->filter_index]) {
625 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
626 }
627 }
628
629 static void SDLCALL
630 SDL_Convert_U16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
631 {
632 int i;
633 const Uint16 *src;
634 Sint32 *dst;
635
636 #if DEBUG_CONVERT
637 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32MSB.\n");
638 #endif
639
640 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
641 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
642 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
643 const Sint32 val = (((Sint32) ((SDL_SwapLE16(*src)) ^ 0x8000)) << 16);
644 *dst = ((Sint32) SDL_SwapBE32(val));
645 }
646
647 cvt->len_cvt *= 2;
648 if (cvt->filters[++cvt->filter_index]) {
649 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
650 }
651 }
652
653 static void SDLCALL
654 SDL_Convert_U16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
655 {
656 int i;
657 const Uint16 *src;
658 float *dst;
659
660 #if DEBUG_CONVERT
661 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32LSB.\n");
662 #endif
663
664 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
665 dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
666 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
667 const float val = ((((float) SDL_SwapLE16(*src)) * DIVBY32767) - 1.0f);
668 *dst = SDL_SwapFloatLE(val);
669 }
670
671 cvt->len_cvt *= 2;
672 if (cvt->filters[++cvt->filter_index]) {
673 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
674 }
675 }
676
677 static void SDLCALL
678 SDL_Convert_U16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
679 {
680 int i;
681 const Uint16 *src;
682 float *dst;
683
684 #if DEBUG_CONVERT
685 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32MSB.\n");
686 #endif
687
688 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
689 dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
690 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
691 const float val = ((((float) SDL_SwapLE16(*src)) * DIVBY32767) - 1.0f);
692 *dst = SDL_SwapFloatBE(val);
693 }
694
695 cvt->len_cvt *= 2;
696 if (cvt->filters[++cvt->filter_index]) {
697 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
698 }
699 }
700
701 static void SDLCALL
702 SDL_Convert_S16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
703 {
704 int i;
705 const Uint16 *src;
706 Uint8 *dst;
707
708 #if DEBUG_CONVERT
709 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U8.\n");
710 #endif
711
712 src = (const Uint16 *) cvt->buf;
713 dst = (Uint8 *) cvt->buf;
714 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
715 const Uint8 val = ((Uint8) (((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000) >> 8));
716 *dst = val;
717 }
718
719 cvt->len_cvt /= 2;
720 if (cvt->filters[++cvt->filter_index]) {
721 cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
722 }
723 }
724
725 static void SDLCALL
726 SDL_Convert_S16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
727 {
728 int i;
729 const Uint16 *src;
730 Sint8 *dst;
731
732 #if DEBUG_CONVERT
733 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S8.\n");
734 #endif
735
736 src = (const Uint16 *) cvt->buf;
737 dst = (Sint8 *) cvt->buf;
738 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
739 const Sint8 val = ((Sint8) (((Sint16) SDL_SwapLE16(*src)) >> 8));
740 *dst = ((Sint8) val);
741 }
742
743 cvt->len_cvt /= 2;
744 if (cvt->filters[++cvt->filter_index]) {
745 cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
746 }
747 }
748
749 static void SDLCALL
750 SDL_Convert_S16LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
751 {
752 int i;
753 const Uint16 *src;
754 Uint16 *dst;
755
756 #if DEBUG_CONVERT
757 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U16LSB.\n");
758 #endif
759
760 src = (const Uint16 *) cvt->buf;
761 dst = (Uint16 *) cvt->buf;
762 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
763 const Uint16 val = ((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000);
764 *dst = SDL_SwapLE16(val);
765 }
766
767 if (cvt->filters[++cvt->filter_index]) {
768 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
769 }
770 }
771
772 static void SDLCALL
773 SDL_Convert_S16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
774 {
775 int i;
776 const Uint16 *src;
777 Uint16 *dst;
778
779 #if DEBUG_CONVERT
780 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U16MSB.\n");
781 #endif
782
783 src = (const Uint16 *) cvt->buf;
784 dst = (Uint16 *) cvt->buf;
785 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
786 const Uint16 val = ((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000);
787 *dst = SDL_SwapBE16(val);
788 }
789
790 if (cvt->filters[++cvt->filter_index]) {
791 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
792 }
793 }
794
795 static void SDLCALL
796 SDL_Convert_S16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
797 {
798 int i;
799 const Uint16 *src;
800 Sint16 *dst;
801
802 #if DEBUG_CONVERT
803 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S16MSB.\n");
804 #endif
805
806 src = (const Uint16 *) cvt->buf;
807 dst = (Sint16 *) cvt->buf;
808 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
809 const Sint16 val = ((Sint16) SDL_SwapLE16(*src));
810 *dst = ((Sint16) SDL_SwapBE16(val));
811 }
812
813 if (cvt->filters[++cvt->filter_index]) {
814 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
815 }
816 }
817
818 static void SDLCALL
819 SDL_Convert_S16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
820 {
821 int i;
822 const Uint16 *src;
823 Sint32 *dst;
824
825 #if DEBUG_CONVERT
826 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32LSB.\n");
827 #endif
828
829 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
830 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
831 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
832 const Sint32 val = (((Sint32) ((Sint16) SDL_SwapLE16(*src))) << 16);
833 *dst = ((Sint32) SDL_SwapLE32(val));
834 }
835
836 cvt->len_cvt *= 2;
837 if (cvt->filters[++cvt->filter_index]) {
838 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
839 }
840 }
841
842 static void SDLCALL
843 SDL_Convert_S16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
844 {
845 int i;
846 const Uint16 *src;
847 Sint32 *dst;
848
849 #if DEBUG_CONVERT
850 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32MSB.\n");
851 #endif
852
853 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
854 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
855 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
856 const Sint32 val = (((Sint32) ((Sint16) SDL_SwapLE16(*src))) << 16);
857 *dst = ((Sint32) SDL_SwapBE32(val));
858 }
859
860 cvt->len_cvt *= 2;
861 if (cvt->filters[++cvt->filter_index]) {
862 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
863 }
864 }
865
866 static void SDLCALL
867 SDL_Convert_S16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
868 {
869 int i;
870 const Uint16 *src;
871 float *dst;
872
873 #if DEBUG_CONVERT
874 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32LSB.\n");
875 #endif
876
877 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
878 dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
879 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
880 const float val = (((float) ((Sint16) SDL_SwapLE16(*src))) * DIVBY32767);
881 *dst = SDL_SwapFloatLE(val);
882 }
883
884 cvt->len_cvt *= 2;
885 if (cvt->filters[++cvt->filter_index]) {
886 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
887 }
888 }
889
890 static void SDLCALL
891 SDL_Convert_S16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
892 {
893 int i;
894 const Uint16 *src;
895 float *dst;
896
897 #if DEBUG_CONVERT
898 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32MSB.\n");
899 #endif
900
901 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
902 dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
903 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
904 const float val = (((float) ((Sint16) SDL_SwapLE16(*src))) * DIVBY32767);
905 *dst = SDL_SwapFloatBE(val);
906 }
907
908 cvt->len_cvt *= 2;
909 if (cvt->filters[++cvt->filter_index]) {
910 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
911 }
912 }
913
914 static void SDLCALL
915 SDL_Convert_U16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
916 {
917 int i;
918 const Uint16 *src;
919 Uint8 *dst;
920
921 #if DEBUG_CONVERT
922 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_U8.\n");
923 #endif
924
925 src = (const Uint16 *) cvt->buf;
926 dst = (Uint8 *) cvt->buf;
927 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
928 const Uint8 val = ((Uint8) (SDL_SwapBE16(*src) >> 8));
929 *dst = val;
930 }
931
932 cvt->len_cvt /= 2;
933 if (cvt->filters[++cvt->filter_index]) {
934 cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
935 }
936 }
937
938 static void SDLCALL
939 SDL_Convert_U16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
940 {
941 int i;
942 const Uint16 *src;
943 Sint8 *dst;
944
945 #if DEBUG_CONVERT
946 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S8.\n");
947 #endif
948
949 src = (const Uint16 *) cvt->buf;
950 dst = (Sint8 *) cvt->buf;
951 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
952 const Sint8 val = ((Sint8) (((SDL_SwapBE16(*src)) ^ 0x8000) >> 8));
953 *dst = ((Sint8) val);
954 }
955
956 cvt->len_cvt /= 2;
957 if (cvt->filters[++cvt->filter_index]) {
958 cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
959 }
960 }
961
962 static void SDLCALL
963 SDL_Convert_U16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
964 {
965 int i;
966 const Uint16 *src;
967 Uint16 *dst;
968
969 #if DEBUG_CONVERT
970 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_U16LSB.\n");
971 #endif
972
973 src = (const Uint16 *) cvt->buf;
974 dst = (Uint16 *) cvt->buf;
975 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
976 const Uint16 val = SDL_SwapBE16(*src);
977 *dst = SDL_SwapLE16(val);
978 }
979
980 if (cvt->filters[++cvt->filter_index]) {
981 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
982 }
983 }
984
985 static void SDLCALL
986 SDL_Convert_U16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
987 {
988 int i;
989 const Uint16 *src;
990 Sint16 *dst;
991
992 #if DEBUG_CONVERT
993 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S16LSB.\n");
994 #endif
995
996 src = (const Uint16 *) cvt->buf;
997 dst = (Sint16 *) cvt->buf;
998 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
999 const Sint16 val = ((SDL_SwapBE16(*src)) ^ 0x8000);
1000 *dst = ((Sint16) SDL_SwapLE16(val));
1001 }
1002
1003 if (cvt->filters[++cvt->filter_index]) {
1004 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
1005 }
1006 }
1007
1008 static void SDLCALL
1009 SDL_Convert_U16MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1010 {
1011 int i;
1012 const Uint16 *src;
1013 Sint16 *dst;
1014
1015 #if DEBUG_CONVERT
1016 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S16MSB.\n");
1017 #endif
1018
1019 src = (const Uint16 *) cvt->buf;
1020 dst = (Sint16 *) cvt->buf;
1021 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1022 const Sint16 val = ((SDL_SwapBE16(*src)) ^ 0x8000);
1023 *dst = ((Sint16) SDL_SwapBE16(val));
1024 }
1025
1026 if (cvt->filters[++cvt->filter_index]) {
1027 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
1028 }
1029 }
1030
1031 static void SDLCALL
1032 SDL_Convert_U16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1033 {
1034 int i;
1035 const Uint16 *src;
1036 Sint32 *dst;
1037
1038 #if DEBUG_CONVERT
1039 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32LSB.\n");
1040 #endif
1041
1042 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
1043 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
1044 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1045 const Sint32 val = (((Sint32) ((SDL_SwapBE16(*src)) ^ 0x8000)) << 16);
1046 *dst = ((Sint32) SDL_SwapLE32(val));
1047 }
1048
1049 cvt->len_cvt *= 2;
1050 if (cvt->filters[++cvt->filter_index]) {
1051 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
1052 }
1053 }
1054
1055 static void SDLCALL
1056 SDL_Convert_U16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1057 {
1058 int i;
1059 const Uint16 *src;
1060 Sint32 *dst;
1061
1062 #if DEBUG_CONVERT
1063 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32MSB.\n");
1064 #endif
1065
1066 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
1067 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
1068 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1069 const Sint32 val = (((Sint32) ((SDL_SwapBE16(*src)) ^ 0x8000)) << 16);
1070 *dst = ((Sint32) SDL_SwapBE32(val));
1071 }
1072
1073 cvt->len_cvt *= 2;
1074 if (cvt->filters[++cvt->filter_index]) {
1075 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
1076 }
1077 }
1078
1079 static void SDLCALL
1080 SDL_Convert_U16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1081 {
1082 int i;
1083 const Uint16 *src;
1084 float *dst;
1085
1086 #if DEBUG_CONVERT
1087 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32LSB.\n");
1088 #endif
1089
1090 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
1091 dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
1092 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1093 const float val = ((((float) SDL_SwapBE16(*src)) * DIVBY32767) - 1.0f);
1094 *dst = SDL_SwapFloatLE(val);
1095 }
1096
1097 cvt->len_cvt *= 2;
1098 if (cvt->filters[++cvt->filter_index]) {
1099 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
1100 }
1101 }
1102
1103 static void SDLCALL
1104 SDL_Convert_U16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1105 {
1106 int i;
1107 const Uint16 *src;
1108 float *dst;
1109
1110 #if DEBUG_CONVERT
1111 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32MSB.\n");
1112 #endif
1113
1114 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
1115 dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
1116 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1117 const float val = ((((float) SDL_SwapBE16(*src)) * DIVBY32767) - 1.0f);
1118 *dst = SDL_SwapFloatBE(val);
1119 }
1120
1121 cvt->len_cvt *= 2;
1122 if (cvt->filters[++cvt->filter_index]) {
1123 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
1124 }
1125 }
1126
1127 static void SDLCALL
1128 SDL_Convert_S16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1129 {
1130 int i;
1131 const Uint16 *src;
1132 Uint8 *dst;
1133
1134 #if DEBUG_CONVERT
1135 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U8.\n");
1136 #endif
1137
1138 src = (const Uint16 *) cvt->buf;
1139 dst = (Uint8 *) cvt->buf;
1140 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1141 const Uint8 val = ((Uint8) (((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000) >> 8));
1142 *dst = val;
1143 }
1144
1145 cvt->len_cvt /= 2;
1146 if (cvt->filters[++cvt->filter_index]) {
1147 cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
1148 }
1149 }
1150
1151 static void SDLCALL
1152 SDL_Convert_S16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1153 {
1154 int i;
1155 const Uint16 *src;
1156 Sint8 *dst;
1157
1158 #if DEBUG_CONVERT
1159 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S8.\n");
1160 #endif
1161
1162 src = (const Uint16 *) cvt->buf;
1163 dst = (Sint8 *) cvt->buf;
1164 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1165 const Sint8 val = ((Sint8) (((Sint16) SDL_SwapBE16(*src)) >> 8));
1166 *dst = ((Sint8) val);
1167 }
1168
1169 cvt->len_cvt /= 2;
1170 if (cvt->filters[++cvt->filter_index]) {
1171 cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
1172 }
1173 }
1174
1175 static void SDLCALL
1176 SDL_Convert_S16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1177 {
1178 int i;
1179 const Uint16 *src;
1180 Uint16 *dst;
1181
1182 #if DEBUG_CONVERT
1183 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U16LSB.\n");
1184 #endif
1185
1186 src = (const Uint16 *) cvt->buf;
1187 dst = (Uint16 *) cvt->buf;
1188 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1189 const Uint16 val = ((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000);
1190 *dst = SDL_SwapLE16(val);
1191 }
1192
1193 if (cvt->filters[++cvt->filter_index]) {
1194 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
1195 }
1196 }
1197
1198 static void SDLCALL
1199 SDL_Convert_S16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1200 {
1201 int i;
1202 const Uint16 *src;
1203 Sint16 *dst;
1204
1205 #if DEBUG_CONVERT
1206 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S16LSB.\n");
1207 #endif
1208
1209 src = (const Uint16 *) cvt->buf;
1210 dst = (Sint16 *) cvt->buf;
1211 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1212 const Sint16 val = ((Sint16) SDL_SwapBE16(*src));
1213 *dst = ((Sint16) SDL_SwapLE16(val));
1214 }
1215
1216 if (cvt->filters[++cvt->filter_index]) {
1217 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
1218 }
1219 }
1220
1221 static void SDLCALL
1222 SDL_Convert_S16MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1223 {
1224 int i;
1225 const Uint16 *src;
1226 Uint16 *dst;
1227
1228 #if DEBUG_CONVERT
1229 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U16MSB.\n");
1230 #endif
1231
1232 src = (const Uint16 *) cvt->buf;
1233 dst = (Uint16 *) cvt->buf;
1234 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1235 const Uint16 val = ((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000);
1236 *dst = SDL_SwapBE16(val);
1237 }
1238
1239 if (cvt->filters[++cvt->filter_index]) {
1240 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
1241 }
1242 }
1243
1244 static void SDLCALL
1245 SDL_Convert_S16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1246 {
1247 int i;
1248 const Uint16 *src;
1249 Sint32 *dst;
1250
1251 #if DEBUG_CONVERT
1252 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32LSB.\n");
1253 #endif
1254
1255 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
1256 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
1257 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1258 const Sint32 val = (((Sint32) ((Sint16) SDL_SwapBE16(*src))) << 16);
1259 *dst = ((Sint32) SDL_SwapLE32(val));
1260 }
1261
1262 cvt->len_cvt *= 2;
1263 if (cvt->filters[++cvt->filter_index]) {
1264 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
1265 }
1266 }
1267
1268 static void SDLCALL
1269 SDL_Convert_S16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1270 {
1271 int i;
1272 const Uint16 *src;
1273 Sint32 *dst;
1274
1275 #if DEBUG_CONVERT
1276 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32MSB.\n");
1277 #endif
1278
1279 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
1280 dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
1281 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1282 const Sint32 val = (((Sint32) ((Sint16) SDL_SwapBE16(*src))) << 16);
1283 *dst = ((Sint32) SDL_SwapBE32(val));
1284 }
1285
1286 cvt->len_cvt *= 2;
1287 if (cvt->filters[++cvt->filter_index]) {
1288 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
1289 }
1290 }
1291
1292 static void SDLCALL
1293 SDL_Convert_S16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1294 {
1295 int i;
1296 const Uint16 *src;
1297 float *dst;
1298
1299 #if DEBUG_CONVERT
1300 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32LSB.\n");
1301 #endif
1302
1303 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
1304 dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
1305 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1306 const float val = (((float) ((Sint16) SDL_SwapBE16(*src))) * DIVBY32767);
1307 *dst = SDL_SwapFloatLE(val);
1308 }
1309
1310 cvt->len_cvt *= 2;
1311 if (cvt->filters[++cvt->filter_index]) {
1312 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
1313 }
1314 }
1315
1316 static void SDLCALL
1317 SDL_Convert_S16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1318 {
1319 int i;
1320 const Uint16 *src;
1321 float *dst;
1322
1323 #if DEBUG_CONVERT
1324 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32MSB.\n");
1325 #endif
1326
1327 src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
1328 dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
1329 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1330 const float val = (((float) ((Sint16) SDL_SwapBE16(*src))) * DIVBY32767);
1331 *dst = SDL_SwapFloatBE(val);
1332 }
1333
1334 cvt->len_cvt *= 2;
1335 if (cvt->filters[++cvt->filter_index]) {
1336 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
1337 }
1338 }
1339
1340 static void SDLCALL
1341 SDL_Convert_S32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1342 {
1343 int i;
1344 const Uint32 *src;
1345 Uint8 *dst;
1346
1347 #if DEBUG_CONVERT
1348 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U8.\n");
1349 #endif
1350
1351 src = (const Uint32 *) cvt->buf;
1352 dst = (Uint8 *) cvt->buf;
1353 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1354 const Uint8 val = ((Uint8) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 24));
1355 *dst = val;
1356 }
1357
1358 cvt->len_cvt /= 4;
1359 if (cvt->filters[++cvt->filter_index]) {
1360 cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
1361 }
1362 }
1363
1364 static void SDLCALL
1365 SDL_Convert_S32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1366 {
1367 int i;
1368 const Uint32 *src;
1369 Sint8 *dst;
1370
1371 #if DEBUG_CONVERT
1372 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S8.\n");
1373 #endif
1374
1375 src = (const Uint32 *) cvt->buf;
1376 dst = (Sint8 *) cvt->buf;
1377 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1378 const Sint8 val = ((Sint8) (((Sint32) SDL_SwapLE32(*src)) >> 24));
1379 *dst = ((Sint8) val);
1380 }
1381
1382 cvt->len_cvt /= 4;
1383 if (cvt->filters[++cvt->filter_index]) {
1384 cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
1385 }
1386 }
1387
1388 static void SDLCALL
1389 SDL_Convert_S32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1390 {
1391 int i;
1392 const Uint32 *src;
1393 Uint16 *dst;
1394
1395 #if DEBUG_CONVERT
1396 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U16LSB.\n");
1397 #endif
1398
1399 src = (const Uint32 *) cvt->buf;
1400 dst = (Uint16 *) cvt->buf;
1401 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1402 const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 16));
1403 *dst = SDL_SwapLE16(val);
1404 }
1405
1406 cvt->len_cvt /= 2;
1407 if (cvt->filters[++cvt->filter_index]) {
1408 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
1409 }
1410 }
1411
1412 static void SDLCALL
1413 SDL_Convert_S32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1414 {
1415 int i;
1416 const Uint32 *src;
1417 Sint16 *dst;
1418
1419 #if DEBUG_CONVERT
1420 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S16LSB.\n");
1421 #endif
1422
1423 src = (const Uint32 *) cvt->buf;
1424 dst = (Sint16 *) cvt->buf;
1425 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1426 const Sint16 val = ((Sint16) (((Sint32) SDL_SwapLE32(*src)) >> 16));
1427 *dst = ((Sint16) SDL_SwapLE16(val));
1428 }
1429
1430 cvt->len_cvt /= 2;
1431 if (cvt->filters[++cvt->filter_index]) {
1432 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
1433 }
1434 }
1435
1436 static void SDLCALL
1437 SDL_Convert_S32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1438 {
1439 int i;
1440 const Uint32 *src;
1441 Uint16 *dst;
1442
1443 #if DEBUG_CONVERT
1444 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U16MSB.\n");
1445 #endif
1446
1447 src = (const Uint32 *) cvt->buf;
1448 dst = (Uint16 *) cvt->buf;
1449 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1450 const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 16));
1451 *dst = SDL_SwapBE16(val);
1452 }
1453
1454 cvt->len_cvt /= 2;
1455 if (cvt->filters[++cvt->filter_index]) {
1456 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
1457 }
1458 }
1459
1460 static void SDLCALL
1461 SDL_Convert_S32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1462 {
1463 int i;
1464 const Uint32 *src;
1465 Sint16 *dst;
1466
1467 #if DEBUG_CONVERT
1468 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S16MSB.\n");
1469 #endif
1470
1471 src = (const Uint32 *) cvt->buf;
1472 dst = (Sint16 *) cvt->buf;
1473 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1474 const Sint16 val = ((Sint16) (((Sint32) SDL_SwapLE32(*src)) >> 16));
1475 *dst = ((Sint16) SDL_SwapBE16(val));
1476 }
1477
1478 cvt->len_cvt /= 2;
1479 if (cvt->filters[++cvt->filter_index]) {
1480 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
1481 }
1482 }
1483
1484 static void SDLCALL
1485 SDL_Convert_S32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1486 {
1487 int i;
1488 const Uint32 *src;
1489 Sint32 *dst;
1490
1491 #if DEBUG_CONVERT
1492 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S32MSB.\n");
1493 #endif
1494
1495 src = (const Uint32 *) cvt->buf;
1496 dst = (Sint32 *) cvt->buf;
1497 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1498 const Sint32 val = ((Sint32) SDL_SwapLE32(*src));
1499 *dst = ((Sint32) SDL_SwapBE32(val));
1500 }
1501
1502 if (cvt->filters[++cvt->filter_index]) {
1503 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
1504 }
1505 }
1506
1507 static void SDLCALL
1508 SDL_Convert_S32LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1509 {
1510 int i;
1511 const Uint32 *src;
1512 float *dst;
1513
1514 #if DEBUG_CONVERT
1515 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_F32LSB.\n");
1516 #endif
1517
1518 src = (const Uint32 *) cvt->buf;
1519 dst = (float *) cvt->buf;
1520 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1521 const float val = (((float) ((Sint32) SDL_SwapLE32(*src))) * DIVBY2147483647);
1522 *dst = SDL_SwapFloatLE(val);
1523 }
1524
1525 if (cvt->filters[++cvt->filter_index]) {
1526 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
1527 }
1528 }
1529
1530 static void SDLCALL
1531 SDL_Convert_S32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1532 {
1533 int i;
1534 const Uint32 *src;
1535 float *dst;
1536
1537 #if DEBUG_CONVERT
1538 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_F32MSB.\n");
1539 #endif
1540
1541 src = (const Uint32 *) cvt->buf;
1542 dst = (float *) cvt->buf;
1543 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1544 const float val = (((float) ((Sint32) SDL_SwapLE32(*src))) * DIVBY2147483647);
1545 *dst = SDL_SwapFloatBE(val);
1546 }
1547
1548 if (cvt->filters[++cvt->filter_index]) {
1549 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
1550 }
1551 }
1552
1553 static void SDLCALL
1554 SDL_Convert_S32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1555 {
1556 int i;
1557 const Uint32 *src;
1558 Uint8 *dst;
1559
1560 #if DEBUG_CONVERT
1561 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U8.\n");
1562 #endif
1563
1564 src = (const Uint32 *) cvt->buf;
1565 dst = (Uint8 *) cvt->buf;
1566 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1567 const Uint8 val = ((Uint8) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 24));
1568 *dst = val;
1569 }
1570
1571 cvt->len_cvt /= 4;
1572 if (cvt->filters[++cvt->filter_index]) {
1573 cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
1574 }
1575 }
1576
1577 static void SDLCALL
1578 SDL_Convert_S32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1579 {
1580 int i;
1581 const Uint32 *src;
1582 Sint8 *dst;
1583
1584 #if DEBUG_CONVERT
1585 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S8.\n");
1586 #endif
1587
1588 src = (const Uint32 *) cvt->buf;
1589 dst = (Sint8 *) cvt->buf;
1590 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1591 const Sint8 val = ((Sint8) (((Sint32) SDL_SwapBE32(*src)) >> 24));
1592 *dst = ((Sint8) val);
1593 }
1594
1595 cvt->len_cvt /= 4;
1596 if (cvt->filters[++cvt->filter_index]) {
1597 cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
1598 }
1599 }
1600
1601 static void SDLCALL
1602 SDL_Convert_S32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1603 {
1604 int i;
1605 const Uint32 *src;
1606 Uint16 *dst;
1607
1608 #if DEBUG_CONVERT
1609 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U16LSB.\n");
1610 #endif
1611
1612 src = (const Uint32 *) cvt->buf;
1613 dst = (Uint16 *) cvt->buf;
1614 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1615 const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 16));
1616 *dst = SDL_SwapLE16(val);
1617 }
1618
1619 cvt->len_cvt /= 2;
1620 if (cvt->filters[++cvt->filter_index]) {
1621 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
1622 }
1623 }
1624
1625 static void SDLCALL
1626 SDL_Convert_S32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1627 {
1628 int i;
1629 const Uint32 *src;
1630 Sint16 *dst;
1631
1632 #if DEBUG_CONVERT
1633 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S16LSB.\n");
1634 #endif
1635
1636 src = (const Uint32 *) cvt->buf;
1637 dst = (Sint16 *) cvt->buf;
1638 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1639 const Sint16 val = ((Sint16) (((Sint32) SDL_SwapBE32(*src)) >> 16));
1640 *dst = ((Sint16) SDL_SwapLE16(val));
1641 }
1642
1643 cvt->len_cvt /= 2;
1644 if (cvt->filters[++cvt->filter_index]) {
1645 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
1646 }
1647 }
1648
1649 static void SDLCALL
1650 SDL_Convert_S32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1651 {
1652 int i;
1653 const Uint32 *src;
1654 Uint16 *dst;
1655
1656 #if DEBUG_CONVERT
1657 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U16MSB.\n");
1658 #endif
1659
1660 src = (const Uint32 *) cvt->buf;
1661 dst = (Uint16 *) cvt->buf;
1662 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1663 const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 16));
1664 *dst = SDL_SwapBE16(val);
1665 }
1666
1667 cvt->len_cvt /= 2;
1668 if (cvt->filters[++cvt->filter_index]) {
1669 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
1670 }
1671 }
1672
1673 static void SDLCALL
1674 SDL_Convert_S32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1675 {
1676 int i;
1677 const Uint32 *src;
1678 Sint16 *dst;
1679
1680 #if DEBUG_CONVERT
1681 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S16MSB.\n");
1682 #endif
1683
1684 src = (const Uint32 *) cvt->buf;
1685 dst = (Sint16 *) cvt->buf;
1686 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1687 const Sint16 val = ((Sint16) (((Sint32) SDL_SwapBE32(*src)) >> 16));
1688 *dst = ((Sint16) SDL_SwapBE16(val));
1689 }
1690
1691 cvt->len_cvt /= 2;
1692 if (cvt->filters[++cvt->filter_index]) {
1693 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
1694 }
1695 }
1696
1697 static void SDLCALL
1698 SDL_Convert_S32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1699 {
1700 int i;
1701 const Uint32 *src;
1702 Sint32 *dst;
1703
1704 #if DEBUG_CONVERT
1705 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S32LSB.\n");
1706 #endif
1707
1708 src = (const Uint32 *) cvt->buf;
1709 dst = (Sint32 *) cvt->buf;
1710 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1711 const Sint32 val = ((Sint32) SDL_SwapBE32(*src));
1712 *dst = ((Sint32) SDL_SwapLE32(val));
1713 }
1714
1715 if (cvt->filters[++cvt->filter_index]) {
1716 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
1717 }
1718 }
1719
1720 static void SDLCALL
1721 SDL_Convert_S32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1722 {
1723 int i;
1724 const Uint32 *src;
1725 float *dst;
1726
1727 #if DEBUG_CONVERT
1728 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_F32LSB.\n");
1729 #endif
1730
1731 src = (const Uint32 *) cvt->buf;
1732 dst = (float *) cvt->buf;
1733 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1734 const float val = (((float) ((Sint32) SDL_SwapBE32(*src))) * DIVBY2147483647);
1735 *dst = SDL_SwapFloatLE(val);
1736 }
1737
1738 if (cvt->filters[++cvt->filter_index]) {
1739 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
1740 }
1741 }
1742
1743 static void SDLCALL
1744 SDL_Convert_S32MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1745 {
1746 int i;
1747 const Uint32 *src;
1748 float *dst;
1749
1750 #if DEBUG_CONVERT
1751 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_F32MSB.\n");
1752 #endif
1753
1754 src = (const Uint32 *) cvt->buf;
1755 dst = (float *) cvt->buf;
1756 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1757 const float val = (((float) ((Sint32) SDL_SwapBE32(*src))) * DIVBY2147483647);
1758 *dst = SDL_SwapFloatBE(val);
1759 }
1760
1761 if (cvt->filters[++cvt->filter_index]) {
1762 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
1763 }
1764 }
1765
1766 static void SDLCALL
1767 SDL_Convert_F32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1768 {
1769 int i;
1770 const float *src;
1771 Uint8 *dst;
1772
1773 #if DEBUG_CONVERT
1774 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U8.\n");
1775 #endif
1776
1777 src = (const float *) cvt->buf;
1778 dst = (Uint8 *) cvt->buf;
1779 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1780 const Uint8 val = ((Uint8) ((SDL_SwapFloatLE(*src) + 1.0f) * 127.0f));
1781 *dst = val;
1782 }
1783
1784 cvt->len_cvt /= 4;
1785 if (cvt->filters[++cvt->filter_index]) {
1786 cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
1787 }
1788 }
1789
1790 static void SDLCALL
1791 SDL_Convert_F32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1792 {
1793 int i;
1794 const float *src;
1795 Sint8 *dst;
1796
1797 #if DEBUG_CONVERT
1798 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S8.\n");
1799 #endif
1800
1801 src = (const float *) cvt->buf;
1802 dst = (Sint8 *) cvt->buf;
1803 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1804 const Sint8 val = ((Sint8) (SDL_SwapFloatLE(*src) * 127.0f));
1805 *dst = ((Sint8) val);
1806 }
1807
1808 cvt->len_cvt /= 4;
1809 if (cvt->filters[++cvt->filter_index]) {
1810 cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
1811 }
1812 }
1813
1814 static void SDLCALL
1815 SDL_Convert_F32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1816 {
1817 int i;
1818 const float *src;
1819 Uint16 *dst;
1820
1821 #if DEBUG_CONVERT
1822 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U16LSB.\n");
1823 #endif
1824
1825 src = (const float *) cvt->buf;
1826 dst = (Uint16 *) cvt->buf;
1827 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1828 const Uint16 val = ((Uint16) ((SDL_SwapFloatLE(*src) + 1.0f) * 32767.0f));
1829 *dst = SDL_SwapLE16(val);
1830 }
1831
1832 cvt->len_cvt /= 2;
1833 if (cvt->filters[++cvt->filter_index]) {
1834 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
1835 }
1836 }
1837
1838 static void SDLCALL
1839 SDL_Convert_F32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1840 {
1841 int i;
1842 const float *src;
1843 Sint16 *dst;
1844
1845 #if DEBUG_CONVERT
1846 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S16LSB.\n");
1847 #endif
1848
1849 src = (const float *) cvt->buf;
1850 dst = (Sint16 *) cvt->buf;
1851 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1852 const Sint16 val = ((Sint16) (SDL_SwapFloatLE(*src) * 32767.0f));
1853 *dst = ((Sint16) SDL_SwapLE16(val));
1854 }
1855
1856 cvt->len_cvt /= 2;
1857 if (cvt->filters[++cvt->filter_index]) {
1858 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
1859 }
1860 }
1861
1862 static void SDLCALL
1863 SDL_Convert_F32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1864 {
1865 int i;
1866 const float *src;
1867 Uint16 *dst;
1868
1869 #if DEBUG_CONVERT
1870 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U16MSB.\n");
1871 #endif
1872
1873 src = (const float *) cvt->buf;
1874 dst = (Uint16 *) cvt->buf;
1875 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1876 const Uint16 val = ((Uint16) ((SDL_SwapFloatLE(*src) + 1.0f) * 32767.0f));
1877 *dst = SDL_SwapBE16(val);
1878 }
1879
1880 cvt->len_cvt /= 2;
1881 if (cvt->filters[++cvt->filter_index]) {
1882 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
1883 }
1884 }
1885
1886 static void SDLCALL
1887 SDL_Convert_F32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1888 {
1889 int i;
1890 const float *src;
1891 Sint16 *dst;
1892
1893 #if DEBUG_CONVERT
1894 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S16MSB.\n");
1895 #endif
1896
1897 src = (const float *) cvt->buf;
1898 dst = (Sint16 *) cvt->buf;
1899 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1900 const Sint16 val = ((Sint16) (SDL_SwapFloatLE(*src) * 32767.0f));
1901 *dst = ((Sint16) SDL_SwapBE16(val));
1902 }
1903
1904 cvt->len_cvt /= 2;
1905 if (cvt->filters[++cvt->filter_index]) {
1906 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
1907 }
1908 }
1909
1910 static void SDLCALL
1911 SDL_Convert_F32LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1912 {
1913 int i;
1914 const float *src;
1915 Sint32 *dst;
1916
1917 #if DEBUG_CONVERT
1918 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S32LSB.\n");
1919 #endif
1920
1921 src = (const float *) cvt->buf;
1922 dst = (Sint32 *) cvt->buf;
1923 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1924 const Sint32 val = ((Sint32) (SDL_SwapFloatLE(*src) * 2147483647.0));
1925 *dst = ((Sint32) SDL_SwapLE32(val));
1926 }
1927
1928 if (cvt->filters[++cvt->filter_index]) {
1929 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
1930 }
1931 }
1932
1933 static void SDLCALL
1934 SDL_Convert_F32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1935 {
1936 int i;
1937 const float *src;
1938 Sint32 *dst;
1939
1940 #if DEBUG_CONVERT
1941 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S32MSB.\n");
1942 #endif
1943
1944 src = (const float *) cvt->buf;
1945 dst = (Sint32 *) cvt->buf;
1946 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1947 const Sint32 val = ((Sint32) (SDL_SwapFloatLE(*src) * 2147483647.0));
1948 *dst = ((Sint32) SDL_SwapBE32(val));
1949 }
1950
1951 if (cvt->filters[++cvt->filter_index]) {
1952 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
1953 }
1954 }
1955
1956 static void SDLCALL
1957 SDL_Convert_F32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1958 {
1959 int i;
1960 const float *src;
1961 float *dst;
1962
1963 #if DEBUG_CONVERT
1964 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_F32MSB.\n");
1965 #endif
1966
1967 src = (const float *) cvt->buf;
1968 dst = (float *) cvt->buf;
1969 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1970 const float val = SDL_SwapFloatLE(*src);
1971 *dst = SDL_SwapFloatBE(val);
1972 }
1973
1974 if (cvt->filters[++cvt->filter_index]) {
1975 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
1976 }
1977 }
1978
1979 static void SDLCALL
1980 SDL_Convert_F32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1981 {
1982 int i;
1983 const float *src;
1984 Uint8 *dst;
1985
1986 #if DEBUG_CONVERT
1987 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U8.\n");
1988 #endif
1989
1990 src = (const float *) cvt->buf;
1991 dst = (Uint8 *) cvt->buf;
1992 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1993 const Uint8 val = ((Uint8) ((SDL_SwapFloatBE(*src) + 1.0f) * 127.0f));
1994 *dst = val;
1995 }
1996
1997 cvt->len_cvt /= 4;
1998 if (cvt->filters[++cvt->filter_index]) {
1999 cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
2000 }
2001 }
2002
2003 static void SDLCALL
2004 SDL_Convert_F32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2005 {
2006 int i;
2007 const float *src;
2008 Sint8 *dst;
2009
2010 #if DEBUG_CONVERT
2011 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S8.\n");
2012 #endif
2013
2014 src = (const float *) cvt->buf;
2015 dst = (Sint8 *) cvt->buf;
2016 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2017 const Sint8 val = ((Sint8) (SDL_SwapFloatBE(*src) * 127.0f));
2018 *dst = ((Sint8) val);
2019 }
2020
2021 cvt->len_cvt /= 4;
2022 if (cvt->filters[++cvt->filter_index]) {
2023 cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
2024 }
2025 }
2026
2027 static void SDLCALL
2028 SDL_Convert_F32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2029 {
2030 int i;
2031 const float *src;
2032 Uint16 *dst;
2033
2034 #if DEBUG_CONVERT
2035 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U16LSB.\n");
2036 #endif
2037
2038 src = (const float *) cvt->buf;
2039 dst = (Uint16 *) cvt->buf;
2040 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2041 const Uint16 val = ((Uint16) ((SDL_SwapFloatBE(*src) + 1.0f) * 32767.0f));
2042 *dst = SDL_SwapLE16(val);
2043 }
2044
2045 cvt->len_cvt /= 2;
2046 if (cvt->filters[++cvt->filter_index]) {
2047 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
2048 }
2049 }
2050
2051 static void SDLCALL
2052 SDL_Convert_F32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2053 {
2054 int i;
2055 const float *src;
2056 Sint16 *dst;
2057
2058 #if DEBUG_CONVERT
2059 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S16LSB.\n");
2060 #endif
2061
2062 src = (const float *) cvt->buf;
2063 dst = (Sint16 *) cvt->buf;
2064 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2065 const Sint16 val = ((Sint16) (SDL_SwapFloatBE(*src) * 32767.0f));
2066 *dst = ((Sint16) SDL_SwapLE16(val));
2067 }
2068
2069 cvt->len_cvt /= 2;
2070 if (cvt->filters[++cvt->filter_index]) {
2071 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
2072 }
2073 }
2074
2075 static void SDLCALL
2076 SDL_Convert_F32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2077 {
2078 int i;
2079 const float *src;
2080 Uint16 *dst;
2081
2082 #if DEBUG_CONVERT
2083 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U16MSB.\n");
2084 #endif
2085
2086 src = (const float *) cvt->buf;
2087 dst = (Uint16 *) cvt->buf;
2088 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2089 const Uint16 val = ((Uint16) ((SDL_SwapFloatBE(*src) + 1.0f) * 32767.0f));
2090 *dst = SDL_SwapBE16(val);
2091 }
2092
2093 cvt->len_cvt /= 2;
2094 if (cvt->filters[++cvt->filter_index]) {
2095 cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
2096 }
2097 }
2098
2099 static void SDLCALL
2100 SDL_Convert_F32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2101 {
2102 int i;
2103 const float *src;
2104 Sint16 *dst;
2105
2106 #if DEBUG_CONVERT
2107 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S16MSB.\n");
2108 #endif
2109
2110 src = (const float *) cvt->buf;
2111 dst = (Sint16 *) cvt->buf;
2112 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2113 const Sint16 val = ((Sint16) (SDL_SwapFloatBE(*src) * 32767.0f));
2114 *dst = ((Sint16) SDL_SwapBE16(val));
2115 }
2116
2117 cvt->len_cvt /= 2;
2118 if (cvt->filters[++cvt->filter_index]) {
2119 cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
2120 }
2121 }
2122
2123 static void SDLCALL
2124 SDL_Convert_F32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2125 {
2126 int i;
2127 const float *src;
2128 Sint32 *dst;
2129
2130 #if DEBUG_CONVERT
2131 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S32LSB.\n");
2132 #endif
2133
2134 src = (const float *) cvt->buf;
2135 dst = (Sint32 *) cvt->buf;
2136 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2137 const Sint32 val = ((Sint32) (SDL_SwapFloatBE(*src) * 2147483647.0));
2138 *dst = ((Sint32) SDL_SwapLE32(val));
2139 }
2140
2141 if (cvt->filters[++cvt->filter_index]) {
2142 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
2143 }
2144 }
2145
2146 static void SDLCALL
2147 SDL_Convert_F32MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2148 {
2149 int i;
2150 const float *src;
2151 Sint32 *dst;
2152
2153 #if DEBUG_CONVERT
2154 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S32MSB.\n");
2155 #endif
2156
2157 src = (const float *) cvt->buf;
2158 dst = (Sint32 *) cvt->buf;
2159 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2160 const Sint32 val = ((Sint32) (SDL_SwapFloatBE(*src) * 2147483647.0));
2161 *dst = ((Sint32) SDL_SwapBE32(val));
2162 }
2163
2164 if (cvt->filters[++cvt->filter_index]) {
2165 cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
2166 }
2167 }
2168
2169 static void SDLCALL
2170 SDL_Convert_F32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2171 {
2172 int i;
2173 const float *src;
2174 float *dst;
2175
2176 #if DEBUG_CONVERT
2177 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_F32LSB.\n");
2178 #endif
2179
2180 src = (const float *) cvt->buf;
2181 dst = (float *) cvt->buf;
2182 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2183 const float val = SDL_SwapFloatBE(*src);
2184 *dst = SDL_SwapFloatLE(val);
2185 }
2186
2187 if (cvt->filters[++cvt->filter_index]) {
2188 cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
2189 }
2190 }
2191
2192 #endif /* !NO_CONVERTERS */
2193
2194
2195 const SDL_AudioTypeFilters sdl_audio_type_filters[] =
2196 {
2197 #if !NO_CONVERTERS
2198 { AUDIO_U8, AUDIO_S8, SDL_Convert_U8_to_S8 },
2199 { AUDIO_U8, AUDIO_U16LSB, SDL_Convert_U8_to_U16LSB },
2200 { AUDIO_U8, AUDIO_S16LSB, SDL_Convert_U8_to_S16LSB },
2201 { AUDIO_U8, AUDIO_U16MSB, SDL_Convert_U8_to_U16MSB },
2202 { AUDIO_U8, AUDIO_S16MSB, SDL_Convert_U8_to_S16MSB },
2203 { AUDIO_U8, AUDIO_S32LSB, SDL_Convert_U8_to_S32LSB },
2204 { AUDIO_U8, AUDIO_S32MSB, SDL_Convert_U8_to_S32MSB },
2205 { AUDIO_U8, AUDIO_F32LSB, SDL_Convert_U8_to_F32LSB },
2206 { AUDIO_U8, AUDIO_F32MSB, SDL_Convert_U8_to_F32MSB },
2207 { AUDIO_S8, AUDIO_U8, SDL_Convert_S8_to_U8 },
2208 { AUDIO_S8, AUDIO_U16LSB, SDL_Convert_S8_to_U16LSB },
2209 { AUDIO_S8, AUDIO_S16LSB, SDL_Convert_S8_to_S16LSB },
2210 { AUDIO_S8, AUDIO_U16MSB, SDL_Convert_S8_to_U16MSB },
2211 { AUDIO_S8, AUDIO_S16MSB, SDL_Convert_S8_to_S16MSB },
2212 { AUDIO_S8, AUDIO_S32LSB, SDL_Convert_S8_to_S32LSB },
2213 { AUDIO_S8, AUDIO_S32MSB, SDL_Convert_S8_to_S32MSB },
2214 { AUDIO_S8, AUDIO_F32LSB, SDL_Convert_S8_to_F32LSB },
2215 { AUDIO_S8, AUDIO_F32MSB, SDL_Convert_S8_to_F32MSB },
2216 { AUDIO_U16LSB, AUDIO_U8, SDL_Convert_U16LSB_to_U8 },
2217 { AUDIO_U16LSB, AUDIO_S8, SDL_Convert_U16LSB_to_S8 },
2218 { AUDIO_U16LSB, AUDIO_S16LSB, SDL_Convert_U16LSB_to_S16LSB },
2219 { AUDIO_U16LSB, AUDIO_U16MSB, SDL_Convert_U16LSB_to_U16MSB },
2220 { AUDIO_U16LSB, AUDIO_S16MSB, SDL_Convert_U16LSB_to_S16MSB },
2221 { AUDIO_U16LSB, AUDIO_S32LSB, SDL_Convert_U16LSB_to_S32LSB },
2222 { AUDIO_U16LSB, AUDIO_S32MSB, SDL_Convert_U16LSB_to_S32MSB },
2223 { AUDIO_U16LSB, AUDIO_F32LSB, SDL_Convert_U16LSB_to_F32LSB },
2224 { AUDIO_U16LSB, AUDIO_F32MSB, SDL_Convert_U16LSB_to_F32MSB },
2225 { AUDIO_S16LSB, AUDIO_U8, SDL_Convert_S16LSB_to_U8 },
2226 { AUDIO_S16LSB, AUDIO_S8, SDL_Convert_S16LSB_to_S8 },
2227 { AUDIO_S16LSB, AUDIO_U16LSB, SDL_Convert_S16LSB_to_U16LSB },
2228 { AUDIO_S16LSB, AUDIO_U16MSB, SDL_Convert_S16LSB_to_U16MSB },
2229 { AUDIO_S16LSB, AUDIO_S16MSB, SDL_Convert_S16LSB_to_S16MSB },
2230 { AUDIO_S16LSB, AUDIO_S32LSB, SDL_Convert_S16LSB_to_S32LSB },
2231 { AUDIO_S16LSB, AUDIO_S32MSB, SDL_Convert_S16LSB_to_S32MSB },
2232 { AUDIO_S16LSB, AUDIO_F32LSB, SDL_Convert_S16LSB_to_F32LSB },
2233 { AUDIO_S16LSB, AUDIO_F32MSB, SDL_Convert_S16LSB_to_F32MSB },
2234 { AUDIO_U16MSB, AUDIO_U8, SDL_Convert_U16MSB_to_U8 },
2235 { AUDIO_U16MSB, AUDIO_S8, SDL_Convert_U16MSB_to_S8 },
2236 { AUDIO_U16MSB, AUDIO_U16LSB, SDL_Convert_U16MSB_to_U16LSB },
2237 { AUDIO_U16MSB, AUDIO_S16LSB, SDL_Convert_U16MSB_to_S16LSB },
2238 { AUDIO_U16MSB, AUDIO_S16MSB, SDL_Convert_U16MSB_to_S16MSB },
2239 { AUDIO_U16MSB, AUDIO_S32LSB, SDL_Convert_U16MSB_to_S32LSB },
2240 { AUDIO_U16MSB, AUDIO_S32MSB, SDL_Convert_U16MSB_to_S32MSB },
2241 { AUDIO_U16MSB, AUDIO_F32LSB, SDL_Convert_U16MSB_to_F32LSB },
2242 { AUDIO_U16MSB, AUDIO_F32MSB, SDL_Convert_U16MSB_to_F32MSB },
2243 { AUDIO_S16MSB, AUDIO_U8, SDL_Convert_S16MSB_to_U8 },
2244 { AUDIO_S16MSB, AUDIO_S8, SDL_Convert_S16MSB_to_S8 },
2245 { AUDIO_S16MSB, AUDIO_U16LSB, SDL_Convert_S16MSB_to_U16LSB },
2246 { AUDIO_S16MSB, AUDIO_S16LSB, SDL_Convert_S16MSB_to_S16LSB },
2247 { AUDIO_S16MSB, AUDIO_U16MSB, SDL_Convert_S16MSB_to_U16MSB },
2248 { AUDIO_S16MSB, AUDIO_S32LSB, SDL_Convert_S16MSB_to_S32LSB },
2249 { AUDIO_S16MSB, AUDIO_S32MSB, SDL_Convert_S16MSB_to_S32MSB },
2250 { AUDIO_S16MSB, AUDIO_F32LSB, SDL_Convert_S16MSB_to_F32LSB },
2251 { AUDIO_S16MSB, AUDIO_F32MSB, SDL_Convert_S16MSB_to_F32MSB },
2252 { AUDIO_S32LSB, AUDIO_U8, SDL_Convert_S32LSB_to_U8 },
2253 { AUDIO_S32LSB, AUDIO_S8, SDL_Convert_S32LSB_to_S8 },
2254 { AUDIO_S32LSB, AUDIO_U16LSB, SDL_Convert_S32LSB_to_U16LSB },
2255 { AUDIO_S32LSB, AUDIO_S16LSB, SDL_Convert_S32LSB_to_S16LSB },
2256 { AUDIO_S32LSB, AUDIO_U16MSB, SDL_Convert_S32LSB_to_U16MSB },
2257 { AUDIO_S32LSB, AUDIO_S16MSB, SDL_Convert_S32LSB_to_S16MSB },
2258 { AUDIO_S32LSB, AUDIO_S32MSB, SDL_Convert_S32LSB_to_S32MSB },
2259 { AUDIO_S32LSB, AUDIO_F32LSB, SDL_Convert_S32LSB_to_F32LSB },
2260 { AUDIO_S32LSB, AUDIO_F32MSB, SDL_Convert_S32LSB_to_F32MSB },
2261 { AUDIO_S32MSB, AUDIO_U8, SDL_Convert_S32MSB_to_U8 },
2262 { AUDIO_S32MSB, AUDIO_S8, SDL_Convert_S32MSB_to_S8 },
2263 { AUDIO_S32MSB, AUDIO_U16LSB, SDL_Convert_S32MSB_to_U16LSB },
2264 { AUDIO_S32MSB, AUDIO_S16LSB, SDL_Convert_S32MSB_to_S16LSB },
2265 { AUDIO_S32MSB, AUDIO_U16MSB, SDL_Convert_S32MSB_to_U16MSB },
2266 { AUDIO_S32MSB, AUDIO_S16MSB, SDL_Convert_S32MSB_to_S16MSB },
2267 { AUDIO_S32MSB, AUDIO_S32LSB, SDL_Convert_S32MSB_to_S32LSB },
2268 { AUDIO_S32MSB, AUDIO_F32LSB, SDL_Convert_S32MSB_to_F32LSB },
2269 { AUDIO_S32MSB, AUDIO_F32MSB, SDL_Convert_S32MSB_to_F32MSB },
2270 { AUDIO_F32LSB, AUDIO_U8, SDL_Convert_F32LSB_to_U8 },
2271 { AUDIO_F32LSB, AUDIO_S8, SDL_Convert_F32LSB_to_S8 },
2272 { AUDIO_F32LSB, AUDIO_U16LSB, SDL_Convert_F32LSB_to_U16LSB },
2273 { AUDIO_F32LSB, AUDIO_S16LSB, SDL_Convert_F32LSB_to_S16LSB },
2274 { AUDIO_F32LSB, AUDIO_U16MSB, SDL_Convert_F32LSB_to_U16MSB },
2275 { AUDIO_F32LSB, AUDIO_S16MSB, SDL_Convert_F32LSB_to_S16MSB },
2276 { AUDIO_F32LSB, AUDIO_S32LSB, SDL_Convert_F32LSB_to_S32LSB },
2277 { AUDIO_F32LSB, AUDIO_S32MSB, SDL_Convert_F32LSB_to_S32MSB },
2278 { AUDIO_F32LSB, AUDIO_F32MSB, SDL_Convert_F32LSB_to_F32MSB },
2279 { AUDIO_F32MSB, AUDIO_U8, SDL_Convert_F32MSB_to_U8 },
2280 { AUDIO_F32MSB, AUDIO_S8, SDL_Convert_F32MSB_to_S8 },
2281 { AUDIO_F32MSB, AUDIO_U16LSB, SDL_Convert_F32MSB_to_U16LSB },
2282 { AUDIO_F32MSB, AUDIO_S16LSB, SDL_Convert_F32MSB_to_S16LSB },
2283 { AUDIO_F32MSB, AUDIO_U16MSB, SDL_Convert_F32MSB_to_U16MSB },
2284 { AUDIO_F32MSB, AUDIO_S16MSB, SDL_Convert_F32MSB_to_S16MSB },
2285 { AUDIO_F32MSB, AUDIO_S32LSB, SDL_Convert_F32MSB_to_S32LSB },
2286 { AUDIO_F32MSB, AUDIO_S32MSB, SDL_Convert_F32MSB_to_S32MSB },
2287 { AUDIO_F32MSB, AUDIO_F32LSB, SDL_Convert_F32MSB_to_F32LSB },
2288 #endif /* !NO_CONVERTERS */
2289 { 0, 0, NULL }
2290 };
2291
2292
2293 #if !NO_RESAMPLERS
2294
2295 static void SDLCALL
2296 SDL_Upsample_U8_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2297 {
2298 #if DEBUG_CONVERT
2299 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U8, 1 channels.\n", cvt->rate_incr);
2300 #endif
2301
2302 const int srcsize = cvt->len_cvt - 16;
2303 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2304 register int eps = 0;
2305 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 1;
2306 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
2307 const Uint8 *target = ((const Uint8 *) cvt->buf);
2308 Uint8 sample0 = src[0];
2309 Uint8 last_sample0 = sample0;
2310 while (dst >= target) {
2311 dst[0] = sample0;
2312 dst--;
2313 eps += srcsize;
2314 if ((eps << 1) >= dstsize) {
2315 src--;
2316 sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
2317 last_sample0 = sample0;
2318 eps -= dstsize;
2319 }
2320 }
2321 cvt->len_cvt = dstsize;
2322 if (cvt->filters[++cvt->filter_index]) {
2323 cvt->filters[cvt->filter_index] (cvt, format);
2324 }
2325 }
2326
2327 static void SDLCALL
2328 SDL_Downsample_U8_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2329 {
2330 #if DEBUG_CONVERT
2331 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U8, 1 channels.\n", cvt->rate_incr);
2332 #endif
2333
2334 const int srcsize = cvt->len_cvt - 16;
2335 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2336 register int eps = 0;
2337 Uint8 *dst = (Uint8 *) cvt->buf;
2338 const Uint8 *src = (Uint8 *) cvt->buf;
2339 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
2340 Uint8 sample0 = src[0];
2341 Uint8 last_sample0 = sample0;
2342 while (dst < target) {
2343 src++;
2344 eps += dstsize;
2345 if ((eps << 1) >= srcsize) {
2346 dst[0] = sample0;
2347 dst++;
2348 sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
2349 last_sample0 = sample0;
2350 eps -= srcsize;
2351 }
2352 }
2353 cvt->len_cvt = dstsize;
2354 if (cvt->filters[++cvt->filter_index]) {
2355 cvt->filters[cvt->filter_index] (cvt, format);
2356 }
2357 }
2358
2359 static void SDLCALL
2360 SDL_Upsample_U8_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2361 {
2362 #if DEBUG_CONVERT
2363 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U8, 2 channels.\n", cvt->rate_incr);
2364 #endif
2365
2366 const int srcsize = cvt->len_cvt - 32;
2367 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2368 register int eps = 0;
2369 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 2;
2370 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 2;
2371 const Uint8 *target = ((const Uint8 *) cvt->buf);
2372 Uint8 sample1 = src[1];
2373 Uint8 sample0 = src[0];
2374 Uint8 last_sample1 = sample1;
2375 Uint8 last_sample0 = sample0;
2376 while (dst >= target) {
2377 dst[1] = sample1;
2378 dst[0] = sample0;
2379 dst -= 2;
2380 eps += srcsize;
2381 if ((eps << 1) >= dstsize) {
2382 src -= 2;
2383 sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
2384 sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
2385 last_sample1 = sample1;
2386 last_sample0 = sample0;
2387 eps -= dstsize;
2388 }
2389 }
2390 cvt->len_cvt = dstsize;
2391 if (cvt->filters[++cvt->filter_index]) {
2392 cvt->filters[cvt->filter_index] (cvt, format);
2393 }
2394 }
2395
2396 static void SDLCALL
2397 SDL_Downsample_U8_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2398 {
2399 #if DEBUG_CONVERT
2400 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U8, 2 channels.\n", cvt->rate_incr);
2401 #endif
2402
2403 const int srcsize = cvt->len_cvt - 32;
2404 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2405 register int eps = 0;
2406 Uint8 *dst = (Uint8 *) cvt->buf;
2407 const Uint8 *src = (Uint8 *) cvt->buf;
2408 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
2409 Uint8 sample0 = src[0];
2410 Uint8 sample1 = src[1];
2411 Uint8 last_sample0 = sample0;
2412 Uint8 last_sample1 = sample1;
2413 while (dst < target) {
2414 src += 2;
2415 eps += dstsize;
2416 if ((eps << 1) >= srcsize) {
2417 dst[0] = sample0;
2418 dst[1] = sample1;
2419 dst += 2;
2420 sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
2421 sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
2422 last_sample0 = sample0;
2423 last_sample1 = sample1;
2424 eps -= srcsize;
2425 }
2426 }
2427 cvt->len_cvt = dstsize;
2428 if (cvt->filters[++cvt->filter_index]) {
2429 cvt->filters[cvt->filter_index] (cvt, format);
2430 }
2431 }
2432
2433 static void SDLCALL
2434 SDL_Upsample_U8_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2435 {
2436 #if DEBUG_CONVERT
2437 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U8, 4 channels.\n", cvt->rate_incr);
2438 #endif
2439
2440 const int srcsize = cvt->len_cvt - 64;
2441 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2442 register int eps = 0;
2443 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 4;
2444 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 4;
2445 const Uint8 *target = ((const Uint8 *) cvt->buf);
2446 Uint8 sample3 = src[3];
2447 Uint8 sample2 = src[2];
2448 Uint8 sample1 = src[1];
2449 Uint8 sample0 = src[0];
2450 Uint8 last_sample3 = sample3;
2451 Uint8 last_sample2 = sample2;
2452 Uint8 last_sample1 = sample1;
2453 Uint8 last_sample0 = sample0;
2454 while (dst >= target) {
2455 dst[3] = sample3;
2456 dst[2] = sample2;
2457 dst[1] = sample1;
2458 dst[0] = sample0;
2459 dst -= 4;
2460 eps += srcsize;
2461 if ((eps << 1) >= dstsize) {
2462 src -= 4;
2463 sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
2464 sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
2465 sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
2466 sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
2467 last_sample3 = sample3;
2468 last_sample2 = sample2;
2469 last_sample1 = sample1;
2470 last_sample0 = sample0;
2471 eps -= dstsize;
2472 }
2473 }
2474 cvt->len_cvt = dstsize;
2475 if (cvt->filters[++cvt->filter_index]) {
2476 cvt->filters[cvt->filter_index] (cvt, format);
2477 }
2478 }
2479
2480 static void SDLCALL
2481 SDL_Downsample_U8_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2482 {
2483 #if DEBUG_CONVERT
2484 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U8, 4 channels.\n", cvt->rate_incr);
2485 #endif
2486
2487 const int srcsize = cvt->len_cvt - 64;
2488 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2489 register int eps = 0;
2490 Uint8 *dst = (Uint8 *) cvt->buf;
2491 const Uint8 *src = (Uint8 *) cvt->buf;
2492 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
2493 Uint8 sample0 = src[0];
2494 Uint8 sample1 = src[1];
2495 Uint8 sample2 = src[2];
2496 Uint8 sample3 = src[3];
2497 Uint8 last_sample0 = sample0;
2498 Uint8 last_sample1 = sample1;
2499 Uint8 last_sample2 = sample2;
2500 Uint8 last_sample3 = sample3;
2501 while (dst < target) {
2502 src += 4;
2503 eps += dstsize;
2504 if ((eps << 1) >= srcsize) {
2505 dst[0] = sample0;
2506 dst[1] = sample1;
2507 dst[2] = sample2;
2508 dst[3] = sample3;
2509 dst += 4;
2510 sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
2511 sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
2512 sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
2513 sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
2514 last_sample0 = sample0;
2515 last_sample1 = sample1;
2516 last_sample2 = sample2;
2517 last_sample3 = sample3;
2518 eps -= srcsize;
2519 }
2520 }
2521 cvt->len_cvt = dstsize;
2522 if (cvt->filters[++cvt->filter_index]) {
2523 cvt->filters[cvt->filter_index] (cvt, format);
2524 }
2525 }
2526
2527 static void SDLCALL
2528 SDL_Upsample_U8_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2529 {
2530 #if DEBUG_CONVERT
2531 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U8, 6 channels.\n", cvt->rate_incr);
2532 #endif
2533
2534 const int srcsize = cvt->len_cvt - 96;
2535 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2536 register int eps = 0;
2537 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 6;
2538 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 6;
2539 const Uint8 *target = ((const Uint8 *) cvt->buf);
2540 Uint8 sample5 = src[5];
2541 Uint8 sample4 = src[4];
2542 Uint8 sample3 = src[3];
2543 Uint8 sample2 = src[2];
2544 Uint8 sample1 = src[1];
2545 Uint8 sample0 = src[0];
2546 Uint8 last_sample5 = sample5;
2547 Uint8 last_sample4 = sample4;
2548 Uint8 last_sample3 = sample3;
2549 Uint8 last_sample2 = sample2;
2550 Uint8 last_sample1 = sample1;
2551 Uint8 last_sample0 = sample0;
2552 while (dst >= target) {
2553 dst[5] = sample5;
2554 dst[4] = sample4;
2555 dst[3] = sample3;
2556 dst[2] = sample2;
2557 dst[1] = sample1;
2558 dst[0] = sample0;
2559 dst -= 6;
2560 eps += srcsize;
2561 if ((eps << 1) >= dstsize) {
2562 src -= 6;
2563 sample5 = (Uint8) ((((Sint16) src[5]) + ((Sint16) last_sample5)) >> 1);
2564 sample4 = (Uint8) ((((Sint16) src[4]) + ((Sint16) last_sample4)) >> 1);
2565 sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
2566 sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
2567 sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
2568 sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
2569 last_sample5 = sample5;
2570 last_sample4 = sample4;
2571 last_sample3 = sample3;
2572 last_sample2 = sample2;
2573 last_sample1 = sample1;
2574 last_sample0 = sample0;
2575 eps -= dstsize;
2576 }
2577 }
2578 cvt->len_cvt = dstsize;
2579 if (cvt->filters[++cvt->filter_index]) {
2580 cvt->filters[cvt->filter_index] (cvt, format);
2581 }
2582 }
2583
2584 static void SDLCALL
2585 SDL_Downsample_U8_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2586 {
2587 #if DEBUG_CONVERT
2588 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U8, 6 channels.\n", cvt->rate_incr);
2589 #endif
2590
2591 const int srcsize = cvt->len_cvt - 96;
2592 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2593 register int eps = 0;
2594 Uint8 *dst = (Uint8 *) cvt->buf;
2595 const Uint8 *src = (Uint8 *) cvt->buf;
2596 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
2597 Uint8 sample0 = src[0];
2598 Uint8 sample1 = src[1];
2599 Uint8 sample2 = src[2];
2600 Uint8 sample3 = src[3];
2601 Uint8 sample4 = src[4];
2602 Uint8 sample5 = src[5];
2603 Uint8 last_sample0 = sample0;
2604 Uint8 last_sample1 = sample1;
2605 Uint8 last_sample2 = sample2;
2606 Uint8 last_sample3 = sample3;
2607 Uint8 last_sample4 = sample4;
2608 Uint8 last_sample5 = sample5;
2609 while (dst < target) {
2610 src += 6;
2611 eps += dstsize;
2612 if ((eps << 1) >= srcsize) {
2613 dst[0] = sample0;
2614 dst[1] = sample1;
2615 dst[2] = sample2;
2616 dst[3] = sample3;
2617 dst[4] = sample4;
2618 dst[5] = sample5;
2619 dst += 6;
2620 sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
2621 sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
2622 sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
2623 sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
2624 sample4 = (Uint8) ((((Sint16) src[4]) + ((Sint16) last_sample4)) >> 1);
2625 sample5 = (Uint8) ((((Sint16) src[5]) + ((Sint16) last_sample5)) >> 1);
2626 last_sample0 = sample0;
2627 last_sample1 = sample1;
2628 last_sample2 = sample2;
2629 last_sample3 = sample3;
2630 last_sample4 = sample4;
2631 last_sample5 = sample5;
2632 eps -= srcsize;
2633 }
2634 }
2635 cvt->len_cvt = dstsize;
2636 if (cvt->filters[++cvt->filter_index]) {
2637 cvt->filters[cvt->filter_index] (cvt, format);
2638 }
2639 }
2640
2641 static void SDLCALL
2642 SDL_Upsample_U8_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2643 {
2644 #if DEBUG_CONVERT
2645 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U8, 8 channels.\n", cvt->rate_incr);
2646 #endif
2647
2648 const int srcsize = cvt->len_cvt - 128;
2649 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2650 register int eps = 0;
2651 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 8;
2652 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 8;
2653 const Uint8 *target = ((const Uint8 *) cvt->buf);
2654 Uint8 sample7 = src[7];
2655 Uint8 sample6 = src[6];
2656 Uint8 sample5 = src[5];
2657 Uint8 sample4 = src[4];
2658 Uint8 sample3 = src[3];
2659 Uint8 sample2 = src[2];
2660 Uint8 sample1 = src[1];
2661 Uint8 sample0 = src[0];
2662 Uint8 last_sample7 = sample7;
2663 Uint8 last_sample6 = sample6;
2664 Uint8 last_sample5 = sample5;
2665 Uint8 last_sample4 = sample4;
2666 Uint8 last_sample3 = sample3;
2667 Uint8 last_sample2 = sample2;
2668 Uint8 last_sample1 = sample1;
2669 Uint8 last_sample0 = sample0;
2670 while (dst >= target) {
2671 dst[7] = sample7;
2672 dst[6] = sample6;
2673 dst[5] = sample5;
2674 dst[4] = sample4;
2675 dst[3] = sample3;
2676 dst[2] = sample2;
2677 dst[1] = sample1;
2678 dst[0] = sample0;
2679 dst -= 8;
2680 eps += srcsize;
2681 if ((eps << 1) >= dstsize) {
2682 src -= 8;
2683 sample7 = (Uint8) ((((Sint16) src[7]) + ((Sint16) last_sample7)) >> 1);
2684 sample6 = (Uint8) ((((Sint16) src[6]) + ((Sint16) last_sample6)) >> 1);
2685 sample5 = (Uint8) ((((Sint16) src[5]) + ((Sint16) last_sample5)) >> 1);
2686 sample4 = (Uint8) ((((Sint16) src[4]) + ((Sint16) last_sample4)) >> 1);
2687 sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
2688 sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
2689 sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
2690 sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
2691 last_sample7 = sample7;
2692 last_sample6 = sample6;
2693 last_sample5 = sample5;
2694 last_sample4 = sample4;
2695 last_sample3 = sample3;
2696 last_sample2 = sample2;
2697 last_sample1 = sample1;
2698 last_sample0 = sample0;
2699 eps -= dstsize;
2700 }
2701 }
2702 cvt->len_cvt = dstsize;
2703 if (cvt->filters[++cvt->filter_index]) {
2704 cvt->filters[cvt->filter_index] (cvt, format);
2705 }
2706 }
2707
2708 static void SDLCALL
2709 SDL_Downsample_U8_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2710 {
2711 #if DEBUG_CONVERT
2712 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U8, 8 channels.\n", cvt->rate_incr);
2713 #endif
2714
2715 const int srcsize = cvt->len_cvt - 128;
2716 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2717 register int eps = 0;
2718 Uint8 *dst = (Uint8 *) cvt->buf;
2719 const Uint8 *src = (Uint8 *) cvt->buf;
2720 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
2721 Uint8 sample0 = src[0];
2722 Uint8 sample1 = src[1];
2723 Uint8 sample2 = src[2];
2724 Uint8 sample3 = src[3];
2725 Uint8 sample4 = src[4];
2726 Uint8 sample5 = src[5];
2727 Uint8 sample6 = src[6];
2728 Uint8 sample7 = src[7];
2729 Uint8 last_sample0 = sample0;
2730 Uint8 last_sample1 = sample1;
2731 Uint8 last_sample2 = sample2;
2732 Uint8 last_sample3 = sample3;
2733 Uint8 last_sample4 = sample4;
2734 Uint8 last_sample5 = sample5;
2735 Uint8 last_sample6 = sample6;
2736 Uint8 last_sample7 = sample7;
2737 while (dst < target) {
2738 src += 8;
2739 eps += dstsize;
2740 if ((eps << 1) >= srcsize) {
2741 dst[0] = sample0;
2742 dst[1] = sample1;
2743 dst[2] = sample2;
2744 dst[3] = sample3;
2745 dst[4] = sample4;
2746 dst[5] = sample5;
2747 dst[6] = sample6;
2748 dst[7] = sample7;
2749 dst += 8;
2750 sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
2751 sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
2752 sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
2753 sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
2754 sample4 = (Uint8) ((((Sint16) src[4]) + ((Sint16) last_sample4)) >> 1);
2755 sample5 = (Uint8) ((((Sint16) src[5]) + ((Sint16) last_sample5)) >> 1);
2756 sample6 = (Uint8) ((((Sint16) src[6]) + ((Sint16) last_sample6)) >> 1);
2757 sample7 = (Uint8) ((((Sint16) src[7]) + ((Sint16) last_sample7)) >> 1);
2758 last_sample0 = sample0;
2759 last_sample1 = sample1;
2760 last_sample2 = sample2;
2761 last_sample3 = sample3;
2762 last_sample4 = sample4;
2763 last_sample5 = sample5;
2764 last_sample6 = sample6;
2765 last_sample7 = sample7;
2766 eps -= srcsize;
2767 }
2768 }
2769 cvt->len_cvt = dstsize;
2770 if (cvt->filters[++cvt->filter_index]) {
2771 cvt->filters[cvt->filter_index] (cvt, format);
2772 }
2773 }
2774
2775 static void SDLCALL
2776 SDL_Upsample_S8_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2777 {
2778 #if DEBUG_CONVERT
2779 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S8, 1 channels.\n", cvt->rate_incr);
2780 #endif
2781
2782 const int srcsize = cvt->len_cvt - 16;
2783 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2784 register int eps = 0;
2785 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 1;
2786 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 1;
2787 const Sint8 *target = ((const Sint8 *) cvt->buf);
2788 Sint8 sample0 = ((Sint8) src[0]);
2789 Sint8 last_sample0 = sample0;
2790 while (dst >= target) {
2791 dst[0] = ((Sint8) sample0);
2792 dst--;
2793 eps += srcsize;
2794 if ((eps << 1) >= dstsize) {
2795 src--;
2796 sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
2797 last_sample0 = sample0;
2798 eps -= dstsize;
2799 }
2800 }
2801 cvt->len_cvt = dstsize;
2802 if (cvt->filters[++cvt->filter_index]) {
2803 cvt->filters[cvt->filter_index] (cvt, format);
2804 }
2805 }
2806
2807 static void SDLCALL
2808 SDL_Downsample_S8_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2809 {
2810 #if DEBUG_CONVERT
2811 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S8, 1 channels.\n", cvt->rate_incr);
2812 #endif
2813
2814 const int srcsize = cvt->len_cvt - 16;
2815 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2816 register int eps = 0;
2817 Sint8 *dst = (Sint8 *) cvt->buf;
2818 const Sint8 *src = (Sint8 *) cvt->buf;
2819 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
2820 Sint8 sample0 = ((Sint8) src[0]);
2821 Sint8 last_sample0 = sample0;
2822 while (dst < target) {
2823 src++;
2824 eps += dstsize;
2825 if ((eps << 1) >= srcsize) {
2826 dst[0] = ((Sint8) sample0);
2827 dst++;
2828 sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
2829 last_sample0 = sample0;
2830 eps -= srcsize;
2831 }
2832 }
2833 cvt->len_cvt = dstsize;
2834 if (cvt->filters[++cvt->filter_index]) {
2835 cvt->filters[cvt->filter_index] (cvt, format);
2836 }
2837 }
2838
2839 static void SDLCALL
2840 SDL_Upsample_S8_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2841 {
2842 #if DEBUG_CONVERT
2843 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S8, 2 channels.\n", cvt->rate_incr);
2844 #endif
2845
2846 const int srcsize = cvt->len_cvt - 32;
2847 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2848 register int eps = 0;
2849 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 2;
2850 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 2;
2851 const Sint8 *target = ((const Sint8 *) cvt->buf);
2852 Sint8 sample1 = ((Sint8) src[1]);
2853 Sint8 sample0 = ((Sint8) src[0]);
2854 Sint8 last_sample1 = sample1;
2855 Sint8 last_sample0 = sample0;
2856 while (dst >= target) {
2857 dst[1] = ((Sint8) sample1);
2858 dst[0] = ((Sint8) sample0);
2859 dst -= 2;
2860 eps += srcsize;
2861 if ((eps << 1) >= dstsize) {
2862 src -= 2;
2863 sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
2864 sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
2865 last_sample1 = sample1;
2866 last_sample0 = sample0;
2867 eps -= dstsize;
2868 }
2869 }
2870 cvt->len_cvt = dstsize;
2871 if (cvt->filters[++cvt->filter_index]) {
2872 cvt->filters[cvt->filter_index] (cvt, format);
2873 }
2874 }
2875
2876 static void SDLCALL
2877 SDL_Downsample_S8_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2878 {
2879 #if DEBUG_CONVERT
2880 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S8, 2 channels.\n", cvt->rate_incr);
2881 #endif
2882
2883 const int srcsize = cvt->len_cvt - 32;
2884 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2885 register int eps = 0;
2886 Sint8 *dst = (Sint8 *) cvt->buf;
2887 const Sint8 *src = (Sint8 *) cvt->buf;
2888 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
2889 Sint8 sample0 = ((Sint8) src[0]);
2890 Sint8 sample1 = ((Sint8) src[1]);
2891 Sint8 last_sample0 = sample0;
2892 Sint8 last_sample1 = sample1;
2893 while (dst < target) {
2894 src += 2;
2895 eps += dstsize;
2896 if ((eps << 1) >= srcsize) {
2897 dst[0] = ((Sint8) sample0);
2898 dst[1] = ((Sint8) sample1);
2899 dst += 2;
2900 sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
2901 sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
2902 last_sample0 = sample0;
2903 last_sample1 = sample1;
2904 eps -= srcsize;
2905 }
2906 }
2907 cvt->len_cvt = dstsize;
2908 if (cvt->filters[++cvt->filter_index]) {
2909 cvt->filters[cvt->filter_index] (cvt, format);
2910 }
2911 }
2912
2913 static void SDLCALL
2914 SDL_Upsample_S8_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2915 {
2916 #if DEBUG_CONVERT
2917 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S8, 4 channels.\n", cvt->rate_incr);
2918 #endif
2919
2920 const int srcsize = cvt->len_cvt - 64;
2921 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2922 register int eps = 0;
2923 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 4;
2924 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 4;
2925 const Sint8 *target = ((const Sint8 *) cvt->buf);
2926 Sint8 sample3 = ((Sint8) src[3]);
2927 Sint8 sample2 = ((Sint8) src[2]);
2928 Sint8 sample1 = ((Sint8) src[1]);
2929 Sint8 sample0 = ((Sint8) src[0]);
2930 Sint8 last_sample3 = sample3;
2931 Sint8 last_sample2 = sample2;
2932 Sint8 last_sample1 = sample1;
2933 Sint8 last_sample0 = sample0;
2934 while (dst >= target) {
2935 dst[3] = ((Sint8) sample3);
2936 dst[2] = ((Sint8) sample2);
2937 dst[1] = ((Sint8) sample1);
2938 dst[0] = ((Sint8) sample0);
2939 dst -= 4;
2940 eps += srcsize;
2941 if ((eps << 1) >= dstsize) {
2942 src -= 4;
2943 sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
2944 sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
2945 sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
2946 sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
2947 last_sample3 = sample3;
2948 last_sample2 = sample2;
2949 last_sample1 = sample1;
2950 last_sample0 = sample0;
2951 eps -= dstsize;
2952 }
2953 }
2954 cvt->len_cvt = dstsize;
2955 if (cvt->filters[++cvt->filter_index]) {
2956 cvt->filters[cvt->filter_index] (cvt, format);
2957 }
2958 }
2959
2960 static void SDLCALL
2961 SDL_Downsample_S8_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2962 {
2963 #if DEBUG_CONVERT
2964 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S8, 4 channels.\n", cvt->rate_incr);
2965 #endif
2966
2967 const int srcsize = cvt->len_cvt - 64;
2968 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
2969 register int eps = 0;
2970 Sint8 *dst = (Sint8 *) cvt->buf;
2971 const Sint8 *src = (Sint8 *) cvt->buf;
2972 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
2973 Sint8 sample0 = ((Sint8) src[0]);
2974 Sint8 sample1 = ((Sint8) src[1]);
2975 Sint8 sample2 = ((Sint8) src[2]);
2976 Sint8 sample3 = ((Sint8) src[3]);
2977 Sint8 last_sample0 = sample0;
2978 Sint8 last_sample1 = sample1;
2979 Sint8 last_sample2 = sample2;
2980 Sint8 last_sample3 = sample3;
2981 while (dst < target) {
2982 src += 4;
2983 eps += dstsize;
2984 if ((eps << 1) >= srcsize) {
2985 dst[0] = ((Sint8) sample0);
2986 dst[1] = ((Sint8) sample1);
2987 dst[2] = ((Sint8) sample2);
2988 dst[3] = ((Sint8) sample3);
2989 dst += 4;
2990 sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
2991 sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
2992 sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
2993 sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
2994 last_sample0 = sample0;
2995 last_sample1 = sample1;
2996 last_sample2 = sample2;
2997 last_sample3 = sample3;
2998 eps -= srcsize;
2999 }
3000 }
3001 cvt->len_cvt = dstsize;
3002 if (cvt->filters[++cvt->filter_index]) {
3003 cvt->filters[cvt->filter_index] (cvt, format);
3004 }
3005 }
3006
3007 static void SDLCALL
3008 SDL_Upsample_S8_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3009 {
3010 #if DEBUG_CONVERT
3011 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S8, 6 channels.\n", cvt->rate_incr);
3012 #endif
3013
3014 const int srcsize = cvt->len_cvt - 96;
3015 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3016 register int eps = 0;
3017 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 6;
3018 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 6;
3019 const Sint8 *target = ((const Sint8 *) cvt->buf);
3020 Sint8 sample5 = ((Sint8) src[5]);
3021 Sint8 sample4 = ((Sint8) src[4]);
3022 Sint8 sample3 = ((Sint8) src[3]);
3023 Sint8 sample2 = ((Sint8) src[2]);
3024 Sint8 sample1 = ((Sint8) src[1]);
3025 Sint8 sample0 = ((Sint8) src[0]);
3026 Sint8 last_sample5 = sample5;
3027 Sint8 last_sample4 = sample4;
3028 Sint8 last_sample3 = sample3;
3029 Sint8 last_sample2 = sample2;
3030 Sint8 last_sample1 = sample1;
3031 Sint8 last_sample0 = sample0;
3032 while (dst >= target) {
3033 dst[5] = ((Sint8) sample5);
3034 dst[4] = ((Sint8) sample4);
3035 dst[3] = ((Sint8) sample3);
3036 dst[2] = ((Sint8) sample2);
3037 dst[1] = ((Sint8) sample1);
3038 dst[0] = ((Sint8) sample0);
3039 dst -= 6;
3040 eps += srcsize;
3041 if ((eps << 1) >= dstsize) {
3042 src -= 6;
3043 sample5 = (Sint8) ((((Sint16) ((Sint8) src[5])) + ((Sint16) last_sample5)) >> 1);
3044 sample4 = (Sint8) ((((Sint16) ((Sint8) src[4])) + ((Sint16) last_sample4)) >> 1);
3045 sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
3046 sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
3047 sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
3048 sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
3049 last_sample5 = sample5;
3050 last_sample4 = sample4;
3051 last_sample3 = sample3;
3052 last_sample2 = sample2;
3053 last_sample1 = sample1;
3054 last_sample0 = sample0;
3055 eps -= dstsize;
3056 }
3057 }
3058 cvt->len_cvt = dstsize;
3059 if (cvt->filters[++cvt->filter_index]) {
3060 cvt->filters[cvt->filter_index] (cvt, format);
3061 }
3062 }
3063
3064 static void SDLCALL
3065 SDL_Downsample_S8_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3066 {
3067 #if DEBUG_CONVERT
3068 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S8, 6 channels.\n", cvt->rate_incr);
3069 #endif
3070
3071 const int srcsize = cvt->len_cvt - 96;
3072 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3073 register int eps = 0;
3074 Sint8 *dst = (Sint8 *) cvt->buf;
3075 const Sint8 *src = (Sint8 *) cvt->buf;
3076 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
3077 Sint8 sample0 = ((Sint8) src[0]);
3078 Sint8 sample1 = ((Sint8) src[1]);
3079 Sint8 sample2 = ((Sint8) src[2]);
3080 Sint8 sample3 = ((Sint8) src[3]);
3081 Sint8 sample4 = ((Sint8) src[4]);
3082 Sint8 sample5 = ((Sint8) src[5]);
3083 Sint8 last_sample0 = sample0;
3084 Sint8 last_sample1 = sample1;
3085 Sint8 last_sample2 = sample2;
3086 Sint8 last_sample3 = sample3;
3087 Sint8 last_sample4 = sample4;
3088 Sint8 last_sample5 = sample5;
3089 while (dst < target) {
3090 src += 6;
3091 eps += dstsize;
3092 if ((eps << 1) >= srcsize) {
3093 dst[0] = ((Sint8) sample0);
3094 dst[1] = ((Sint8) sample1);
3095 dst[2] = ((Sint8) sample2);
3096 dst[3] = ((Sint8) sample3);
3097 dst[4] = ((Sint8) sample4);
3098 dst[5] = ((Sint8) sample5);
3099 dst += 6;
3100 sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
3101 sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
3102 sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
3103 sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
3104 sample4 = (Sint8) ((((Sint16) ((Sint8) src[4])) + ((Sint16) last_sample4)) >> 1);
3105 sample5 = (Sint8) ((((Sint16) ((Sint8) src[5])) + ((Sint16) last_sample5)) >> 1);
3106 last_sample0 = sample0;
3107 last_sample1 = sample1;
3108 last_sample2 = sample2;
3109 last_sample3 = sample3;
3110 last_sample4 = sample4;
3111 last_sample5 = sample5;
3112 eps -= srcsize;
3113 }
3114 }
3115 cvt->len_cvt = dstsize;
3116 if (cvt->filters[++cvt->filter_index]) {
3117 cvt->filters[cvt->filter_index] (cvt, format);
3118 }
3119 }
3120
3121 static void SDLCALL
3122 SDL_Upsample_S8_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3123 {
3124 #if DEBUG_CONVERT
3125 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S8, 8 channels.\n", cvt->rate_incr);
3126 #endif
3127
3128 const int srcsize = cvt->len_cvt - 128;
3129 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3130 register int eps = 0;
3131 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 8;
3132 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 8;
3133 const Sint8 *target = ((const Sint8 *) cvt->buf);
3134 Sint8 sample7 = ((Sint8) src[7]);
3135 Sint8 sample6 = ((Sint8) src[6]);
3136 Sint8 sample5 = ((Sint8) src[5]);
3137 Sint8 sample4 = ((Sint8) src[4]);
3138 Sint8 sample3 = ((Sint8) src[3]);
3139 Sint8 sample2 = ((Sint8) src[2]);
3140 Sint8 sample1 = ((Sint8) src[1]);
3141 Sint8 sample0 = ((Sint8) src[0]);
3142 Sint8 last_sample7 = sample7;
3143 Sint8 last_sample6 = sample6;
3144 Sint8 last_sample5 = sample5;
3145 Sint8 last_sample4 = sample4;
3146 Sint8 last_sample3 = sample3;
3147 Sint8 last_sample2 = sample2;
3148 Sint8 last_sample1 = sample1;
3149 Sint8 last_sample0 = sample0;
3150 while (dst >= target) {
3151 dst[7] = ((Sint8) sample7);
3152 dst[6] = ((Sint8) sample6);
3153 dst[5] = ((Sint8) sample5);
3154 dst[4] = ((Sint8) sample4);
3155 dst[3] = ((Sint8) sample3);
3156 dst[2] = ((Sint8) sample2);
3157 dst[1] = ((Sint8) sample1);
3158 dst[0] = ((Sint8) sample0);
3159 dst -= 8;
3160 eps += srcsize;
3161 if ((eps << 1) >= dstsize) {
3162 src -= 8;
3163 sample7 = (Sint8) ((((Sint16) ((Sint8) src[7])) + ((Sint16) last_sample7)) >> 1);
3164 sample6 = (Sint8) ((((Sint16) ((Sint8) src[6])) + ((Sint16) last_sample6)) >> 1);
3165 sample5 = (Sint8) ((((Sint16) ((Sint8) src[5])) + ((Sint16) last_sample5)) >> 1);
3166 sample4 = (Sint8) ((((Sint16) ((Sint8) src[4])) + ((Sint16) last_sample4)) >> 1);
3167 sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
3168 sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
3169 sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
3170 sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
3171 last_sample7 = sample7;
3172 last_sample6 = sample6;
3173 last_sample5 = sample5;
3174 last_sample4 = sample4;
3175 last_sample3 = sample3;
3176 last_sample2 = sample2;
3177 last_sample1 = sample1;
3178 last_sample0 = sample0;
3179 eps -= dstsize;
3180 }
3181 }
3182 cvt->len_cvt = dstsize;
3183 if (cvt->filters[++cvt->filter_index]) {
3184 cvt->filters[cvt->filter_index] (cvt, format);
3185 }
3186 }
3187
3188 static void SDLCALL
3189 SDL_Downsample_S8_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3190 {
3191 #if DEBUG_CONVERT
3192 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S8, 8 channels.\n", cvt->rate_incr);
3193 #endif
3194
3195 const int srcsize = cvt->len_cvt - 128;
3196 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3197 register int eps = 0;
3198 Sint8 *dst = (Sint8 *) cvt->buf;
3199 const Sint8 *src = (Sint8 *) cvt->buf;
3200 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
3201 Sint8 sample0 = ((Sint8) src[0]);
3202 Sint8 sample1 = ((Sint8) src[1]);
3203 Sint8 sample2 = ((Sint8) src[2]);
3204 Sint8 sample3 = ((Sint8) src[3]);
3205 Sint8 sample4 = ((Sint8) src[4]);
3206 Sint8 sample5 = ((Sint8) src[5]);
3207 Sint8 sample6 = ((Sint8) src[6]);
3208 Sint8 sample7 = ((Sint8) src[7]);
3209 Sint8 last_sample0 = sample0;
3210 Sint8 last_sample1 = sample1;
3211 Sint8 last_sample2 = sample2;
3212 Sint8 last_sample3 = sample3;
3213 Sint8 last_sample4 = sample4;
3214 Sint8 last_sample5 = sample5;
3215 Sint8 last_sample6 = sample6;
3216 Sint8 last_sample7 = sample7;
3217 while (dst < target) {
3218 src += 8;
3219 eps += dstsize;
3220 if ((eps << 1) >= srcsize) {
3221 dst[0] = ((Sint8) sample0);
3222 dst[1] = ((Sint8) sample1);
3223 dst[2] = ((Sint8) sample2);
3224 dst[3] = ((Sint8) sample3);
3225 dst[4] = ((Sint8) sample4);
3226 dst[5] = ((Sint8) sample5);
3227 dst[6] = ((Sint8) sample6);
3228 dst[7] = ((Sint8) sample7);
3229 dst += 8;
3230 sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
3231 sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
3232 sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
3233 sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
3234 sample4 = (Sint8) ((((Sint16) ((Sint8) src[4])) + ((Sint16) last_sample4)) >> 1);
3235 sample5 = (Sint8) ((((Sint16) ((Sint8) src[5])) + ((Sint16) last_sample5)) >> 1);
3236 sample6 = (Sint8) ((((Sint16) ((Sint8) src[6])) + ((Sint16) last_sample6)) >> 1);
3237 sample7 = (Sint8) ((((Sint16) ((Sint8) src[7])) + ((Sint16) last_sample7)) >> 1);
3238 last_sample0 = sample0;
3239 last_sample1 = sample1;
3240 last_sample2 = sample2;
3241 last_sample3 = sample3;
3242 last_sample4 = sample4;
3243 last_sample5 = sample5;
3244 last_sample6 = sample6;
3245 last_sample7 = sample7;
3246 eps -= srcsize;
3247 }
3248 }
3249 cvt->len_cvt = dstsize;
3250 if (cvt->filters[++cvt->filter_index]) {
3251 cvt->filters[cvt->filter_index] (cvt, format);
3252 }
3253 }
3254
3255 static void SDLCALL
3256 SDL_Upsample_U16LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3257 {
3258 #if DEBUG_CONVERT
3259 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16LSB, 1 channels.\n", cvt->rate_incr);
3260 #endif
3261
3262 const int srcsize = cvt->len_cvt - 32;
3263 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3264 register int eps = 0;
3265 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1;
3266 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
3267 const Uint16 *target = ((const Uint16 *) cvt->buf);
3268 Uint16 sample0 = SDL_SwapLE16(src[0]);
3269 Uint16 last_sample0 = sample0;
3270 while (dst >= target) {
3271 dst[0] = SDL_SwapLE16(sample0);
3272 dst--;
3273 eps += srcsize;
3274 if ((eps << 1) >= dstsize) {
3275 src--;
3276 sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
3277 last_sample0 = sample0;
3278 eps -= dstsize;
3279 }
3280 }
3281 cvt->len_cvt = dstsize;
3282 if (cvt->filters[++cvt->filter_index]) {
3283 cvt->filters[cvt->filter_index] (cvt, format);
3284 }
3285 }
3286
3287 static void SDLCALL
3288 SDL_Downsample_U16LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3289 {
3290 #if DEBUG_CONVERT
3291 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16LSB, 1 channels.\n", cvt->rate_incr);
3292 #endif
3293
3294 const int srcsize = cvt->len_cvt - 32;
3295 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3296 register int eps = 0;
3297 Uint16 *dst = (Uint16 *) cvt->buf;
3298 const Uint16 *src = (Uint16 *) cvt->buf;
3299 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
3300 Uint16 sample0 = SDL_SwapLE16(src[0]);
3301 Uint16 last_sample0 = sample0;
3302 while (dst < target) {
3303 src++;
3304 eps += dstsize;
3305 if ((eps << 1) >= srcsize) {
3306 dst[0] = SDL_SwapLE16(sample0);
3307 dst++;
3308 sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
3309 last_sample0 = sample0;
3310 eps -= srcsize;
3311 }
3312 }
3313 cvt->len_cvt = dstsize;
3314 if (cvt->filters[++cvt->filter_index]) {
3315 cvt->filters[cvt->filter_index] (cvt, format);
3316 }
3317 }
3318
3319 static void SDLCALL
3320 SDL_Upsample_U16LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3321 {
3322 #if DEBUG_CONVERT
3323 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16LSB, 2 channels.\n", cvt->rate_incr);
3324 #endif
3325
3326 const int srcsize = cvt->len_cvt - 64;
3327 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3328 register int eps = 0;
3329 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2;
3330 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
3331 const Uint16 *target = ((const Uint16 *) cvt->buf);
3332 Uint16 sample1 = SDL_SwapLE16(src[1]);
3333 Uint16 sample0 = SDL_SwapLE16(src[0]);
3334 Uint16 last_sample1 = sample1;
3335 Uint16 last_sample0 = sample0;
3336 while (dst >= target) {
3337 dst[1] = SDL_SwapLE16(sample1);
3338 dst[0] = SDL_SwapLE16(sample0);
3339 dst -= 2;
3340 eps += srcsize;
3341 if ((eps << 1) >= dstsize) {
3342 src -= 2;
3343 sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
3344 sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
3345 last_sample1 = sample1;
3346 last_sample0 = sample0;
3347 eps -= dstsize;
3348 }
3349 }
3350 cvt->len_cvt = dstsize;
3351 if (cvt->filters[++cvt->filter_index]) {
3352 cvt->filters[cvt->filter_index] (cvt, format);
3353 }
3354 }
3355
3356 static void SDLCALL
3357 SDL_Downsample_U16LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3358 {
3359 #if DEBUG_CONVERT
3360 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16LSB, 2 channels.\n", cvt->rate_incr);
3361 #endif
3362
3363 const int srcsize = cvt->len_cvt - 64;
3364 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3365 register int eps = 0;
3366 Uint16 *dst = (Uint16 *) cvt->buf;
3367 const Uint16 *src = (Uint16 *) cvt->buf;
3368 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
3369 Uint16 sample0 = SDL_SwapLE16(src[0]);
3370 Uint16 sample1 = SDL_SwapLE16(src[1]);
3371 Uint16 last_sample0 = sample0;
3372 Uint16 last_sample1 = sample1;
3373 while (dst < target) {
3374 src += 2;
3375 eps += dstsize;
3376 if ((eps << 1) >= srcsize) {
3377 dst[0] = SDL_SwapLE16(sample0);
3378 dst[1] = SDL_SwapLE16(sample1);
3379 dst += 2;
3380 sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
3381 sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
3382 last_sample0 = sample0;
3383 last_sample1 = sample1;
3384 eps -= srcsize;
3385 }
3386 }
3387 cvt->len_cvt = dstsize;
3388 if (cvt->filters[++cvt->filter_index]) {
3389 cvt->filters[cvt->filter_index] (cvt, format);
3390 }
3391 }
3392
3393 static void SDLCALL
3394 SDL_Upsample_U16LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3395 {
3396 #if DEBUG_CONVERT
3397 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16LSB, 4 channels.\n", cvt->rate_incr);
3398 #endif
3399
3400 const int srcsize = cvt->len_cvt - 128;
3401 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3402 register int eps = 0;
3403 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4;
3404 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
3405 const Uint16 *target = ((const Uint16 *) cvt->buf);
3406 Uint16 sample3 = SDL_SwapLE16(src[3]);
3407 Uint16 sample2 = SDL_SwapLE16(src[2]);
3408 Uint16 sample1 = SDL_SwapLE16(src[1]);
3409 Uint16 sample0 = SDL_SwapLE16(src[0]);
3410 Uint16 last_sample3 = sample3;
3411 Uint16 last_sample2 = sample2;
3412 Uint16 last_sample1 = sample1;
3413 Uint16 last_sample0 = sample0;
3414 while (dst >= target) {
3415 dst[3] = SDL_SwapLE16(sample3);
3416 dst[2] = SDL_SwapLE16(sample2);
3417 dst[1] = SDL_SwapLE16(sample1);
3418 dst[0] = SDL_SwapLE16(sample0);
3419 dst -= 4;
3420 eps += srcsize;
3421 if ((eps << 1) >= dstsize) {
3422 src -= 4;
3423 sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
3424 sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
3425 sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
3426 sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
3427 last_sample3 = sample3;
3428 last_sample2 = sample2;
3429 last_sample1 = sample1;
3430 last_sample0 = sample0;
3431 eps -= dstsize;
3432 }
3433 }
3434 cvt->len_cvt = dstsize;
3435 if (cvt->filters[++cvt->filter_index]) {
3436 cvt->filters[cvt->filter_index] (cvt, format);
3437 }
3438 }
3439
3440 static void SDLCALL
3441 SDL_Downsample_U16LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3442 {
3443 #if DEBUG_CONVERT
3444 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16LSB, 4 channels.\n", cvt->rate_incr);
3445 #endif
3446
3447 const int srcsize = cvt->len_cvt - 128;
3448 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3449 register int eps = 0;
3450 Uint16 *dst = (Uint16 *) cvt->buf;
3451 const Uint16 *src = (Uint16 *) cvt->buf;
3452 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
3453 Uint16 sample0 = SDL_SwapLE16(src[0]);
3454 Uint16 sample1 = SDL_SwapLE16(src[1]);
3455 Uint16 sample2 = SDL_SwapLE16(src[2]);
3456 Uint16 sample3 = SDL_SwapLE16(src[3]);
3457 Uint16 last_sample0 = sample0;
3458 Uint16 last_sample1 = sample1;
3459 Uint16 last_sample2 = sample2;
3460 Uint16 last_sample3 = sample3;
3461 while (dst < target) {
3462 src += 4;
3463 eps += dstsize;
3464 if ((eps << 1) >= srcsize) {
3465 dst[0] = SDL_SwapLE16(sample0);
3466 dst[1] = SDL_SwapLE16(sample1);
3467 dst[2] = SDL_SwapLE16(sample2);
3468 dst[3] = SDL_SwapLE16(sample3);
3469 dst += 4;
3470 sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
3471 sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
3472 sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
3473 sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
3474 last_sample0 = sample0;
3475 last_sample1 = sample1;
3476 last_sample2 = sample2;
3477 last_sample3 = sample3;
3478 eps -= srcsize;
3479 }
3480 }
3481 cvt->len_cvt = dstsize;
3482 if (cvt->filters[++cvt->filter_index]) {
3483 cvt->filters[cvt->filter_index] (cvt, format);
3484 }
3485 }
3486
3487 static void SDLCALL
3488 SDL_Upsample_U16LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3489 {
3490 #if DEBUG_CONVERT
3491 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16LSB, 6 channels.\n", cvt->rate_incr);
3492 #endif
3493
3494 const int srcsize = cvt->len_cvt - 192;
3495 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3496 register int eps = 0;
3497 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6;
3498 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
3499 const Uint16 *target = ((const Uint16 *) cvt->buf);
3500 Uint16 sample5 = SDL_SwapLE16(src[5]);
3501 Uint16 sample4 = SDL_SwapLE16(src[4]);
3502 Uint16 sample3 = SDL_SwapLE16(src[3]);
3503 Uint16 sample2 = SDL_SwapLE16(src[2]);
3504 Uint16 sample1 = SDL_SwapLE16(src[1]);
3505 Uint16 sample0 = SDL_SwapLE16(src[0]);
3506 Uint16 last_sample5 = sample5;
3507 Uint16 last_sample4 = sample4;
3508 Uint16 last_sample3 = sample3;
3509 Uint16 last_sample2 = sample2;
3510 Uint16 last_sample1 = sample1;
3511 Uint16 last_sample0 = sample0;
3512 while (dst >= target) {
3513 dst[5] = SDL_SwapLE16(sample5);
3514 dst[4] = SDL_SwapLE16(sample4);
3515 dst[3] = SDL_SwapLE16(sample3);
3516 dst[2] = SDL_SwapLE16(sample2);
3517 dst[1] = SDL_SwapLE16(sample1);
3518 dst[0] = SDL_SwapLE16(sample0);
3519 dst -= 6;
3520 eps += srcsize;
3521 if ((eps << 1) >= dstsize) {
3522 src -= 6;
3523 sample5 = (Uint16) ((((Sint32) SDL_SwapLE16(src[5])) + ((Sint32) last_sample5)) >> 1);
3524 sample4 = (Uint16) ((((Sint32) SDL_SwapLE16(src[4])) + ((Sint32) last_sample4)) >> 1);
3525 sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
3526 sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
3527 sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
3528 sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
3529 last_sample5 = sample5;
3530 last_sample4 = sample4;
3531 last_sample3 = sample3;
3532 last_sample2 = sample2;
3533 last_sample1 = sample1;
3534 last_sample0 = sample0;
3535 eps -= dstsize;
3536 }
3537 }
3538 cvt->len_cvt = dstsize;
3539 if (cvt->filters[++cvt->filter_index]) {
3540 cvt->filters[cvt->filter_index] (cvt, format);
3541 }
3542 }
3543
3544 static void SDLCALL
3545 SDL_Downsample_U16LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3546 {
3547 #if DEBUG_CONVERT
3548 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16LSB, 6 channels.\n", cvt->rate_incr);
3549 #endif
3550
3551 const int srcsize = cvt->len_cvt - 192;
3552 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3553 register int eps = 0;
3554 Uint16 *dst = (Uint16 *) cvt->buf;
3555 const Uint16 *src = (Uint16 *) cvt->buf;
3556 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
3557 Uint16 sample0 = SDL_SwapLE16(src[0]);
3558 Uint16 sample1 = SDL_SwapLE16(src[1]);
3559 Uint16 sample2 = SDL_SwapLE16(src[2]);
3560 Uint16 sample3 = SDL_SwapLE16(src[3]);
3561 Uint16 sample4 = SDL_SwapLE16(src[4]);
3562 Uint16 sample5 = SDL_SwapLE16(src[5]);
3563 Uint16 last_sample0 = sample0;
3564 Uint16 last_sample1 = sample1;
3565 Uint16 last_sample2 = sample2;
3566 Uint16 last_sample3 = sample3;
3567 Uint16 last_sample4 = sample4;
3568 Uint16 last_sample5 = sample5;
3569 while (dst < target) {
3570 src += 6;
3571 eps += dstsize;
3572 if ((eps << 1) >= srcsize) {
3573 dst[0] = SDL_SwapLE16(sample0);
3574 dst[1] = SDL_SwapLE16(sample1);
3575 dst[2] = SDL_SwapLE16(sample2);
3576 dst[3] = SDL_SwapLE16(sample3);
3577 dst[4] = SDL_SwapLE16(sample4);
3578 dst[5] = SDL_SwapLE16(sample5);
3579 dst += 6;
3580 sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
3581 sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
3582 sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
3583 sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
3584 sample4 = (Uint16) ((((Sint32) SDL_SwapLE16(src[4])) + ((Sint32) last_sample4)) >> 1);
3585 sample5 = (Uint16) ((((Sint32) SDL_SwapLE16(src[5])) + ((Sint32) last_sample5)) >> 1);
3586 last_sample0 = sample0;
3587 last_sample1 = sample1;
3588 last_sample2 = sample2;
3589 last_sample3 = sample3;
3590 last_sample4 = sample4;
3591 last_sample5 = sample5;
3592 eps -= srcsize;
3593 }
3594 }
3595 cvt->len_cvt = dstsize;
3596 if (cvt->filters[++cvt->filter_index]) {
3597 cvt->filters[cvt->filter_index] (cvt, format);
3598 }
3599 }
3600
3601 static void SDLCALL
3602 SDL_Upsample_U16LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3603 {
3604 #if DEBUG_CONVERT
3605 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16LSB, 8 channels.\n", cvt->rate_incr);
3606 #endif
3607
3608 const int srcsize = cvt->len_cvt - 256;
3609 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3610 register int eps = 0;
3611 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8;
3612 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
3613 const Uint16 *target = ((const Uint16 *) cvt->buf);
3614 Uint16 sample7 = SDL_SwapLE16(src[7]);
3615 Uint16 sample6 = SDL_SwapLE16(src[6]);
3616 Uint16 sample5 = SDL_SwapLE16(src[5]);
3617 Uint16 sample4 = SDL_SwapLE16(src[4]);
3618 Uint16 sample3 = SDL_SwapLE16(src[3]);
3619 Uint16 sample2 = SDL_SwapLE16(src[2]);
3620 Uint16 sample1 = SDL_SwapLE16(src[1]);
3621 Uint16 sample0 = SDL_SwapLE16(src[0]);
3622 Uint16 last_sample7 = sample7;
3623 Uint16 last_sample6 = sample6;
3624 Uint16 last_sample5 = sample5;
3625 Uint16 last_sample4 = sample4;
3626 Uint16 last_sample3 = sample3;
3627 Uint16 last_sample2 = sample2;
3628 Uint16 last_sample1 = sample1;
3629 Uint16 last_sample0 = sample0;
3630 while (dst >= target) {
3631 dst[7] = SDL_SwapLE16(sample7);
3632 dst[6] = SDL_SwapLE16(sample6);
3633 dst[5] = SDL_SwapLE16(sample5);
3634 dst[4] = SDL_SwapLE16(sample4);
3635 dst[3] = SDL_SwapLE16(sample3);
3636 dst[2] = SDL_SwapLE16(sample2);
3637 dst[1] = SDL_SwapLE16(sample1);
3638 dst[0] = SDL_SwapLE16(sample0);
3639 dst -= 8;
3640 eps += srcsize;
3641 if ((eps << 1) >= dstsize) {
3642 src -= 8;
3643 sample7 = (Uint16) ((((Sint32) SDL_SwapLE16(src[7])) + ((Sint32) last_sample7)) >> 1);
3644 sample6 = (Uint16) ((((Sint32) SDL_SwapLE16(src[6])) + ((Sint32) last_sample6)) >> 1);
3645 sample5 = (Uint16) ((((Sint32) SDL_SwapLE16(src[5])) + ((Sint32) last_sample5)) >> 1);
3646 sample4 = (Uint16) ((((Sint32) SDL_SwapLE16(src[4])) + ((Sint32) last_sample4)) >> 1);
3647 sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
3648 sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
3649 sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
3650 sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
3651 last_sample7 = sample7;
3652 last_sample6 = sample6;
3653 last_sample5 = sample5;
3654 last_sample4 = sample4;
3655 last_sample3 = sample3;
3656 last_sample2 = sample2;
3657 last_sample1 = sample1;
3658 last_sample0 = sample0;
3659 eps -= dstsize;
3660 }
3661 }
3662 cvt->len_cvt = dstsize;
3663 if (cvt->filters[++cvt->filter_index]) {
3664 cvt->filters[cvt->filter_index] (cvt, format);
3665 }
3666 }
3667
3668 static void SDLCALL
3669 SDL_Downsample_U16LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3670 {
3671 #if DEBUG_CONVERT
3672 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16LSB, 8 channels.\n", cvt->rate_incr);
3673 #endif
3674
3675 const int srcsize = cvt->len_cvt - 256;
3676 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3677 register int eps = 0;
3678 Uint16 *dst = (Uint16 *) cvt->buf;
3679 const Uint16 *src = (Uint16 *) cvt->buf;
3680 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
3681 Uint16 sample0 = SDL_SwapLE16(src[0]);
3682 Uint16 sample1 = SDL_SwapLE16(src[1]);
3683 Uint16 sample2 = SDL_SwapLE16(src[2]);
3684 Uint16 sample3 = SDL_SwapLE16(src[3]);
3685 Uint16 sample4 = SDL_SwapLE16(src[4]);
3686 Uint16 sample5 = SDL_SwapLE16(src[5]);
3687 Uint16 sample6 = SDL_SwapLE16(src[6]);
3688 Uint16 sample7 = SDL_SwapLE16(src[7]);
3689 Uint16 last_sample0 = sample0;
3690 Uint16 last_sample1 = sample1;
3691 Uint16 last_sample2 = sample2;
3692 Uint16 last_sample3 = sample3;
3693 Uint16 last_sample4 = sample4;
3694 Uint16 last_sample5 = sample5;
3695 Uint16 last_sample6 = sample6;
3696 Uint16 last_sample7 = sample7;
3697 while (dst < target) {
3698 src += 8;
3699 eps += dstsize;
3700 if ((eps << 1) >= srcsize) {
3701 dst[0] = SDL_SwapLE16(sample0);
3702 dst[1] = SDL_SwapLE16(sample1);
3703 dst[2] = SDL_SwapLE16(sample2);
3704 dst[3] = SDL_SwapLE16(sample3);
3705 dst[4] = SDL_SwapLE16(sample4);
3706 dst[5] = SDL_SwapLE16(sample5);
3707 dst[6] = SDL_SwapLE16(sample6);
3708 dst[7] = SDL_SwapLE16(sample7);
3709 dst += 8;
3710 sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
3711 sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
3712 sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
3713 sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
3714 sample4 = (Uint16) ((((Sint32) SDL_SwapLE16(src[4])) + ((Sint32) last_sample4)) >> 1);
3715 sample5 = (Uint16) ((((Sint32) SDL_SwapLE16(src[5])) + ((Sint32) last_sample5)) >> 1);
3716 sample6 = (Uint16) ((((Sint32) SDL_SwapLE16(src[6])) + ((Sint32) last_sample6)) >> 1);
3717 sample7 = (Uint16) ((((Sint32) SDL_SwapLE16(src[7])) + ((Sint32) last_sample7)) >> 1);
3718 last_sample0 = sample0;
3719 last_sample1 = sample1;
3720 last_sample2 = sample2;
3721 last_sample3 = sample3;
3722 last_sample4 = sample4;
3723 last_sample5 = sample5;
3724 last_sample6 = sample6;
3725 last_sample7 = sample7;
3726 eps -= srcsize;
3727 }
3728 }
3729 cvt->len_cvt = dstsize;
3730 if (cvt->filters[++cvt->filter_index]) {
3731 cvt->filters[cvt->filter_index] (cvt, format);
3732 }
3733 }
3734
3735 static void SDLCALL
3736 SDL_Upsample_S16LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3737 {
3738 #if DEBUG_CONVERT
3739 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16LSB, 1 channels.\n", cvt->rate_incr);
3740 #endif
3741
3742 const int srcsize = cvt->len_cvt - 32;
3743 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3744 register int eps = 0;
3745 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1;
3746 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
3747 const Sint16 *target = ((const Sint16 *) cvt->buf);
3748 Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
3749 Sint16 last_sample0 = sample0;
3750 while (dst >= target) {
3751 dst[0] = ((Sint16) SDL_SwapLE16(sample0));
3752 dst--;
3753 eps += srcsize;
3754 if ((eps << 1) >= dstsize) {
3755 src--;
3756 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
3757 last_sample0 = sample0;
3758 eps -= dstsize;
3759 }
3760 }
3761 cvt->len_cvt = dstsize;
3762 if (cvt->filters[++cvt->filter_index]) {
3763 cvt->filters[cvt->filter_index] (cvt, format);
3764 }
3765 }
3766
3767 static void SDLCALL
3768 SDL_Downsample_S16LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3769 {
3770 #if DEBUG_CONVERT
3771 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16LSB, 1 channels.\n", cvt->rate_incr);
3772 #endif
3773
3774 const int srcsize = cvt->len_cvt - 32;
3775 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3776 register int eps = 0;
3777 Sint16 *dst = (Sint16 *) cvt->buf;
3778 const Sint16 *src = (Sint16 *) cvt->buf;
3779 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
3780 Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
3781 Sint16 last_sample0 = sample0;
3782 while (dst < target) {
3783 src++;
3784 eps += dstsize;
3785 if ((eps << 1) >= srcsize) {
3786 dst[0] = ((Sint16) SDL_SwapLE16(sample0));
3787 dst++;
3788 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
3789 last_sample0 = sample0;
3790 eps -= srcsize;
3791 }
3792 }
3793 cvt->len_cvt = dstsize;
3794 if (cvt->filters[++cvt->filter_index]) {
3795 cvt->filters[cvt->filter_index] (cvt, format);
3796 }
3797 }
3798
3799 static void SDLCALL
3800 SDL_Upsample_S16LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3801 {
3802 #if DEBUG_CONVERT
3803 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16LSB, 2 channels.\n", cvt->rate_incr);
3804 #endif
3805
3806 const int srcsize = cvt->len_cvt - 64;
3807 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3808 register int eps = 0;
3809 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2;
3810 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
3811 const Sint16 *target = ((const Sint16 *) cvt->buf);
3812 Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
3813 Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
3814 Sint16 last_sample1 = sample1;
3815 Sint16 last_sample0 = sample0;
3816 while (dst >= target) {
3817 dst[1] = ((Sint16) SDL_SwapLE16(sample1));
3818 dst[0] = ((Sint16) SDL_SwapLE16(sample0));
3819 dst -= 2;
3820 eps += srcsize;
3821 if ((eps << 1) >= dstsize) {
3822 src -= 2;
3823 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
3824 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
3825 last_sample1 = sample1;
3826 last_sample0 = sample0;
3827 eps -= dstsize;
3828 }
3829 }
3830 cvt->len_cvt = dstsize;
3831 if (cvt->filters[++cvt->filter_index]) {
3832 cvt->filters[cvt->filter_index] (cvt, format);
3833 }
3834 }
3835
3836 static void SDLCALL
3837 SDL_Downsample_S16LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3838 {
3839 #if DEBUG_CONVERT
3840 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16LSB, 2 channels.\n", cvt->rate_incr);
3841 #endif
3842
3843 const int srcsize = cvt->len_cvt - 64;
3844 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3845 register int eps = 0;
3846 Sint16 *dst = (Sint16 *) cvt->buf;
3847 const Sint16 *src = (Sint16 *) cvt->buf;
3848 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
3849 Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
3850 Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
3851 Sint16 last_sample0 = sample0;
3852 Sint16 last_sample1 = sample1;
3853 while (dst < target) {
3854 src += 2;
3855 eps += dstsize;
3856 if ((eps << 1) >= srcsize) {
3857 dst[0] = ((Sint16) SDL_SwapLE16(sample0));
3858 dst[1] = ((Sint16) SDL_SwapLE16(sample1));
3859 dst += 2;
3860 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
3861 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
3862 last_sample0 = sample0;
3863 last_sample1 = sample1;
3864 eps -= srcsize;
3865 }
3866 }
3867 cvt->len_cvt = dstsize;
3868 if (cvt->filters[++cvt->filter_index]) {
3869 cvt->filters[cvt->filter_index] (cvt, format);
3870 }
3871 }
3872
3873 static void SDLCALL
3874 SDL_Upsample_S16LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3875 {
3876 #if DEBUG_CONVERT
3877 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16LSB, 4 channels.\n", cvt->rate_incr);
3878 #endif
3879
3880 const int srcsize = cvt->len_cvt - 128;
3881 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3882 register int eps = 0;
3883 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4;
3884 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
3885 const Sint16 *target = ((const Sint16 *) cvt->buf);
3886 Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
3887 Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
3888 Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
3889 Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
3890 Sint16 last_sample3 = sample3;
3891 Sint16 last_sample2 = sample2;
3892 Sint16 last_sample1 = sample1;
3893 Sint16 last_sample0 = sample0;
3894 while (dst >= target) {
3895 dst[3] = ((Sint16) SDL_SwapLE16(sample3));
3896 dst[2] = ((Sint16) SDL_SwapLE16(sample2));
3897 dst[1] = ((Sint16) SDL_SwapLE16(sample1));
3898 dst[0] = ((Sint16) SDL_SwapLE16(sample0));
3899 dst -= 4;
3900 eps += srcsize;
3901 if ((eps << 1) >= dstsize) {
3902 src -= 4;
3903 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
3904 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
3905 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
3906 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
3907 last_sample3 = sample3;
3908 last_sample2 = sample2;
3909 last_sample1 = sample1;
3910 last_sample0 = sample0;
3911 eps -= dstsize;
3912 }
3913 }
3914 cvt->len_cvt = dstsize;
3915 if (cvt->filters[++cvt->filter_index]) {
3916 cvt->filters[cvt->filter_index] (cvt, format);
3917 }
3918 }
3919
3920 static void SDLCALL
3921 SDL_Downsample_S16LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3922 {
3923 #if DEBUG_CONVERT
3924 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16LSB, 4 channels.\n", cvt->rate_incr);
3925 #endif
3926
3927 const int srcsize = cvt->len_cvt - 128;
3928 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3929 register int eps = 0;
3930 Sint16 *dst = (Sint16 *) cvt->buf;
3931 const Sint16 *src = (Sint16 *) cvt->buf;
3932 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
3933 Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
3934 Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
3935 Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
3936 Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
3937 Sint16 last_sample0 = sample0;
3938 Sint16 last_sample1 = sample1;
3939 Sint16 last_sample2 = sample2;
3940 Sint16 last_sample3 = sample3;
3941 while (dst < target) {
3942 src += 4;
3943 eps += dstsize;
3944 if ((eps << 1) >= srcsize) {
3945 dst[0] = ((Sint16) SDL_SwapLE16(sample0));
3946 dst[1] = ((Sint16) SDL_SwapLE16(sample1));
3947 dst[2] = ((Sint16) SDL_SwapLE16(sample2));
3948 dst[3] = ((Sint16) SDL_SwapLE16(sample3));
3949 dst += 4;
3950 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
3951 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
3952 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
3953 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
3954 last_sample0 = sample0;
3955 last_sample1 = sample1;
3956 last_sample2 = sample2;
3957 last_sample3 = sample3;
3958 eps -= srcsize;
3959 }
3960 }
3961 cvt->len_cvt = dstsize;
3962 if (cvt->filters[++cvt->filter_index]) {
3963 cvt->filters[cvt->filter_index] (cvt, format);
3964 }
3965 }
3966
3967 static void SDLCALL
3968 SDL_Upsample_S16LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
3969 {
3970 #if DEBUG_CONVERT
3971 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16LSB, 6 channels.\n", cvt->rate_incr);
3972 #endif
3973
3974 const int srcsize = cvt->len_cvt - 192;
3975 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
3976 register int eps = 0;
3977 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6;
3978 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
3979 const Sint16 *target = ((const Sint16 *) cvt->buf);
3980 Sint16 sample5 = ((Sint16) SDL_SwapLE16(src[5]));
3981 Sint16 sample4 = ((Sint16) SDL_SwapLE16(src[4]));
3982 Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
3983 Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
3984 Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
3985 Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
3986 Sint16 last_sample5 = sample5;
3987 Sint16 last_sample4 = sample4;
3988 Sint16 last_sample3 = sample3;
3989 Sint16 last_sample2 = sample2;
3990 Sint16 last_sample1 = sample1;
3991 Sint16 last_sample0 = sample0;
3992 while (dst >= target) {
3993 dst[5] = ((Sint16) SDL_SwapLE16(sample5));
3994 dst[4] = ((Sint16) SDL_SwapLE16(sample4));
3995 dst[3] = ((Sint16) SDL_SwapLE16(sample3));
3996 dst[2] = ((Sint16) SDL_SwapLE16(sample2));
3997 dst[1] = ((Sint16) SDL_SwapLE16(sample1));
3998 dst[0] = ((Sint16) SDL_SwapLE16(sample0));
3999 dst -= 6;
4000 eps += srcsize;
4001 if ((eps << 1) >= dstsize) {
4002 src -= 6;
4003 sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
4004 sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
4005 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
4006 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
4007 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
4008 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
4009 last_sample5 = sample5;
4010 last_sample4 = sample4;
4011 last_sample3 = sample3;
4012 last_sample2 = sample2;
4013 last_sample1 = sample1;
4014 last_sample0 = sample0;
4015 eps -= dstsize;
4016 }
4017 }
4018 cvt->len_cvt = dstsize;
4019 if (cvt->filters[++cvt->filter_index]) {
4020 cvt->filters[cvt->filter_index] (cvt, format);
4021 }
4022 }
4023
4024 static void SDLCALL
4025 SDL_Downsample_S16LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4026 {
4027 #if DEBUG_CONVERT
4028 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16LSB, 6 channels.\n", cvt->rate_incr);
4029 #endif
4030
4031 const int srcsize = cvt->len_cvt - 192;
4032 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4033 register int eps = 0;
4034 Sint16 *dst = (Sint16 *) cvt->buf;
4035 const Sint16 *src = (Sint16 *) cvt->buf;
4036 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
4037 Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
4038 Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
4039 Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
4040 Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
4041 Sint16 sample4 = ((Sint16) SDL_SwapLE16(src[4]));
4042 Sint16 sample5 = ((Sint16) SDL_SwapLE16(src[5]));
4043 Sint16 last_sample0 = sample0;
4044 Sint16 last_sample1 = sample1;
4045 Sint16 last_sample2 = sample2;
4046 Sint16 last_sample3 = sample3;
4047 Sint16 last_sample4 = sample4;
4048 Sint16 last_sample5 = sample5;
4049 while (dst < target) {
4050 src += 6;
4051 eps += dstsize;
4052 if ((eps << 1) >= srcsize) {
4053 dst[0] = ((Sint16) SDL_SwapLE16(sample0));
4054 dst[1] = ((Sint16) SDL_SwapLE16(sample1));
4055 dst[2] = ((Sint16) SDL_SwapLE16(sample2));
4056 dst[3] = ((Sint16) SDL_SwapLE16(sample3));
4057 dst[4] = ((Sint16) SDL_SwapLE16(sample4));
4058 dst[5] = ((Sint16) SDL_SwapLE16(sample5));
4059 dst += 6;
4060 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
4061 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
4062 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
4063 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
4064 sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
4065 sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
4066 last_sample0 = sample0;
4067 last_sample1 = sample1;
4068 last_sample2 = sample2;
4069 last_sample3 = sample3;
4070 last_sample4 = sample4;
4071 last_sample5 = sample5;
4072 eps -= srcsize;
4073 }
4074 }
4075 cvt->len_cvt = dstsize;
4076 if (cvt->filters[++cvt->filter_index]) {
4077 cvt->filters[cvt->filter_index] (cvt, format);
4078 }
4079 }
4080
4081 static void SDLCALL
4082 SDL_Upsample_S16LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4083 {
4084 #if DEBUG_CONVERT
4085 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16LSB, 8 channels.\n", cvt->rate_incr);
4086 #endif
4087
4088 const int srcsize = cvt->len_cvt - 256;
4089 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4090 register int eps = 0;
4091 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8;
4092 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
4093 const Sint16 *target = ((const Sint16 *) cvt->buf);
4094 Sint16 sample7 = ((Sint16) SDL_SwapLE16(src[7]));
4095 Sint16 sample6 = ((Sint16) SDL_SwapLE16(src[6]));
4096 Sint16 sample5 = ((Sint16) SDL_SwapLE16(src[5]));
4097 Sint16 sample4 = ((Sint16) SDL_SwapLE16(src[4]));
4098 Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
4099 Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
4100 Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
4101 Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
4102 Sint16 last_sample7 = sample7;
4103 Sint16 last_sample6 = sample6;
4104 Sint16 last_sample5 = sample5;
4105 Sint16 last_sample4 = sample4;
4106 Sint16 last_sample3 = sample3;
4107 Sint16 last_sample2 = sample2;
4108 Sint16 last_sample1 = sample1;
4109 Sint16 last_sample0 = sample0;
4110 while (dst >= target) {
4111 dst[7] = ((Sint16) SDL_SwapLE16(sample7));
4112 dst[6] = ((Sint16) SDL_SwapLE16(sample6));
4113 dst[5] = ((Sint16) SDL_SwapLE16(sample5));
4114 dst[4] = ((Sint16) SDL_SwapLE16(sample4));
4115 dst[3] = ((Sint16) SDL_SwapLE16(sample3));
4116 dst[2] = ((Sint16) SDL_SwapLE16(sample2));
4117 dst[1] = ((Sint16) SDL_SwapLE16(sample1));
4118 dst[0] = ((Sint16) SDL_SwapLE16(sample0));
4119 dst -= 8;
4120 eps += srcsize;
4121 if ((eps << 1) >= dstsize) {
4122 src -= 8;
4123 sample7 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[7]))) + ((Sint32) last_sample7)) >> 1);
4124 sample6 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[6]))) + ((Sint32) last_sample6)) >> 1);
4125 sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
4126 sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
4127 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
4128 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
4129 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
4130 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
4131 last_sample7 = sample7;
4132 last_sample6 = sample6;
4133 last_sample5 = sample5;
4134 last_sample4 = sample4;
4135 last_sample3 = sample3;
4136 last_sample2 = sample2;
4137 last_sample1 = sample1;
4138 last_sample0 = sample0;
4139 eps -= dstsize;
4140 }
4141 }
4142 cvt->len_cvt = dstsize;
4143 if (cvt->filters[++cvt->filter_index]) {
4144 cvt->filters[cvt->filter_index] (cvt, format);
4145 }
4146 }
4147
4148 static void SDLCALL
4149 SDL_Downsample_S16LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4150 {
4151 #if DEBUG_CONVERT
4152 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16LSB, 8 channels.\n", cvt->rate_incr);
4153 #endif
4154
4155 const int srcsize = cvt->len_cvt - 256;
4156 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4157 register int eps = 0;
4158 Sint16 *dst = (Sint16 *) cvt->buf;
4159 const Sint16 *src = (Sint16 *) cvt->buf;
4160 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
4161 Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
4162 Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
4163 Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
4164 Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
4165 Sint16 sample4 = ((Sint16) SDL_SwapLE16(src[4]));
4166 Sint16 sample5 = ((Sint16) SDL_SwapLE16(src[5]));
4167 Sint16 sample6 = ((Sint16) SDL_SwapLE16(src[6]));
4168 Sint16 sample7 = ((Sint16) SDL_SwapLE16(src[7]));
4169 Sint16 last_sample0 = sample0;
4170 Sint16 last_sample1 = sample1;
4171 Sint16 last_sample2 = sample2;
4172 Sint16 last_sample3 = sample3;
4173 Sint16 last_sample4 = sample4;
4174 Sint16 last_sample5 = sample5;
4175 Sint16 last_sample6 = sample6;
4176 Sint16 last_sample7 = sample7;
4177 while (dst < target) {
4178 src += 8;
4179 eps += dstsize;
4180 if ((eps << 1) >= srcsize) {
4181 dst[0] = ((Sint16) SDL_SwapLE16(sample0));
4182 dst[1] = ((Sint16) SDL_SwapLE16(sample1));
4183 dst[2] = ((Sint16) SDL_SwapLE16(sample2));
4184 dst[3] = ((Sint16) SDL_SwapLE16(sample3));
4185 dst[4] = ((Sint16) SDL_SwapLE16(sample4));
4186 dst[5] = ((Sint16) SDL_SwapLE16(sample5));
4187 dst[6] = ((Sint16) SDL_SwapLE16(sample6));
4188 dst[7] = ((Sint16) SDL_SwapLE16(sample7));
4189 dst += 8;
4190 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
4191 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
4192 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
4193 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
4194 sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
4195 sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
4196 sample6 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[6]))) + ((Sint32) last_sample6)) >> 1);
4197 sample7 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[7]))) + ((Sint32) last_sample7)) >> 1);
4198 last_sample0 = sample0;
4199 last_sample1 = sample1;
4200 last_sample2 = sample2;
4201 last_sample3 = sample3;
4202 last_sample4 = sample4;
4203 last_sample5 = sample5;
4204 last_sample6 = sample6;
4205 last_sample7 = sample7;
4206 eps -= srcsize;
4207 }
4208 }
4209 cvt->len_cvt = dstsize;
4210 if (cvt->filters[++cvt->filter_index]) {
4211 cvt->filters[cvt->filter_index] (cvt, format);
4212 }
4213 }
4214
4215 static void SDLCALL
4216 SDL_Upsample_U16MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4217 {
4218 #if DEBUG_CONVERT
4219 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16MSB, 1 channels.\n", cvt->rate_incr);
4220 #endif
4221
4222 const int srcsize = cvt->len_cvt - 32;
4223 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4224 register int eps = 0;
4225 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1;
4226 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
4227 const Uint16 *target = ((const Uint16 *) cvt->buf);
4228 Uint16 sample0 = SDL_SwapBE16(src[0]);
4229 Uint16 last_sample0 = sample0;
4230 while (dst >= target) {
4231 dst[0] = SDL_SwapBE16(sample0);
4232 dst--;
4233 eps += srcsize;
4234 if ((eps << 1) >= dstsize) {
4235 src--;
4236 sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
4237 last_sample0 = sample0;
4238 eps -= dstsize;
4239 }
4240 }
4241 cvt->len_cvt = dstsize;
4242 if (cvt->filters[++cvt->filter_index]) {
4243 cvt->filters[cvt->filter_index] (cvt, format);
4244 }
4245 }
4246
4247 static void SDLCALL
4248 SDL_Downsample_U16MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4249 {
4250 #if DEBUG_CONVERT
4251 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16MSB, 1 channels.\n", cvt->rate_incr);
4252 #endif
4253
4254 const int srcsize = cvt->len_cvt - 32;
4255 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4256 register int eps = 0;
4257 Uint16 *dst = (Uint16 *) cvt->buf;
4258 const Uint16 *src = (Uint16 *) cvt->buf;
4259 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
4260 Uint16 sample0 = SDL_SwapBE16(src[0]);
4261 Uint16 last_sample0 = sample0;
4262 while (dst < target) {
4263 src++;
4264 eps += dstsize;
4265 if ((eps << 1) >= srcsize) {
4266 dst[0] = SDL_SwapBE16(sample0);
4267 dst++;
4268 sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
4269 last_sample0 = sample0;
4270 eps -= srcsize;
4271 }
4272 }
4273 cvt->len_cvt = dstsize;
4274 if (cvt->filters[++cvt->filter_index]) {
4275 cvt->filters[cvt->filter_index] (cvt, format);
4276 }
4277 }
4278
4279 static void SDLCALL
4280 SDL_Upsample_U16MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4281 {
4282 #if DEBUG_CONVERT
4283 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16MSB, 2 channels.\n", cvt->rate_incr);
4284 #endif
4285
4286 const int srcsize = cvt->len_cvt - 64;
4287 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4288 register int eps = 0;
4289 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2;
4290 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
4291 const Uint16 *target = ((const Uint16 *) cvt->buf);
4292 Uint16 sample1 = SDL_SwapBE16(src[1]);
4293 Uint16 sample0 = SDL_SwapBE16(src[0]);
4294 Uint16 last_sample1 = sample1;
4295 Uint16 last_sample0 = sample0;
4296 while (dst >= target) {
4297 dst[1] = SDL_SwapBE16(sample1);
4298 dst[0] = SDL_SwapBE16(sample0);
4299 dst -= 2;
4300 eps += srcsize;
4301 if ((eps << 1) >= dstsize) {
4302 src -= 2;
4303 sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
4304 sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
4305 last_sample1 = sample1;
4306 last_sample0 = sample0;
4307 eps -= dstsize;
4308 }
4309 }
4310 cvt->len_cvt = dstsize;
4311 if (cvt->filters[++cvt->filter_index]) {
4312 cvt->filters[cvt->filter_index] (cvt, format);
4313 }
4314 }
4315
4316 static void SDLCALL
4317 SDL_Downsample_U16MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4318 {
4319 #if DEBUG_CONVERT
4320 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16MSB, 2 channels.\n", cvt->rate_incr);
4321 #endif
4322
4323 const int srcsize = cvt->len_cvt - 64;
4324 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4325 register int eps = 0;
4326 Uint16 *dst = (Uint16 *) cvt->buf;
4327 const Uint16 *src = (Uint16 *) cvt->buf;
4328 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
4329 Uint16 sample0 = SDL_SwapBE16(src[0]);
4330 Uint16 sample1 = SDL_SwapBE16(src[1]);
4331 Uint16 last_sample0 = sample0;
4332 Uint16 last_sample1 = sample1;
4333 while (dst < target) {
4334 src += 2;
4335 eps += dstsize;
4336 if ((eps << 1) >= srcsize) {
4337 dst[0] = SDL_SwapBE16(sample0);
4338 dst[1] = SDL_SwapBE16(sample1);
4339 dst += 2;
4340 sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
4341 sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
4342 last_sample0 = sample0;
4343 last_sample1 = sample1;
4344 eps -= srcsize;
4345 }
4346 }
4347 cvt->len_cvt = dstsize;
4348 if (cvt->filters[++cvt->filter_index]) {
4349 cvt->filters[cvt->filter_index] (cvt, format);
4350 }
4351 }
4352
4353 static void SDLCALL
4354 SDL_Upsample_U16MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4355 {
4356 #if DEBUG_CONVERT
4357 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16MSB, 4 channels.\n", cvt->rate_incr);
4358 #endif
4359
4360 const int srcsize = cvt->len_cvt - 128;
4361 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4362 register int eps = 0;
4363 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4;
4364 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
4365 const Uint16 *target = ((const Uint16 *) cvt->buf);
4366 Uint16 sample3 = SDL_SwapBE16(src[3]);
4367 Uint16 sample2 = SDL_SwapBE16(src[2]);
4368 Uint16 sample1 = SDL_SwapBE16(src[1]);
4369 Uint16 sample0 = SDL_SwapBE16(src[0]);
4370 Uint16 last_sample3 = sample3;
4371 Uint16 last_sample2 = sample2;
4372 Uint16 last_sample1 = sample1;
4373 Uint16 last_sample0 = sample0;
4374 while (dst >= target) {
4375 dst[3] = SDL_SwapBE16(sample3);
4376 dst[2] = SDL_SwapBE16(sample2);
4377 dst[1] = SDL_SwapBE16(sample1);
4378 dst[0] = SDL_SwapBE16(sample0);
4379 dst -= 4;
4380 eps += srcsize;
4381 if ((eps << 1) >= dstsize) {
4382 src -= 4;
4383 sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
4384 sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
4385 sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
4386 sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
4387 last_sample3 = sample3;
4388 last_sample2 = sample2;
4389 last_sample1 = sample1;
4390 last_sample0 = sample0;
4391 eps -= dstsize;
4392 }
4393 }
4394 cvt->len_cvt = dstsize;
4395 if (cvt->filters[++cvt->filter_index]) {
4396 cvt->filters[cvt->filter_index] (cvt, format);
4397 }
4398 }
4399
4400 static void SDLCALL
4401 SDL_Downsample_U16MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4402 {
4403 #if DEBUG_CONVERT
4404 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16MSB, 4 channels.\n", cvt->rate_incr);
4405 #endif
4406
4407 const int srcsize = cvt->len_cvt - 128;
4408 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4409 register int eps = 0;
4410 Uint16 *dst = (Uint16 *) cvt->buf;
4411 const Uint16 *src = (Uint16 *) cvt->buf;
4412 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
4413 Uint16 sample0 = SDL_SwapBE16(src[0]);
4414 Uint16 sample1 = SDL_SwapBE16(src[1]);
4415 Uint16 sample2 = SDL_SwapBE16(src[2]);
4416 Uint16 sample3 = SDL_SwapBE16(src[3]);
4417 Uint16 last_sample0 = sample0;
4418 Uint16 last_sample1 = sample1;
4419 Uint16 last_sample2 = sample2;
4420 Uint16 last_sample3 = sample3;
4421 while (dst < target) {
4422 src += 4;
4423 eps += dstsize;
4424 if ((eps << 1) >= srcsize) {
4425 dst[0] = SDL_SwapBE16(sample0);
4426 dst[1] = SDL_SwapBE16(sample1);
4427 dst[2] = SDL_SwapBE16(sample2);
4428 dst[3] = SDL_SwapBE16(sample3);
4429 dst += 4;
4430 sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
4431 sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
4432 sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
4433 sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
4434 last_sample0 = sample0;
4435 last_sample1 = sample1;
4436 last_sample2 = sample2;
4437 last_sample3 = sample3;
4438 eps -= srcsize;
4439 }
4440 }
4441 cvt->len_cvt = dstsize;
4442 if (cvt->filters[++cvt->filter_index]) {
4443 cvt->filters[cvt->filter_index] (cvt, format);
4444 }
4445 }
4446
4447 static void SDLCALL
4448 SDL_Upsample_U16MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4449 {
4450 #if DEBUG_CONVERT
4451 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16MSB, 6 channels.\n", cvt->rate_incr);
4452 #endif
4453
4454 const int srcsize = cvt->len_cvt - 192;
4455 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4456 register int eps = 0;
4457 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6;
4458 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
4459 const Uint16 *target = ((const Uint16 *) cvt->buf);
4460 Uint16 sample5 = SDL_SwapBE16(src[5]);
4461 Uint16 sample4 = SDL_SwapBE16(src[4]);
4462 Uint16 sample3 = SDL_SwapBE16(src[3]);
4463 Uint16 sample2 = SDL_SwapBE16(src[2]);
4464 Uint16 sample1 = SDL_SwapBE16(src[1]);
4465 Uint16 sample0 = SDL_SwapBE16(src[0]);
4466 Uint16 last_sample5 = sample5;
4467 Uint16 last_sample4 = sample4;
4468 Uint16 last_sample3 = sample3;
4469 Uint16 last_sample2 = sample2;
4470 Uint16 last_sample1 = sample1;
4471 Uint16 last_sample0 = sample0;
4472 while (dst >= target) {
4473 dst[5] = SDL_SwapBE16(sample5);
4474 dst[4] = SDL_SwapBE16(sample4);
4475 dst[3] = SDL_SwapBE16(sample3);
4476 dst[2] = SDL_SwapBE16(sample2);
4477 dst[1] = SDL_SwapBE16(sample1);
4478 dst[0] = SDL_SwapBE16(sample0);
4479 dst -= 6;
4480 eps += srcsize;
4481 if ((eps << 1) >= dstsize) {
4482 src -= 6;
4483 sample5 = (Uint16) ((((Sint32) SDL_SwapBE16(src[5])) + ((Sint32) last_sample5)) >> 1);
4484 sample4 = (Uint16) ((((Sint32) SDL_SwapBE16(src[4])) + ((Sint32) last_sample4)) >> 1);
4485 sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
4486 sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
4487 sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
4488 sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
4489 last_sample5 = sample5;
4490 last_sample4 = sample4;
4491 last_sample3 = sample3;
4492 last_sample2 = sample2;
4493 last_sample1 = sample1;
4494 last_sample0 = sample0;
4495 eps -= dstsize;
4496 }
4497 }
4498 cvt->len_cvt = dstsize;
4499 if (cvt->filters[++cvt->filter_index]) {
4500 cvt->filters[cvt->filter_index] (cvt, format);
4501 }
4502 }
4503
4504 static void SDLCALL
4505 SDL_Downsample_U16MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4506 {
4507 #if DEBUG_CONVERT
4508 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16MSB, 6 channels.\n", cvt->rate_incr);
4509 #endif
4510
4511 const int srcsize = cvt->len_cvt - 192;
4512 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4513 register int eps = 0;
4514 Uint16 *dst = (Uint16 *) cvt->buf;
4515 const Uint16 *src = (Uint16 *) cvt->buf;
4516 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
4517 Uint16 sample0 = SDL_SwapBE16(src[0]);
4518 Uint16 sample1 = SDL_SwapBE16(src[1]);
4519 Uint16 sample2 = SDL_SwapBE16(src[2]);
4520 Uint16 sample3 = SDL_SwapBE16(src[3]);
4521 Uint16 sample4 = SDL_SwapBE16(src[4]);
4522 Uint16 sample5 = SDL_SwapBE16(src[5]);
4523 Uint16 last_sample0 = sample0;
4524 Uint16 last_sample1 = sample1;
4525 Uint16 last_sample2 = sample2;
4526 Uint16 last_sample3 = sample3;
4527 Uint16 last_sample4 = sample4;
4528 Uint16 last_sample5 = sample5;
4529 while (dst < target) {
4530 src += 6;
4531 eps += dstsize;
4532 if ((eps << 1) >= srcsize) {
4533 dst[0] = SDL_SwapBE16(sample0);
4534 dst[1] = SDL_SwapBE16(sample1);
4535 dst[2] = SDL_SwapBE16(sample2);
4536 dst[3] = SDL_SwapBE16(sample3);
4537 dst[4] = SDL_SwapBE16(sample4);
4538 dst[5] = SDL_SwapBE16(sample5);
4539 dst += 6;
4540 sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
4541 sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
4542 sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
4543 sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
4544 sample4 = (Uint16) ((((Sint32) SDL_SwapBE16(src[4])) + ((Sint32) last_sample4)) >> 1);
4545 sample5 = (Uint16) ((((Sint32) SDL_SwapBE16(src[5])) + ((Sint32) last_sample5)) >> 1);
4546 last_sample0 = sample0;
4547 last_sample1 = sample1;
4548 last_sample2 = sample2;
4549 last_sample3 = sample3;
4550 last_sample4 = sample4;
4551 last_sample5 = sample5;
4552 eps -= srcsize;
4553 }
4554 }
4555 cvt->len_cvt = dstsize;
4556 if (cvt->filters[++cvt->filter_index]) {
4557 cvt->filters[cvt->filter_index] (cvt, format);
4558 }
4559 }
4560
4561 static void SDLCALL
4562 SDL_Upsample_U16MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4563 {
4564 #if DEBUG_CONVERT
4565 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16MSB, 8 channels.\n", cvt->rate_incr);
4566 #endif
4567
4568 const int srcsize = cvt->len_cvt - 256;
4569 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4570 register int eps = 0;
4571 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8;
4572 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
4573 const Uint16 *target = ((const Uint16 *) cvt->buf);
4574 Uint16 sample7 = SDL_SwapBE16(src[7]);
4575 Uint16 sample6 = SDL_SwapBE16(src[6]);
4576 Uint16 sample5 = SDL_SwapBE16(src[5]);
4577 Uint16 sample4 = SDL_SwapBE16(src[4]);
4578 Uint16 sample3 = SDL_SwapBE16(src[3]);
4579 Uint16 sample2 = SDL_SwapBE16(src[2]);
4580 Uint16 sample1 = SDL_SwapBE16(src[1]);
4581 Uint16 sample0 = SDL_SwapBE16(src[0]);
4582 Uint16 last_sample7 = sample7;
4583 Uint16 last_sample6 = sample6;
4584 Uint16 last_sample5 = sample5;
4585 Uint16 last_sample4 = sample4;
4586 Uint16 last_sample3 = sample3;
4587 Uint16 last_sample2 = sample2;
4588 Uint16 last_sample1 = sample1;
4589 Uint16 last_sample0 = sample0;
4590 while (dst >= target) {
4591 dst[7] = SDL_SwapBE16(sample7);
4592 dst[6] = SDL_SwapBE16(sample6);
4593 dst[5] = SDL_SwapBE16(sample5);
4594 dst[4] = SDL_SwapBE16(sample4);
4595 dst[3] = SDL_SwapBE16(sample3);
4596 dst[2] = SDL_SwapBE16(sample2);
4597 dst[1] = SDL_SwapBE16(sample1);
4598 dst[0] = SDL_SwapBE16(sample0);
4599 dst -= 8;
4600 eps += srcsize;
4601 if ((eps << 1) >= dstsize) {
4602 src -= 8;
4603 sample7 = (Uint16) ((((Sint32) SDL_SwapBE16(src[7])) + ((Sint32) last_sample7)) >> 1);
4604 sample6 = (Uint16) ((((Sint32) SDL_SwapBE16(src[6])) + ((Sint32) last_sample6)) >> 1);
4605 sample5 = (Uint16) ((((Sint32) SDL_SwapBE16(src[5])) + ((Sint32) last_sample5)) >> 1);
4606 sample4 = (Uint16) ((((Sint32) SDL_SwapBE16(src[4])) + ((Sint32) last_sample4)) >> 1);
4607 sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
4608 sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
4609 sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
4610 sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
4611 last_sample7 = sample7;
4612 last_sample6 = sample6;
4613 last_sample5 = sample5;
4614 last_sample4 = sample4;
4615 last_sample3 = sample3;
4616 last_sample2 = sample2;
4617 last_sample1 = sample1;
4618 last_sample0 = sample0;
4619 eps -= dstsize;
4620 }
4621 }
4622 cvt->len_cvt = dstsize;
4623 if (cvt->filters[++cvt->filter_index]) {
4624 cvt->filters[cvt->filter_index] (cvt, format);
4625 }
4626 }
4627
4628 static void SDLCALL
4629 SDL_Downsample_U16MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4630 {
4631 #if DEBUG_CONVERT
4632 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16MSB, 8 channels.\n", cvt->rate_incr);
4633 #endif
4634
4635 const int srcsize = cvt->len_cvt - 256;
4636 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4637 register int eps = 0;
4638 Uint16 *dst = (Uint16 *) cvt->buf;
4639 const Uint16 *src = (Uint16 *) cvt->buf;
4640 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
4641 Uint16 sample0 = SDL_SwapBE16(src[0]);
4642 Uint16 sample1 = SDL_SwapBE16(src[1]);
4643 Uint16 sample2 = SDL_SwapBE16(src[2]);
4644 Uint16 sample3 = SDL_SwapBE16(src[3]);
4645 Uint16 sample4 = SDL_SwapBE16(src[4]);
4646 Uint16 sample5 = SDL_SwapBE16(src[5]);
4647 Uint16 sample6 = SDL_SwapBE16(src[6]);
4648 Uint16 sample7 = SDL_SwapBE16(src[7]);
4649 Uint16 last_sample0 = sample0;
4650 Uint16 last_sample1 = sample1;
4651 Uint16 last_sample2 = sample2;
4652 Uint16 last_sample3 = sample3;
4653 Uint16 last_sample4 = sample4;
4654 Uint16 last_sample5 = sample5;
4655 Uint16 last_sample6 = sample6;
4656 Uint16 last_sample7 = sample7;
4657 while (dst < target) {
4658 src += 8;
4659 eps += dstsize;
4660 if ((eps << 1) >= srcsize) {
4661 dst[0] = SDL_SwapBE16(sample0);
4662 dst[1] = SDL_SwapBE16(sample1);
4663 dst[2] = SDL_SwapBE16(sample2);
4664 dst[3] = SDL_SwapBE16(sample3);
4665 dst[4] = SDL_SwapBE16(sample4);
4666 dst[5] = SDL_SwapBE16(sample5);
4667 dst[6] = SDL_SwapBE16(sample6);
4668 dst[7] = SDL_SwapBE16(sample7);
4669 dst += 8;
4670 sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
4671 sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
4672 sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
4673 sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
4674 sample4 = (Uint16) ((((Sint32) SDL_SwapBE16(src[4])) + ((Sint32) last_sample4)) >> 1);
4675 sample5 = (Uint16) ((((Sint32) SDL_SwapBE16(src[5])) + ((Sint32) last_sample5)) >> 1);
4676 sample6 = (Uint16) ((((Sint32) SDL_SwapBE16(src[6])) + ((Sint32) last_sample6)) >> 1);
4677 sample7 = (Uint16) ((((Sint32) SDL_SwapBE16(src[7])) + ((Sint32) last_sample7)) >> 1);
4678 last_sample0 = sample0;
4679 last_sample1 = sample1;
4680 last_sample2 = sample2;
4681 last_sample3 = sample3;
4682 last_sample4 = sample4;
4683 last_sample5 = sample5;
4684 last_sample6 = sample6;
4685 last_sample7 = sample7;
4686 eps -= srcsize;
4687 }
4688 }
4689 cvt->len_cvt = dstsize;
4690 if (cvt->filters[++cvt->filter_index]) {
4691 cvt->filters[cvt->filter_index] (cvt, format);
4692 }
4693 }
4694
4695 static void SDLCALL
4696 SDL_Upsample_S16MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4697 {
4698 #if DEBUG_CONVERT
4699 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16MSB, 1 channels.\n", cvt->rate_incr);
4700 #endif
4701
4702 const int srcsize = cvt->len_cvt - 32;
4703 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4704 register int eps = 0;
4705 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1;
4706 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
4707 const Sint16 *target = ((const Sint16 *) cvt->buf);
4708 Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
4709 Sint16 last_sample0 = sample0;
4710 while (dst >= target) {
4711 dst[0] = ((Sint16) SDL_SwapBE16(sample0));
4712 dst--;
4713 eps += srcsize;
4714 if ((eps << 1) >= dstsize) {
4715 src--;
4716 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
4717 last_sample0 = sample0;
4718 eps -= dstsize;
4719 }
4720 }
4721 cvt->len_cvt = dstsize;
4722 if (cvt->filters[++cvt->filter_index]) {
4723 cvt->filters[cvt->filter_index] (cvt, format);
4724 }
4725 }
4726
4727 static void SDLCALL
4728 SDL_Downsample_S16MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4729 {
4730 #if DEBUG_CONVERT
4731 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16MSB, 1 channels.\n", cvt->rate_incr);
4732 #endif
4733
4734 const int srcsize = cvt->len_cvt - 32;
4735 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4736 register int eps = 0;
4737 Sint16 *dst = (Sint16 *) cvt->buf;
4738 const Sint16 *src = (Sint16 *) cvt->buf;
4739 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
4740 Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
4741 Sint16 last_sample0 = sample0;
4742 while (dst < target) {
4743 src++;
4744 eps += dstsize;
4745 if ((eps << 1) >= srcsize) {
4746 dst[0] = ((Sint16) SDL_SwapBE16(sample0));
4747 dst++;
4748 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
4749 last_sample0 = sample0;
4750 eps -= srcsize;
4751 }
4752 }
4753 cvt->len_cvt = dstsize;
4754 if (cvt->filters[++cvt->filter_index]) {
4755 cvt->filters[cvt->filter_index] (cvt, format);
4756 }
4757 }
4758
4759 static void SDLCALL
4760 SDL_Upsample_S16MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4761 {
4762 #if DEBUG_CONVERT
4763 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16MSB, 2 channels.\n", cvt->rate_incr);
4764 #endif
4765
4766 const int srcsize = cvt->len_cvt - 64;
4767 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4768 register int eps = 0;
4769 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2;
4770 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
4771 const Sint16 *target = ((const Sint16 *) cvt->buf);
4772 Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
4773 Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
4774 Sint16 last_sample1 = sample1;
4775 Sint16 last_sample0 = sample0;
4776 while (dst >= target) {
4777 dst[1] = ((Sint16) SDL_SwapBE16(sample1));
4778 dst[0] = ((Sint16) SDL_SwapBE16(sample0));
4779 dst -= 2;
4780 eps += srcsize;
4781 if ((eps << 1) >= dstsize) {
4782 src -= 2;
4783 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
4784 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
4785 last_sample1 = sample1;
4786 last_sample0 = sample0;
4787 eps -= dstsize;
4788 }
4789 }
4790 cvt->len_cvt = dstsize;
4791 if (cvt->filters[++cvt->filter_index]) {
4792 cvt->filters[cvt->filter_index] (cvt, format);
4793 }
4794 }
4795
4796 static void SDLCALL
4797 SDL_Downsample_S16MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4798 {
4799 #if DEBUG_CONVERT
4800 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16MSB, 2 channels.\n", cvt->rate_incr);
4801 #endif
4802
4803 const int srcsize = cvt->len_cvt - 64;
4804 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4805 register int eps = 0;
4806 Sint16 *dst = (Sint16 *) cvt->buf;
4807 const Sint16 *src = (Sint16 *) cvt->buf;
4808 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
4809 Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
4810 Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
4811 Sint16 last_sample0 = sample0;
4812 Sint16 last_sample1 = sample1;
4813 while (dst < target) {
4814 src += 2;
4815 eps += dstsize;
4816 if ((eps << 1) >= srcsize) {
4817 dst[0] = ((Sint16) SDL_SwapBE16(sample0));
4818 dst[1] = ((Sint16) SDL_SwapBE16(sample1));
4819 dst += 2;
4820 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
4821 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
4822 last_sample0 = sample0;
4823 last_sample1 = sample1;
4824 eps -= srcsize;
4825 }
4826 }
4827 cvt->len_cvt = dstsize;
4828 if (cvt->filters[++cvt->filter_index]) {
4829 cvt->filters[cvt->filter_index] (cvt, format);
4830 }
4831 }
4832
4833 static void SDLCALL
4834 SDL_Upsample_S16MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4835 {
4836 #if DEBUG_CONVERT
4837 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16MSB, 4 channels.\n", cvt->rate_incr);
4838 #endif
4839
4840 const int srcsize = cvt->len_cvt - 128;
4841 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4842 register int eps = 0;
4843 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4;
4844 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
4845 const Sint16 *target = ((const Sint16 *) cvt->buf);
4846 Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
4847 Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
4848 Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
4849 Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
4850 Sint16 last_sample3 = sample3;
4851 Sint16 last_sample2 = sample2;
4852 Sint16 last_sample1 = sample1;
4853 Sint16 last_sample0 = sample0;
4854 while (dst >= target) {
4855 dst[3] = ((Sint16) SDL_SwapBE16(sample3));
4856 dst[2] = ((Sint16) SDL_SwapBE16(sample2));
4857 dst[1] = ((Sint16) SDL_SwapBE16(sample1));
4858 dst[0] = ((Sint16) SDL_SwapBE16(sample0));
4859 dst -= 4;
4860 eps += srcsize;
4861 if ((eps << 1) >= dstsize) {
4862 src -= 4;
4863 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
4864 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
4865 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
4866 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
4867 last_sample3 = sample3;
4868 last_sample2 = sample2;
4869 last_sample1 = sample1;
4870 last_sample0 = sample0;
4871 eps -= dstsize;
4872 }
4873 }
4874 cvt->len_cvt = dstsize;
4875 if (cvt->filters[++cvt->filter_index]) {
4876 cvt->filters[cvt->filter_index] (cvt, format);
4877 }
4878 }
4879
4880 static void SDLCALL
4881 SDL_Downsample_S16MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4882 {
4883 #if DEBUG_CONVERT
4884 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16MSB, 4 channels.\n", cvt->rate_incr);
4885 #endif
4886
4887 const int srcsize = cvt->len_cvt - 128;
4888 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4889 register int eps = 0;
4890 Sint16 *dst = (Sint16 *) cvt->buf;
4891 const Sint16 *src = (Sint16 *) cvt->buf;
4892 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
4893 Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
4894 Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
4895 Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
4896 Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
4897 Sint16 last_sample0 = sample0;
4898 Sint16 last_sample1 = sample1;
4899 Sint16 last_sample2 = sample2;
4900 Sint16 last_sample3 = sample3;
4901 while (dst < target) {
4902 src += 4;
4903 eps += dstsize;
4904 if ((eps << 1) >= srcsize) {
4905 dst[0] = ((Sint16) SDL_SwapBE16(sample0));
4906 dst[1] = ((Sint16) SDL_SwapBE16(sample1));
4907 dst[2] = ((Sint16) SDL_SwapBE16(sample2));
4908 dst[3] = ((Sint16) SDL_SwapBE16(sample3));
4909 dst += 4;
4910 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
4911 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
4912 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
4913 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
4914 last_sample0 = sample0;
4915 last_sample1 = sample1;
4916 last_sample2 = sample2;
4917 last_sample3 = sample3;
4918 eps -= srcsize;
4919 }
4920 }
4921 cvt->len_cvt = dstsize;
4922 if (cvt->filters[++cvt->filter_index]) {
4923 cvt->filters[cvt->filter_index] (cvt, format);
4924 }
4925 }
4926
4927 static void SDLCALL
4928 SDL_Upsample_S16MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4929 {
4930 #if DEBUG_CONVERT
4931 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16MSB, 6 channels.\n", cvt->rate_incr);
4932 #endif
4933
4934 const int srcsize = cvt->len_cvt - 192;
4935 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4936 register int eps = 0;
4937 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6;
4938 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
4939 const Sint16 *target = ((const Sint16 *) cvt->buf);
4940 Sint16 sample5 = ((Sint16) SDL_SwapBE16(src[5]));
4941 Sint16 sample4 = ((Sint16) SDL_SwapBE16(src[4]));
4942 Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
4943 Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
4944 Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
4945 Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
4946 Sint16 last_sample5 = sample5;
4947 Sint16 last_sample4 = sample4;
4948 Sint16 last_sample3 = sample3;
4949 Sint16 last_sample2 = sample2;
4950 Sint16 last_sample1 = sample1;
4951 Sint16 last_sample0 = sample0;
4952 while (dst >= target) {
4953 dst[5] = ((Sint16) SDL_SwapBE16(sample5));
4954 dst[4] = ((Sint16) SDL_SwapBE16(sample4));
4955 dst[3] = ((Sint16) SDL_SwapBE16(sample3));
4956 dst[2] = ((Sint16) SDL_SwapBE16(sample2));
4957 dst[1] = ((Sint16) SDL_SwapBE16(sample1));
4958 dst[0] = ((Sint16) SDL_SwapBE16(sample0));
4959 dst -= 6;
4960 eps += srcsize;
4961 if ((eps << 1) >= dstsize) {
4962 src -= 6;
4963 sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
4964 sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
4965 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
4966 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
4967 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
4968 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
4969 last_sample5 = sample5;
4970 last_sample4 = sample4;
4971 last_sample3 = sample3;
4972 last_sample2 = sample2;
4973 last_sample1 = sample1;
4974 last_sample0 = sample0;
4975 eps -= dstsize;
4976 }
4977 }
4978 cvt->len_cvt = dstsize;
4979 if (cvt->filters[++cvt->filter_index]) {
4980 cvt->filters[cvt->filter_index] (cvt, format);
4981 }
4982 }
4983
4984 static void SDLCALL
4985 SDL_Downsample_S16MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
4986 {
4987 #if DEBUG_CONVERT
4988 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16MSB, 6 channels.\n", cvt->rate_incr);
4989 #endif
4990
4991 const int srcsize = cvt->len_cvt - 192;
4992 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
4993 register int eps = 0;
4994 Sint16 *dst = (Sint16 *) cvt->buf;
4995 const Sint16 *src = (Sint16 *) cvt->buf;
4996 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
4997 Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
4998 Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
4999 Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
5000 Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
5001 Sint16 sample4 = ((Sint16) SDL_SwapBE16(src[4]));
5002 Sint16 sample5 = ((Sint16) SDL_SwapBE16(src[5]));
5003 Sint16 last_sample0 = sample0;
5004 Sint16 last_sample1 = sample1;
5005 Sint16 last_sample2 = sample2;
5006 Sint16 last_sample3 = sample3;
5007 Sint16 last_sample4 = sample4;
5008 Sint16 last_sample5 = sample5;
5009 while (dst < target) {
5010 src += 6;
5011 eps += dstsize;
5012 if ((eps << 1) >= srcsize) {
5013 dst[0] = ((Sint16) SDL_SwapBE16(sample0));
5014 dst[1] = ((Sint16) SDL_SwapBE16(sample1));
5015 dst[2] = ((Sint16) SDL_SwapBE16(sample2));
5016 dst[3] = ((Sint16) SDL_SwapBE16(sample3));
5017 dst[4] = ((Sint16) SDL_SwapBE16(sample4));
5018 dst[5] = ((Sint16) SDL_SwapBE16(sample5));
5019 dst += 6;
5020 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
5021 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
5022 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
5023 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
5024 sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
5025 sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
5026 last_sample0 = sample0;
5027 last_sample1 = sample1;
5028 last_sample2 = sample2;
5029 last_sample3 = sample3;
5030 last_sample4 = sample4;
5031 last_sample5 = sample5;
5032 eps -= srcsize;
5033 }
5034 }
5035 cvt->len_cvt = dstsize;
5036 if (cvt->filters[++cvt->filter_index]) {
5037 cvt->filters[cvt->filter_index] (cvt, format);
5038 }
5039 }
5040
5041 static void SDLCALL
5042 SDL_Upsample_S16MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5043 {
5044 #if DEBUG_CONVERT
5045 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16MSB, 8 channels.\n", cvt->rate_incr);
5046 #endif
5047
5048 const int srcsize = cvt->len_cvt - 256;
5049 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5050 register int eps = 0;
5051 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8;
5052 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
5053 const Sint16 *target = ((const Sint16 *) cvt->buf);
5054 Sint16 sample7 = ((Sint16) SDL_SwapBE16(src[7]));
5055 Sint16 sample6 = ((Sint16) SDL_SwapBE16(src[6]));
5056 Sint16 sample5 = ((Sint16) SDL_SwapBE16(src[5]));
5057 Sint16 sample4 = ((Sint16) SDL_SwapBE16(src[4]));
5058 Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
5059 Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
5060 Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
5061 Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
5062 Sint16 last_sample7 = sample7;
5063 Sint16 last_sample6 = sample6;
5064 Sint16 last_sample5 = sample5;
5065 Sint16 last_sample4 = sample4;
5066 Sint16 last_sample3 = sample3;
5067 Sint16 last_sample2 = sample2;
5068 Sint16 last_sample1 = sample1;
5069 Sint16 last_sample0 = sample0;
5070 while (dst >= target) {
5071 dst[7] = ((Sint16) SDL_SwapBE16(sample7));
5072 dst[6] = ((Sint16) SDL_SwapBE16(sample6));
5073 dst[5] = ((Sint16) SDL_SwapBE16(sample5));
5074 dst[4] = ((Sint16) SDL_SwapBE16(sample4));
5075 dst[3] = ((Sint16) SDL_SwapBE16(sample3));
5076 dst[2] = ((Sint16) SDL_SwapBE16(sample2));
5077 dst[1] = ((Sint16) SDL_SwapBE16(sample1));
5078 dst[0] = ((Sint16) SDL_SwapBE16(sample0));
5079 dst -= 8;
5080 eps += srcsize;
5081 if ((eps << 1) >= dstsize) {
5082 src -= 8;
5083 sample7 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[7]))) + ((Sint32) last_sample7)) >> 1);
5084 sample6 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[6]))) + ((Sint32) last_sample6)) >> 1);
5085 sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
5086 sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
5087 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
5088 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
5089 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
5090 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
5091 last_sample7 = sample7;
5092 last_sample6 = sample6;
5093 last_sample5 = sample5;
5094 last_sample4 = sample4;
5095 last_sample3 = sample3;
5096 last_sample2 = sample2;
5097 last_sample1 = sample1;
5098 last_sample0 = sample0;
5099 eps -= dstsize;
5100 }
5101 }
5102 cvt->len_cvt = dstsize;
5103 if (cvt->filters[++cvt->filter_index]) {
5104 cvt->filters[cvt->filter_index] (cvt, format);
5105 }
5106 }
5107
5108 static void SDLCALL
5109 SDL_Downsample_S16MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5110 {
5111 #if DEBUG_CONVERT
5112 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16MSB, 8 channels.\n", cvt->rate_incr);
5113 #endif
5114
5115 const int srcsize = cvt->len_cvt - 256;
5116 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5117 register int eps = 0;
5118 Sint16 *dst = (Sint16 *) cvt->buf;
5119 const Sint16 *src = (Sint16 *) cvt->buf;
5120 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
5121 Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
5122 Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
5123 Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
5124 Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
5125 Sint16 sample4 = ((Sint16) SDL_SwapBE16(src[4]));
5126 Sint16 sample5 = ((Sint16) SDL_SwapBE16(src[5]));
5127 Sint16 sample6 = ((Sint16) SDL_SwapBE16(src[6]));
5128 Sint16 sample7 = ((Sint16) SDL_SwapBE16(src[7]));
5129 Sint16 last_sample0 = sample0;
5130 Sint16 last_sample1 = sample1;
5131 Sint16 last_sample2 = sample2;
5132 Sint16 last_sample3 = sample3;
5133 Sint16 last_sample4 = sample4;
5134 Sint16 last_sample5 = sample5;
5135 Sint16 last_sample6 = sample6;
5136 Sint16 last_sample7 = sample7;
5137 while (dst < target) {
5138 src += 8;
5139 eps += dstsize;
5140 if ((eps << 1) >= srcsize) {
5141 dst[0] = ((Sint16) SDL_SwapBE16(sample0));
5142 dst[1] = ((Sint16) SDL_SwapBE16(sample1));
5143 dst[2] = ((Sint16) SDL_SwapBE16(sample2));
5144 dst[3] = ((Sint16) SDL_SwapBE16(sample3));
5145 dst[4] = ((Sint16) SDL_SwapBE16(sample4));
5146 dst[5] = ((Sint16) SDL_SwapBE16(sample5));
5147 dst[6] = ((Sint16) SDL_SwapBE16(sample6));
5148 dst[7] = ((Sint16) SDL_SwapBE16(sample7));
5149 dst += 8;
5150 sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
5151 sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
5152 sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
5153 sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
5154 sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
5155 sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
5156 sample6 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[6]))) + ((Sint32) last_sample6)) >> 1);
5157 sample7 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[7]))) + ((Sint32) last_sample7)) >> 1);
5158 last_sample0 = sample0;
5159 last_sample1 = sample1;
5160 last_sample2 = sample2;
5161 last_sample3 = sample3;
5162 last_sample4 = sample4;
5163 last_sample5 = sample5;
5164 last_sample6 = sample6;
5165 last_sample7 = sample7;
5166 eps -= srcsize;
5167 }
5168 }
5169 cvt->len_cvt = dstsize;
5170 if (cvt->filters[++cvt->filter_index]) {
5171 cvt->filters[cvt->filter_index] (cvt, format);
5172 }
5173 }
5174
5175 static void SDLCALL
5176 SDL_Upsample_S32LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5177 {
5178 #if DEBUG_CONVERT
5179 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32LSB, 1 channels.\n", cvt->rate_incr);
5180 #endif
5181
5182 const int srcsize = cvt->len_cvt - 64;
5183 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5184 register int eps = 0;
5185 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1;
5186 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
5187 const Sint32 *target = ((const Sint32 *) cvt->buf);
5188 Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
5189 Sint32 last_sample0 = sample0;
5190 while (dst >= target) {
5191 dst[0] = ((Sint32) SDL_SwapLE32(sample0));
5192 dst--;
5193 eps += srcsize;
5194 if ((eps << 1) >= dstsize) {
5195 src--;
5196 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5197 last_sample0 = sample0;
5198 eps -= dstsize;
5199 }
5200 }
5201 cvt->len_cvt = dstsize;
5202 if (cvt->filters[++cvt->filter_index]) {
5203 cvt->filters[cvt->filter_index] (cvt, format);
5204 }
5205 }
5206
5207 static void SDLCALL
5208 SDL_Downsample_S32LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5209 {
5210 #if DEBUG_CONVERT
5211 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32LSB, 1 channels.\n", cvt->rate_incr);
5212 #endif
5213
5214 const int srcsize = cvt->len_cvt - 64;
5215 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5216 register int eps = 0;
5217 Sint32 *dst = (Sint32 *) cvt->buf;
5218 const Sint32 *src = (Sint32 *) cvt->buf;
5219 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
5220 Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
5221 Sint32 last_sample0 = sample0;
5222 while (dst < target) {
5223 src++;
5224 eps += dstsize;
5225 if ((eps << 1) >= srcsize) {
5226 dst[0] = ((Sint32) SDL_SwapLE32(sample0));
5227 dst++;
5228 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5229 last_sample0 = sample0;
5230 eps -= srcsize;
5231 }
5232 }
5233 cvt->len_cvt = dstsize;
5234 if (cvt->filters[++cvt->filter_index]) {
5235 cvt->filters[cvt->filter_index] (cvt, format);
5236 }
5237 }
5238
5239 static void SDLCALL
5240 SDL_Upsample_S32LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5241 {
5242 #if DEBUG_CONVERT
5243 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32LSB, 2 channels.\n", cvt->rate_incr);
5244 #endif
5245
5246 const int srcsize = cvt->len_cvt - 128;
5247 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5248 register int eps = 0;
5249 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2;
5250 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
5251 const Sint32 *target = ((const Sint32 *) cvt->buf);
5252 Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
5253 Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
5254 Sint32 last_sample1 = sample1;
5255 Sint32 last_sample0 = sample0;
5256 while (dst >= target) {
5257 dst[1] = ((Sint32) SDL_SwapLE32(sample1));
5258 dst[0] = ((Sint32) SDL_SwapLE32(sample0));
5259 dst -= 2;
5260 eps += srcsize;
5261 if ((eps << 1) >= dstsize) {
5262 src -= 2;
5263 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5264 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5265 last_sample1 = sample1;
5266 last_sample0 = sample0;
5267 eps -= dstsize;
5268 }
5269 }
5270 cvt->len_cvt = dstsize;
5271 if (cvt->filters[++cvt->filter_index]) {
5272 cvt->filters[cvt->filter_index] (cvt, format);
5273 }
5274 }
5275
5276 static void SDLCALL
5277 SDL_Downsample_S32LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5278 {
5279 #if DEBUG_CONVERT
5280 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32LSB, 2 channels.\n", cvt->rate_incr);
5281 #endif
5282
5283 const int srcsize = cvt->len_cvt - 128;
5284 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5285 register int eps = 0;
5286 Sint32 *dst = (Sint32 *) cvt->buf;
5287 const Sint32 *src = (Sint32 *) cvt->buf;
5288 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
5289 Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
5290 Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
5291 Sint32 last_sample0 = sample0;
5292 Sint32 last_sample1 = sample1;
5293 while (dst < target) {
5294 src += 2;
5295 eps += dstsize;
5296 if ((eps << 1) >= srcsize) {
5297 dst[0] = ((Sint32) SDL_SwapLE32(sample0));
5298 dst[1] = ((Sint32) SDL_SwapLE32(sample1));
5299 dst += 2;
5300 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5301 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5302 last_sample0 = sample0;
5303 last_sample1 = sample1;
5304 eps -= srcsize;
5305 }
5306 }
5307 cvt->len_cvt = dstsize;
5308 if (cvt->filters[++cvt->filter_index]) {
5309 cvt->filters[cvt->filter_index] (cvt, format);
5310 }
5311 }
5312
5313 static void SDLCALL
5314 SDL_Upsample_S32LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5315 {
5316 #if DEBUG_CONVERT
5317 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32LSB, 4 channels.\n", cvt->rate_incr);
5318 #endif
5319
5320 const int srcsize = cvt->len_cvt - 256;
5321 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5322 register int eps = 0;
5323 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4;
5324 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
5325 const Sint32 *target = ((const Sint32 *) cvt->buf);
5326 Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
5327 Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
5328 Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
5329 Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
5330 Sint32 last_sample3 = sample3;
5331 Sint32 last_sample2 = sample2;
5332 Sint32 last_sample1 = sample1;
5333 Sint32 last_sample0 = sample0;
5334 while (dst >= target) {
5335 dst[3] = ((Sint32) SDL_SwapLE32(sample3));
5336 dst[2] = ((Sint32) SDL_SwapLE32(sample2));
5337 dst[1] = ((Sint32) SDL_SwapLE32(sample1));
5338 dst[0] = ((Sint32) SDL_SwapLE32(sample0));
5339 dst -= 4;
5340 eps += srcsize;
5341 if ((eps << 1) >= dstsize) {
5342 src -= 4;
5343 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
5344 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
5345 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5346 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5347 last_sample3 = sample3;
5348 last_sample2 = sample2;
5349 last_sample1 = sample1;
5350 last_sample0 = sample0;
5351 eps -= dstsize;
5352 }
5353 }
5354 cvt->len_cvt = dstsize;
5355 if (cvt->filters[++cvt->filter_index]) {
5356 cvt->filters[cvt->filter_index] (cvt, format);
5357 }
5358 }
5359
5360 static void SDLCALL
5361 SDL_Downsample_S32LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5362 {
5363 #if DEBUG_CONVERT
5364 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32LSB, 4 channels.\n", cvt->rate_incr);
5365 #endif
5366
5367 const int srcsize = cvt->len_cvt - 256;
5368 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5369 register int eps = 0;
5370 Sint32 *dst = (Sint32 *) cvt->buf;
5371 const Sint32 *src = (Sint32 *) cvt->buf;
5372 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
5373 Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
5374 Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
5375 Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
5376 Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
5377 Sint32 last_sample0 = sample0;
5378 Sint32 last_sample1 = sample1;
5379 Sint32 last_sample2 = sample2;
5380 Sint32 last_sample3 = sample3;
5381 while (dst < target) {
5382 src += 4;
5383 eps += dstsize;
5384 if ((eps << 1) >= srcsize) {
5385 dst[0] = ((Sint32) SDL_SwapLE32(sample0));
5386 dst[1] = ((Sint32) SDL_SwapLE32(sample1));
5387 dst[2] = ((Sint32) SDL_SwapLE32(sample2));
5388 dst[3] = ((Sint32) SDL_SwapLE32(sample3));
5389 dst += 4;
5390 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5391 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5392 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
5393 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
5394 last_sample0 = sample0;
5395 last_sample1 = sample1;
5396 last_sample2 = sample2;
5397 last_sample3 = sample3;
5398 eps -= srcsize;
5399 }
5400 }
5401 cvt->len_cvt = dstsize;
5402 if (cvt->filters[++cvt->filter_index]) {
5403 cvt->filters[cvt->filter_index] (cvt, format);
5404 }
5405 }
5406
5407 static void SDLCALL
5408 SDL_Upsample_S32LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5409 {
5410 #if DEBUG_CONVERT
5411 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32LSB, 6 channels.\n", cvt->rate_incr);
5412 #endif
5413
5414 const int srcsize = cvt->len_cvt - 384;
5415 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5416 register int eps = 0;
5417 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6;
5418 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
5419 const Sint32 *target = ((const Sint32 *) cvt->buf);
5420 Sint32 sample5 = ((Sint32) SDL_SwapLE32(src[5]));
5421 Sint32 sample4 = ((Sint32) SDL_SwapLE32(src[4]));
5422 Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
5423 Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
5424 Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
5425 Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
5426 Sint32 last_sample5 = sample5;
5427 Sint32 last_sample4 = sample4;
5428 Sint32 last_sample3 = sample3;
5429 Sint32 last_sample2 = sample2;
5430 Sint32 last_sample1 = sample1;
5431 Sint32 last_sample0 = sample0;
5432 while (dst >= target) {
5433 dst[5] = ((Sint32) SDL_SwapLE32(sample5));
5434 dst[4] = ((Sint32) SDL_SwapLE32(sample4));
5435 dst[3] = ((Sint32) SDL_SwapLE32(sample3));
5436 dst[2] = ((Sint32) SDL_SwapLE32(sample2));
5437 dst[1] = ((Sint32) SDL_SwapLE32(sample1));
5438 dst[0] = ((Sint32) SDL_SwapLE32(sample0));
5439 dst -= 6;
5440 eps += srcsize;
5441 if ((eps << 1) >= dstsize) {
5442 src -= 6;
5443 sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
5444 sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
5445 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
5446 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
5447 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5448 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5449 last_sample5 = sample5;
5450 last_sample4 = sample4;
5451 last_sample3 = sample3;
5452 last_sample2 = sample2;
5453 last_sample1 = sample1;
5454 last_sample0 = sample0;
5455 eps -= dstsize;
5456 }
5457 }
5458 cvt->len_cvt = dstsize;
5459 if (cvt->filters[++cvt->filter_index]) {
5460 cvt->filters[cvt->filter_index] (cvt, format);
5461 }
5462 }
5463
5464 static void SDLCALL
5465 SDL_Downsample_S32LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5466 {
5467 #if DEBUG_CONVERT
5468 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32LSB, 6 channels.\n", cvt->rate_incr);
5469 #endif
5470
5471 const int srcsize = cvt->len_cvt - 384;
5472 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5473 register int eps = 0;
5474 Sint32 *dst = (Sint32 *) cvt->buf;
5475 const Sint32 *src = (Sint32 *) cvt->buf;
5476 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
5477 Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
5478 Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
5479 Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
5480 Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
5481 Sint32 sample4 = ((Sint32) SDL_SwapLE32(src[4]));
5482 Sint32 sample5 = ((Sint32) SDL_SwapLE32(src[5]));
5483 Sint32 last_sample0 = sample0;
5484 Sint32 last_sample1 = sample1;
5485 Sint32 last_sample2 = sample2;
5486 Sint32 last_sample3 = sample3;
5487 Sint32 last_sample4 = sample4;
5488 Sint32 last_sample5 = sample5;
5489 while (dst < target) {
5490 src += 6;
5491 eps += dstsize;
5492 if ((eps << 1) >= srcsize) {
5493 dst[0] = ((Sint32) SDL_SwapLE32(sample0));
5494 dst[1] = ((Sint32) SDL_SwapLE32(sample1));
5495 dst[2] = ((Sint32) SDL_SwapLE32(sample2));
5496 dst[3] = ((Sint32) SDL_SwapLE32(sample3));
5497 dst[4] = ((Sint32) SDL_SwapLE32(sample4));
5498 dst[5] = ((Sint32) SDL_SwapLE32(sample5));
5499 dst += 6;
5500 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5501 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5502 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
5503 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
5504 sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
5505 sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
5506 last_sample0 = sample0;
5507 last_sample1 = sample1;
5508 last_sample2 = sample2;
5509 last_sample3 = sample3;
5510 last_sample4 = sample4;
5511 last_sample5 = sample5;
5512 eps -= srcsize;
5513 }
5514 }
5515 cvt->len_cvt = dstsize;
5516 if (cvt->filters[++cvt->filter_index]) {
5517 cvt->filters[cvt->filter_index] (cvt, format);
5518 }
5519 }
5520
5521 static void SDLCALL
5522 SDL_Upsample_S32LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5523 {
5524 #if DEBUG_CONVERT
5525 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32LSB, 8 channels.\n", cvt->rate_incr);
5526 #endif
5527
5528 const int srcsize = cvt->len_cvt - 512;
5529 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5530 register int eps = 0;
5531 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8;
5532 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
5533 const Sint32 *target = ((const Sint32 *) cvt->buf);
5534 Sint32 sample7 = ((Sint32) SDL_SwapLE32(src[7]));
5535 Sint32 sample6 = ((Sint32) SDL_SwapLE32(src[6]));
5536 Sint32 sample5 = ((Sint32) SDL_SwapLE32(src[5]));
5537 Sint32 sample4 = ((Sint32) SDL_SwapLE32(src[4]));
5538 Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
5539 Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
5540 Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
5541 Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
5542 Sint32 last_sample7 = sample7;
5543 Sint32 last_sample6 = sample6;
5544 Sint32 last_sample5 = sample5;
5545 Sint32 last_sample4 = sample4;
5546 Sint32 last_sample3 = sample3;
5547 Sint32 last_sample2 = sample2;
5548 Sint32 last_sample1 = sample1;
5549 Sint32 last_sample0 = sample0;
5550 while (dst >= target) {
5551 dst[7] = ((Sint32) SDL_SwapLE32(sample7));
5552 dst[6] = ((Sint32) SDL_SwapLE32(sample6));
5553 dst[5] = ((Sint32) SDL_SwapLE32(sample5));
5554 dst[4] = ((Sint32) SDL_SwapLE32(sample4));
5555 dst[3] = ((Sint32) SDL_SwapLE32(sample3));
5556 dst[2] = ((Sint32) SDL_SwapLE32(sample2));
5557 dst[1] = ((Sint32) SDL_SwapLE32(sample1));
5558 dst[0] = ((Sint32) SDL_SwapLE32(sample0));
5559 dst -= 8;
5560 eps += srcsize;
5561 if ((eps << 1) >= dstsize) {
5562 src -= 8;
5563 sample7 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[7]))) + ((Sint64) last_sample7)) >> 1);
5564 sample6 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[6]))) + ((Sint64) last_sample6)) >> 1);
5565 sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
5566 sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
5567 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
5568 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
5569 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5570 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5571 last_sample7 = sample7;
5572 last_sample6 = sample6;
5573 last_sample5 = sample5;
5574 last_sample4 = sample4;
5575 last_sample3 = sample3;
5576 last_sample2 = sample2;
5577 last_sample1 = sample1;
5578 last_sample0 = sample0;
5579 eps -= dstsize;
5580 }
5581 }
5582 cvt->len_cvt = dstsize;
5583 if (cvt->filters[++cvt->filter_index]) {
5584 cvt->filters[cvt->filter_index] (cvt, format);
5585 }
5586 }
5587
5588 static void SDLCALL
5589 SDL_Downsample_S32LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5590 {
5591 #if DEBUG_CONVERT
5592 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32LSB, 8 channels.\n", cvt->rate_incr);
5593 #endif
5594
5595 const int srcsize = cvt->len_cvt - 512;
5596 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5597 register int eps = 0;
5598 Sint32 *dst = (Sint32 *) cvt->buf;
5599 const Sint32 *src = (Sint32 *) cvt->buf;
5600 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
5601 Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
5602 Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
5603 Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
5604 Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
5605 Sint32 sample4 = ((Sint32) SDL_SwapLE32(src[4]));
5606 Sint32 sample5 = ((Sint32) SDL_SwapLE32(src[5]));
5607 Sint32 sample6 = ((Sint32) SDL_SwapLE32(src[6]));
5608 Sint32 sample7 = ((Sint32) SDL_SwapLE32(src[7]));
5609 Sint32 last_sample0 = sample0;
5610 Sint32 last_sample1 = sample1;
5611 Sint32 last_sample2 = sample2;
5612 Sint32 last_sample3 = sample3;
5613 Sint32 last_sample4 = sample4;
5614 Sint32 last_sample5 = sample5;
5615 Sint32 last_sample6 = sample6;
5616 Sint32 last_sample7 = sample7;
5617 while (dst < target) {
5618 src += 8;
5619 eps += dstsize;
5620 if ((eps << 1) >= srcsize) {
5621 dst[0] = ((Sint32) SDL_SwapLE32(sample0));
5622 dst[1] = ((Sint32) SDL_SwapLE32(sample1));
5623 dst[2] = ((Sint32) SDL_SwapLE32(sample2));
5624 dst[3] = ((Sint32) SDL_SwapLE32(sample3));
5625 dst[4] = ((Sint32) SDL_SwapLE32(sample4));
5626 dst[5] = ((Sint32) SDL_SwapLE32(sample5));
5627 dst[6] = ((Sint32) SDL_SwapLE32(sample6));
5628 dst[7] = ((Sint32) SDL_SwapLE32(sample7));
5629 dst += 8;
5630 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5631 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5632 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
5633 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
5634 sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
5635 sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
5636 sample6 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[6]))) + ((Sint64) last_sample6)) >> 1);
5637 sample7 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[7]))) + ((Sint64) last_sample7)) >> 1);
5638 last_sample0 = sample0;
5639 last_sample1 = sample1;
5640 last_sample2 = sample2;
5641 last_sample3 = sample3;
5642 last_sample4 = sample4;
5643 last_sample5 = sample5;
5644 last_sample6 = sample6;
5645 last_sample7 = sample7;
5646 eps -= srcsize;
5647 }
5648 }
5649 cvt->len_cvt = dstsize;
5650 if (cvt->filters[++cvt->filter_index]) {
5651 cvt->filters[cvt->filter_index] (cvt, format);
5652 }
5653 }
5654
5655 static void SDLCALL
5656 SDL_Upsample_S32MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5657 {
5658 #if DEBUG_CONVERT
5659 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32MSB, 1 channels.\n", cvt->rate_incr);
5660 #endif
5661
5662 const int srcsize = cvt->len_cvt - 64;
5663 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5664 register int eps = 0;
5665 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1;
5666 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
5667 const Sint32 *target = ((const Sint32 *) cvt->buf);
5668 Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
5669 Sint32 last_sample0 = sample0;
5670 while (dst >= target) {
5671 dst[0] = ((Sint32) SDL_SwapBE32(sample0));
5672 dst--;
5673 eps += srcsize;
5674 if ((eps << 1) >= dstsize) {
5675 src--;
5676 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5677 last_sample0 = sample0;
5678 eps -= dstsize;
5679 }
5680 }
5681 cvt->len_cvt = dstsize;
5682 if (cvt->filters[++cvt->filter_index]) {
5683 cvt->filters[cvt->filter_index] (cvt, format);
5684 }
5685 }
5686
5687 static void SDLCALL
5688 SDL_Downsample_S32MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5689 {
5690 #if DEBUG_CONVERT
5691 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32MSB, 1 channels.\n", cvt->rate_incr);
5692 #endif
5693
5694 const int srcsize = cvt->len_cvt - 64;
5695 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5696 register int eps = 0;
5697 Sint32 *dst = (Sint32 *) cvt->buf;
5698 const Sint32 *src = (Sint32 *) cvt->buf;
5699 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
5700 Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
5701 Sint32 last_sample0 = sample0;
5702 while (dst < target) {
5703 src++;
5704 eps += dstsize;
5705 if ((eps << 1) >= srcsize) {
5706 dst[0] = ((Sint32) SDL_SwapBE32(sample0));
5707 dst++;
5708 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5709 last_sample0 = sample0;
5710 eps -= srcsize;
5711 }
5712 }
5713 cvt->len_cvt = dstsize;
5714 if (cvt->filters[++cvt->filter_index]) {
5715 cvt->filters[cvt->filter_index] (cvt, format);
5716 }
5717 }
5718
5719 static void SDLCALL
5720 SDL_Upsample_S32MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5721 {
5722 #if DEBUG_CONVERT
5723 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32MSB, 2 channels.\n", cvt->rate_incr);
5724 #endif
5725
5726 const int srcsize = cvt->len_cvt - 128;
5727 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5728 register int eps = 0;
5729 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2;
5730 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
5731 const Sint32 *target = ((const Sint32 *) cvt->buf);
5732 Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
5733 Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
5734 Sint32 last_sample1 = sample1;
5735 Sint32 last_sample0 = sample0;
5736 while (dst >= target) {
5737 dst[1] = ((Sint32) SDL_SwapBE32(sample1));
5738 dst[0] = ((Sint32) SDL_SwapBE32(sample0));
5739 dst -= 2;
5740 eps += srcsize;
5741 if ((eps << 1) >= dstsize) {
5742 src -= 2;
5743 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5744 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5745 last_sample1 = sample1;
5746 last_sample0 = sample0;
5747 eps -= dstsize;
5748 }
5749 }
5750 cvt->len_cvt = dstsize;
5751 if (cvt->filters[++cvt->filter_index]) {
5752 cvt->filters[cvt->filter_index] (cvt, format);
5753 }
5754 }
5755
5756 static void SDLCALL
5757 SDL_Downsample_S32MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5758 {
5759 #if DEBUG_CONVERT
5760 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32MSB, 2 channels.\n", cvt->rate_incr);
5761 #endif
5762
5763 const int srcsize = cvt->len_cvt - 128;
5764 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5765 register int eps = 0;
5766 Sint32 *dst = (Sint32 *) cvt->buf;
5767 const Sint32 *src = (Sint32 *) cvt->buf;
5768 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
5769 Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
5770 Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
5771 Sint32 last_sample0 = sample0;
5772 Sint32 last_sample1 = sample1;
5773 while (dst < target) {
5774 src += 2;
5775 eps += dstsize;
5776 if ((eps << 1) >= srcsize) {
5777 dst[0] = ((Sint32) SDL_SwapBE32(sample0));
5778 dst[1] = ((Sint32) SDL_SwapBE32(sample1));
5779 dst += 2;
5780 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5781 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5782 last_sample0 = sample0;
5783 last_sample1 = sample1;
5784 eps -= srcsize;
5785 }
5786 }
5787 cvt->len_cvt = dstsize;
5788 if (cvt->filters[++cvt->filter_index]) {
5789 cvt->filters[cvt->filter_index] (cvt, format);
5790 }
5791 }
5792
5793 static void SDLCALL
5794 SDL_Upsample_S32MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5795 {
5796 #if DEBUG_CONVERT
5797 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32MSB, 4 channels.\n", cvt->rate_incr);
5798 #endif
5799
5800 const int srcsize = cvt->len_cvt - 256;
5801 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5802 register int eps = 0;
5803 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4;
5804 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
5805 const Sint32 *target = ((const Sint32 *) cvt->buf);
5806 Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
5807 Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
5808 Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
5809 Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
5810 Sint32 last_sample3 = sample3;
5811 Sint32 last_sample2 = sample2;
5812 Sint32 last_sample1 = sample1;
5813 Sint32 last_sample0 = sample0;
5814 while (dst >= target) {
5815 dst[3] = ((Sint32) SDL_SwapBE32(sample3));
5816 dst[2] = ((Sint32) SDL_SwapBE32(sample2));
5817 dst[1] = ((Sint32) SDL_SwapBE32(sample1));
5818 dst[0] = ((Sint32) SDL_SwapBE32(sample0));
5819 dst -= 4;
5820 eps += srcsize;
5821 if ((eps << 1) >= dstsize) {
5822 src -= 4;
5823 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
5824 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
5825 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5826 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5827 last_sample3 = sample3;
5828 last_sample2 = sample2;
5829 last_sample1 = sample1;
5830 last_sample0 = sample0;
5831 eps -= dstsize;
5832 }
5833 }
5834 cvt->len_cvt = dstsize;
5835 if (cvt->filters[++cvt->filter_index]) {
5836 cvt->filters[cvt->filter_index] (cvt, format);
5837 }
5838 }
5839
5840 static void SDLCALL
5841 SDL_Downsample_S32MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5842 {
5843 #if DEBUG_CONVERT
5844 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32MSB, 4 channels.\n", cvt->rate_incr);
5845 #endif
5846
5847 const int srcsize = cvt->len_cvt - 256;
5848 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5849 register int eps = 0;
5850 Sint32 *dst = (Sint32 *) cvt->buf;
5851 const Sint32 *src = (Sint32 *) cvt->buf;
5852 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
5853 Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
5854 Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
5855 Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
5856 Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
5857 Sint32 last_sample0 = sample0;
5858 Sint32 last_sample1 = sample1;
5859 Sint32 last_sample2 = sample2;
5860 Sint32 last_sample3 = sample3;
5861 while (dst < target) {
5862 src += 4;
5863 eps += dstsize;
5864 if ((eps << 1) >= srcsize) {
5865 dst[0] = ((Sint32) SDL_SwapBE32(sample0));
5866 dst[1] = ((Sint32) SDL_SwapBE32(sample1));
5867 dst[2] = ((Sint32) SDL_SwapBE32(sample2));
5868 dst[3] = ((Sint32) SDL_SwapBE32(sample3));
5869 dst += 4;
5870 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5871 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5872 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
5873 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
5874 last_sample0 = sample0;
5875 last_sample1 = sample1;
5876 last_sample2 = sample2;
5877 last_sample3 = sample3;
5878 eps -= srcsize;
5879 }
5880 }
5881 cvt->len_cvt = dstsize;
5882 if (cvt->filters[++cvt->filter_index]) {
5883 cvt->filters[cvt->filter_index] (cvt, format);
5884 }
5885 }
5886
5887 static void SDLCALL
5888 SDL_Upsample_S32MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5889 {
5890 #if DEBUG_CONVERT
5891 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32MSB, 6 channels.\n", cvt->rate_incr);
5892 #endif
5893
5894 const int srcsize = cvt->len_cvt - 384;
5895 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5896 register int eps = 0;
5897 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6;
5898 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
5899 const Sint32 *target = ((const Sint32 *) cvt->buf);
5900 Sint32 sample5 = ((Sint32) SDL_SwapBE32(src[5]));
5901 Sint32 sample4 = ((Sint32) SDL_SwapBE32(src[4]));
5902 Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
5903 Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
5904 Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
5905 Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
5906 Sint32 last_sample5 = sample5;
5907 Sint32 last_sample4 = sample4;
5908 Sint32 last_sample3 = sample3;
5909 Sint32 last_sample2 = sample2;
5910 Sint32 last_sample1 = sample1;
5911 Sint32 last_sample0 = sample0;
5912 while (dst >= target) {
5913 dst[5] = ((Sint32) SDL_SwapBE32(sample5));
5914 dst[4] = ((Sint32) SDL_SwapBE32(sample4));
5915 dst[3] = ((Sint32) SDL_SwapBE32(sample3));
5916 dst[2] = ((Sint32) SDL_SwapBE32(sample2));
5917 dst[1] = ((Sint32) SDL_SwapBE32(sample1));
5918 dst[0] = ((Sint32) SDL_SwapBE32(sample0));
5919 dst -= 6;
5920 eps += srcsize;
5921 if ((eps << 1) >= dstsize) {
5922 src -= 6;
5923 sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
5924 sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
5925 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
5926 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
5927 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5928 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5929 last_sample5 = sample5;
5930 last_sample4 = sample4;
5931 last_sample3 = sample3;
5932 last_sample2 = sample2;
5933 last_sample1 = sample1;
5934 last_sample0 = sample0;
5935 eps -= dstsize;
5936 }
5937 }
5938 cvt->len_cvt = dstsize;
5939 if (cvt->filters[++cvt->filter_index]) {
5940 cvt->filters[cvt->filter_index] (cvt, format);
5941 }
5942 }
5943
5944 static void SDLCALL
5945 SDL_Downsample_S32MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
5946 {
5947 #if DEBUG_CONVERT
5948 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32MSB, 6 channels.\n", cvt->rate_incr);
5949 #endif
5950
5951 const int srcsize = cvt->len_cvt - 384;
5952 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
5953 register int eps = 0;
5954 Sint32 *dst = (Sint32 *) cvt->buf;
5955 const Sint32 *src = (Sint32 *) cvt->buf;
5956 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
5957 Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
5958 Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
5959 Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
5960 Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
5961 Sint32 sample4 = ((Sint32) SDL_SwapBE32(src[4]));
5962 Sint32 sample5 = ((Sint32) SDL_SwapBE32(src[5]));
5963 Sint32 last_sample0 = sample0;
5964 Sint32 last_sample1 = sample1;
5965 Sint32 last_sample2 = sample2;
5966 Sint32 last_sample3 = sample3;
5967 Sint32 last_sample4 = sample4;
5968 Sint32 last_sample5 = sample5;
5969 while (dst < target) {
5970 src += 6;
5971 eps += dstsize;
5972 if ((eps << 1) >= srcsize) {
5973 dst[0] = ((Sint32) SDL_SwapBE32(sample0));
5974 dst[1] = ((Sint32) SDL_SwapBE32(sample1));
5975 dst[2] = ((Sint32) SDL_SwapBE32(sample2));
5976 dst[3] = ((Sint32) SDL_SwapBE32(sample3));
5977 dst[4] = ((Sint32) SDL_SwapBE32(sample4));
5978 dst[5] = ((Sint32) SDL_SwapBE32(sample5));
5979 dst += 6;
5980 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
5981 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
5982 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
5983 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
5984 sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
5985 sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
5986 last_sample0 = sample0;
5987 last_sample1 = sample1;
5988 last_sample2 = sample2;
5989 last_sample3 = sample3;
5990 last_sample4 = sample4;
5991 last_sample5 = sample5;
5992 eps -= srcsize;
5993 }
5994 }
5995 cvt->len_cvt = dstsize;
5996 if (cvt->filters[++cvt->filter_index]) {
5997 cvt->filters[cvt->filter_index] (cvt, format);
5998 }
5999 }
6000
6001 static void SDLCALL
6002 SDL_Upsample_S32MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6003 {
6004 #if DEBUG_CONVERT
6005 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32MSB, 8 channels.\n", cvt->rate_incr);
6006 #endif
6007
6008 const int srcsize = cvt->len_cvt - 512;
6009 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6010 register int eps = 0;
6011 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8;
6012 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
6013 const Sint32 *target = ((const Sint32 *) cvt->buf);
6014 Sint32 sample7 = ((Sint32) SDL_SwapBE32(src[7]));
6015 Sint32 sample6 = ((Sint32) SDL_SwapBE32(src[6]));
6016 Sint32 sample5 = ((Sint32) SDL_SwapBE32(src[5]));
6017 Sint32 sample4 = ((Sint32) SDL_SwapBE32(src[4]));
6018 Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
6019 Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
6020 Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
6021 Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
6022 Sint32 last_sample7 = sample7;
6023 Sint32 last_sample6 = sample6;
6024 Sint32 last_sample5 = sample5;
6025 Sint32 last_sample4 = sample4;
6026 Sint32 last_sample3 = sample3;
6027 Sint32 last_sample2 = sample2;
6028 Sint32 last_sample1 = sample1;
6029 Sint32 last_sample0 = sample0;
6030 while (dst >= target) {
6031 dst[7] = ((Sint32) SDL_SwapBE32(sample7));
6032 dst[6] = ((Sint32) SDL_SwapBE32(sample6));
6033 dst[5] = ((Sint32) SDL_SwapBE32(sample5));
6034 dst[4] = ((Sint32) SDL_SwapBE32(sample4));
6035 dst[3] = ((Sint32) SDL_SwapBE32(sample3));
6036 dst[2] = ((Sint32) SDL_SwapBE32(sample2));
6037 dst[1] = ((Sint32) SDL_SwapBE32(sample1));
6038 dst[0] = ((Sint32) SDL_SwapBE32(sample0));
6039 dst -= 8;
6040 eps += srcsize;
6041 if ((eps << 1) >= dstsize) {
6042 src -= 8;
6043 sample7 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[7]))) + ((Sint64) last_sample7)) >> 1);
6044 sample6 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[6]))) + ((Sint64) last_sample6)) >> 1);
6045 sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
6046 sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
6047 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
6048 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
6049 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
6050 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
6051 last_sample7 = sample7;
6052 last_sample6 = sample6;
6053 last_sample5 = sample5;
6054 last_sample4 = sample4;
6055 last_sample3 = sample3;
6056 last_sample2 = sample2;
6057 last_sample1 = sample1;
6058 last_sample0 = sample0;
6059 eps -= dstsize;
6060 }
6061 }
6062 cvt->len_cvt = dstsize;
6063 if (cvt->filters[++cvt->filter_index]) {
6064 cvt->filters[cvt->filter_index] (cvt, format);
6065 }
6066 }
6067
6068 static void SDLCALL
6069 SDL_Downsample_S32MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6070 {
6071 #if DEBUG_CONVERT
6072 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32MSB, 8 channels.\n", cvt->rate_incr);
6073 #endif
6074
6075 const int srcsize = cvt->len_cvt - 512;
6076 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6077 register int eps = 0;
6078 Sint32 *dst = (Sint32 *) cvt->buf;
6079 const Sint32 *src = (Sint32 *) cvt->buf;
6080 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
6081 Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
6082 Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
6083 Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
6084 Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
6085 Sint32 sample4 = ((Sint32) SDL_SwapBE32(src[4]));
6086 Sint32 sample5 = ((Sint32) SDL_SwapBE32(src[5]));
6087 Sint32 sample6 = ((Sint32) SDL_SwapBE32(src[6]));
6088 Sint32 sample7 = ((Sint32) SDL_SwapBE32(src[7]));
6089 Sint32 last_sample0 = sample0;
6090 Sint32 last_sample1 = sample1;
6091 Sint32 last_sample2 = sample2;
6092 Sint32 last_sample3 = sample3;
6093 Sint32 last_sample4 = sample4;
6094 Sint32 last_sample5 = sample5;
6095 Sint32 last_sample6 = sample6;
6096 Sint32 last_sample7 = sample7;
6097 while (dst < target) {
6098 src += 8;
6099 eps += dstsize;
6100 if ((eps << 1) >= srcsize) {
6101 dst[0] = ((Sint32) SDL_SwapBE32(sample0));
6102 dst[1] = ((Sint32) SDL_SwapBE32(sample1));
6103 dst[2] = ((Sint32) SDL_SwapBE32(sample2));
6104 dst[3] = ((Sint32) SDL_SwapBE32(sample3));
6105 dst[4] = ((Sint32) SDL_SwapBE32(sample4));
6106 dst[5] = ((Sint32) SDL_SwapBE32(sample5));
6107 dst[6] = ((Sint32) SDL_SwapBE32(sample6));
6108 dst[7] = ((Sint32) SDL_SwapBE32(sample7));
6109 dst += 8;
6110 sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
6111 sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
6112 sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
6113 sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
6114 sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
6115 sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
6116 sample6 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[6]))) + ((Sint64) last_sample6)) >> 1);
6117 sample7 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[7]))) + ((Sint64) last_sample7)) >> 1);
6118 last_sample0 = sample0;
6119 last_sample1 = sample1;
6120 last_sample2 = sample2;
6121 last_sample3 = sample3;
6122 last_sample4 = sample4;
6123 last_sample5 = sample5;
6124 last_sample6 = sample6;
6125 last_sample7 = sample7;
6126 eps -= srcsize;
6127 }
6128 }
6129 cvt->len_cvt = dstsize;
6130 if (cvt->filters[++cvt->filter_index]) {
6131 cvt->filters[cvt->filter_index] (cvt, format);
6132 }
6133 }
6134
6135 static void SDLCALL
6136 SDL_Upsample_F32LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6137 {
6138 #if DEBUG_CONVERT
6139 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32LSB, 1 channels.\n", cvt->rate_incr);
6140 #endif
6141
6142 const int srcsize = cvt->len_cvt - 64;
6143 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6144 register int eps = 0;
6145 float *dst = ((float *) (cvt->buf + dstsize)) - 1;
6146 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
6147 const float *target = ((const float *) cvt->buf);
6148 float sample0 = SDL_SwapFloatLE(src[0]);
6149 float last_sample0 = sample0;
6150 while (dst >= target) {
6151 dst[0] = SDL_SwapFloatLE(sample0);
6152 dst--;
6153 eps += srcsize;
6154 if ((eps << 1) >= dstsize) {
6155 src--;
6156 sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
6157 last_sample0 = sample0;
6158 eps -= dstsize;
6159 }
6160 }
6161 cvt->len_cvt = dstsize;
6162 if (cvt->filters[++cvt->filter_index]) {
6163 cvt->filters[cvt->filter_index] (cvt, format);
6164 }
6165 }
6166
6167 static void SDLCALL
6168 SDL_Downsample_F32LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6169 {
6170 #if DEBUG_CONVERT
6171 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32LSB, 1 channels.\n", cvt->rate_incr);
6172 #endif
6173
6174 const int srcsize = cvt->len_cvt - 64;
6175 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6176 register int eps = 0;
6177 float *dst = (float *) cvt->buf;
6178 const float *src = (float *) cvt->buf;
6179 const float *target = (const float *) (cvt->buf + dstsize);
6180 float sample0 = SDL_SwapFloatLE(src[0]);
6181 float last_sample0 = sample0;
6182 while (dst < target) {
6183 src++;
6184 eps += dstsize;
6185 if ((eps << 1) >= srcsize) {
6186 dst[0] = SDL_SwapFloatLE(sample0);
6187 dst++;
6188 sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
6189 last_sample0 = sample0;
6190 eps -= srcsize;
6191 }
6192 }
6193 cvt->len_cvt = dstsize;
6194 if (cvt->filters[++cvt->filter_index]) {
6195 cvt->filters[cvt->filter_index] (cvt, format);
6196 }
6197 }
6198
6199 static void SDLCALL
6200 SDL_Upsample_F32LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6201 {
6202 #if DEBUG_CONVERT
6203 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32LSB, 2 channels.\n", cvt->rate_incr);
6204 #endif
6205
6206 const int srcsize = cvt->len_cvt - 128;
6207 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6208 register int eps = 0;
6209 float *dst = ((float *) (cvt->buf + dstsize)) - 2;
6210 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
6211 const float *target = ((const float *) cvt->buf);
6212 float sample1 = SDL_SwapFloatLE(src[1]);
6213 float sample0 = SDL_SwapFloatLE(src[0]);
6214 float last_sample1 = sample1;
6215 float last_sample0 = sample0;
6216 while (dst >= target) {
6217 dst[1] = SDL_SwapFloatLE(sample1);
6218 dst[0] = SDL_SwapFloatLE(sample0);
6219 dst -= 2;
6220 eps += srcsize;
6221 if ((eps << 1) >= dstsize) {
6222 src -= 2;
6223 sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
6224 sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
6225 last_sample1 = sample1;
6226 last_sample0 = sample0;
6227 eps -= dstsize;
6228 }
6229 }
6230 cvt->len_cvt = dstsize;
6231 if (cvt->filters[++cvt->filter_index]) {
6232 cvt->filters[cvt->filter_index] (cvt, format);
6233 }
6234 }
6235
6236 static void SDLCALL
6237 SDL_Downsample_F32LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6238 {
6239 #if DEBUG_CONVERT
6240 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32LSB, 2 channels.\n", cvt->rate_incr);
6241 #endif
6242
6243 const int srcsize = cvt->len_cvt - 128;
6244 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6245 register int eps = 0;
6246 float *dst = (float *) cvt->buf;
6247 const float *src = (float *) cvt->buf;
6248 const float *target = (const float *) (cvt->buf + dstsize);
6249 float sample0 = SDL_SwapFloatLE(src[0]);
6250 float sample1 = SDL_SwapFloatLE(src[1]);
6251 float last_sample0 = sample0;
6252 float last_sample1 = sample1;
6253 while (dst < target) {
6254 src += 2;
6255 eps += dstsize;
6256 if ((eps << 1) >= srcsize) {
6257 dst[0] = SDL_SwapFloatLE(sample0);
6258 dst[1] = SDL_SwapFloatLE(sample1);
6259 dst += 2;
6260 sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
6261 sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
6262 last_sample0 = sample0;
6263 last_sample1 = sample1;
6264 eps -= srcsize;
6265 }
6266 }
6267 cvt->len_cvt = dstsize;
6268 if (cvt->filters[++cvt->filter_index]) {
6269 cvt->filters[cvt->filter_index] (cvt, format);
6270 }
6271 }
6272
6273 static void SDLCALL
6274 SDL_Upsample_F32LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6275 {
6276 #if DEBUG_CONVERT
6277 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32LSB, 4 channels.\n", cvt->rate_incr);
6278 #endif
6279
6280 const int srcsize = cvt->len_cvt - 256;
6281 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6282 register int eps = 0;
6283 float *dst = ((float *) (cvt->buf + dstsize)) - 4;
6284 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
6285 const float *target = ((const float *) cvt->buf);
6286 float sample3 = SDL_SwapFloatLE(src[3]);
6287 float sample2 = SDL_SwapFloatLE(src[2]);
6288 float sample1 = SDL_SwapFloatLE(src[1]);
6289 float sample0 = SDL_SwapFloatLE(src[0]);
6290 float last_sample3 = sample3;
6291 float last_sample2 = sample2;
6292 float last_sample1 = sample1;
6293 float last_sample0 = sample0;
6294 while (dst >= target) {
6295 dst[3] = SDL_SwapFloatLE(sample3);
6296 dst[2] = SDL_SwapFloatLE(sample2);
6297 dst[1] = SDL_SwapFloatLE(sample1);
6298 dst[0] = SDL_SwapFloatLE(sample0);
6299 dst -= 4;
6300 eps += srcsize;
6301 if ((eps << 1) >= dstsize) {
6302 src -= 4;
6303 sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
6304 sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
6305 sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
6306 sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
6307 last_sample3 = sample3;
6308 last_sample2 = sample2;
6309 last_sample1 = sample1;
6310 last_sample0 = sample0;
6311 eps -= dstsize;
6312 }
6313 }
6314 cvt->len_cvt = dstsize;
6315 if (cvt->filters[++cvt->filter_index]) {
6316 cvt->filters[cvt->filter_index] (cvt, format);
6317 }
6318 }
6319
6320 static void SDLCALL
6321 SDL_Downsample_F32LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6322 {
6323 #if DEBUG_CONVERT
6324 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32LSB, 4 channels.\n", cvt->rate_incr);
6325 #endif
6326
6327 const int srcsize = cvt->len_cvt - 256;
6328 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6329 register int eps = 0;
6330 float *dst = (float *) cvt->buf;
6331 const float *src = (float *) cvt->buf;
6332 const float *target = (const float *) (cvt->buf + dstsize);
6333 float sample0 = SDL_SwapFloatLE(src[0]);
6334 float sample1 = SDL_SwapFloatLE(src[1]);
6335 float sample2 = SDL_SwapFloatLE(src[2]);
6336 float sample3 = SDL_SwapFloatLE(src[3]);
6337 float last_sample0 = sample0;
6338 float last_sample1 = sample1;
6339 float last_sample2 = sample2;
6340 float last_sample3 = sample3;
6341 while (dst < target) {
6342 src += 4;
6343 eps += dstsize;
6344 if ((eps << 1) >= srcsize) {
6345 dst[0] = SDL_SwapFloatLE(sample0);
6346 dst[1] = SDL_SwapFloatLE(sample1);
6347 dst[2] = SDL_SwapFloatLE(sample2);
6348 dst[3] = SDL_SwapFloatLE(sample3);
6349 dst += 4;
6350 sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
6351 sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
6352 sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
6353 sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
6354 last_sample0 = sample0;
6355 last_sample1 = sample1;
6356 last_sample2 = sample2;
6357 last_sample3 = sample3;
6358 eps -= srcsize;
6359 }
6360 }
6361 cvt->len_cvt = dstsize;
6362 if (cvt->filters[++cvt->filter_index]) {
6363 cvt->filters[cvt->filter_index] (cvt, format);
6364 }
6365 }
6366
6367 static void SDLCALL
6368 SDL_Upsample_F32LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6369 {
6370 #if DEBUG_CONVERT
6371 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32LSB, 6 channels.\n", cvt->rate_incr);
6372 #endif
6373
6374 const int srcsize = cvt->len_cvt - 384;
6375 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6376 register int eps = 0;
6377 float *dst = ((float *) (cvt->buf + dstsize)) - 6;
6378 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
6379 const float *target = ((const float *) cvt->buf);
6380 float sample5 = SDL_SwapFloatLE(src[5]);
6381 float sample4 = SDL_SwapFloatLE(src[4]);
6382 float sample3 = SDL_SwapFloatLE(src[3]);
6383 float sample2 = SDL_SwapFloatLE(src[2]);
6384 float sample1 = SDL_SwapFloatLE(src[1]);
6385 float sample0 = SDL_SwapFloatLE(src[0]);
6386 float last_sample5 = sample5;
6387 float last_sample4 = sample4;
6388 float last_sample3 = sample3;
6389 float last_sample2 = sample2;
6390 float last_sample1 = sample1;
6391 float last_sample0 = sample0;
6392 while (dst >= target) {
6393 dst[5] = SDL_SwapFloatLE(sample5);
6394 dst[4] = SDL_SwapFloatLE(sample4);
6395 dst[3] = SDL_SwapFloatLE(sample3);
6396 dst[2] = SDL_SwapFloatLE(sample2);
6397 dst[1] = SDL_SwapFloatLE(sample1);
6398 dst[0] = SDL_SwapFloatLE(sample0);
6399 dst -= 6;
6400 eps += srcsize;
6401 if ((eps << 1) >= dstsize) {
6402 src -= 6;
6403 sample5 = (float) ((((double) SDL_SwapFloatLE(src[5])) + ((double) last_sample5)) * 0.5);
6404 sample4 = (float) ((((double) SDL_SwapFloatLE(src[4])) + ((double) last_sample4)) * 0.5);
6405 sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
6406 sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
6407 sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
6408 sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
6409 last_sample5 = sample5;
6410 last_sample4 = sample4;
6411 last_sample3 = sample3;
6412 last_sample2 = sample2;
6413 last_sample1 = sample1;
6414 last_sample0 = sample0;
6415 eps -= dstsize;
6416 }
6417 }
6418 cvt->len_cvt = dstsize;
6419 if (cvt->filters[++cvt->filter_index]) {
6420 cvt->filters[cvt->filter_index] (cvt, format);
6421 }
6422 }
6423
6424 static void SDLCALL
6425 SDL_Downsample_F32LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6426 {
6427 #if DEBUG_CONVERT
6428 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32LSB, 6 channels.\n", cvt->rate_incr);
6429 #endif
6430
6431 const int srcsize = cvt->len_cvt - 384;
6432 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6433 register int eps = 0;
6434 float *dst = (float *) cvt->buf;
6435 const float *src = (float *) cvt->buf;
6436 const float *target = (const float *) (cvt->buf + dstsize);
6437 float sample0 = SDL_SwapFloatLE(src[0]);
6438 float sample1 = SDL_SwapFloatLE(src[1]);
6439 float sample2 = SDL_SwapFloatLE(src[2]);
6440 float sample3 = SDL_SwapFloatLE(src[3]);
6441 float sample4 = SDL_SwapFloatLE(src[4]);
6442 float sample5 = SDL_SwapFloatLE(src[5]);
6443 float last_sample0 = sample0;
6444 float last_sample1 = sample1;
6445 float last_sample2 = sample2;
6446 float last_sample3 = sample3;
6447 float last_sample4 = sample4;
6448 float last_sample5 = sample5;
6449 while (dst < target) {
6450 src += 6;
6451 eps += dstsize;
6452 if ((eps << 1) >= srcsize) {
6453 dst[0] = SDL_SwapFloatLE(sample0);
6454 dst[1] = SDL_SwapFloatLE(sample1);
6455 dst[2] = SDL_SwapFloatLE(sample2);
6456 dst[3] = SDL_SwapFloatLE(sample3);
6457 dst[4] = SDL_SwapFloatLE(sample4);
6458 dst[5] = SDL_SwapFloatLE(sample5);
6459 dst += 6;
6460 sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
6461 sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
6462 sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
6463 sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
6464 sample4 = (float) ((((double) SDL_SwapFloatLE(src[4])) + ((double) last_sample4)) * 0.5);
6465 sample5 = (float) ((((double) SDL_SwapFloatLE(src[5])) + ((double) last_sample5)) * 0.5);
6466 last_sample0 = sample0;
6467 last_sample1 = sample1;
6468 last_sample2 = sample2;
6469 last_sample3 = sample3;
6470 last_sample4 = sample4;
6471 last_sample5 = sample5;
6472 eps -= srcsize;
6473 }
6474 }
6475 cvt->len_cvt = dstsize;
6476 if (cvt->filters[++cvt->filter_index]) {
6477 cvt->filters[cvt->filter_index] (cvt, format);
6478 }
6479 }
6480
6481 static void SDLCALL
6482 SDL_Upsample_F32LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6483 {
6484 #if DEBUG_CONVERT
6485 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32LSB, 8 channels.\n", cvt->rate_incr);
6486 #endif
6487
6488 const int srcsize = cvt->len_cvt - 512;
6489 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6490 register int eps = 0;
6491 float *dst = ((float *) (cvt->buf + dstsize)) - 8;
6492 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
6493 const float *target = ((const float *) cvt->buf);
6494 float sample7 = SDL_SwapFloatLE(src[7]);
6495 float sample6 = SDL_SwapFloatLE(src[6]);
6496 float sample5 = SDL_SwapFloatLE(src[5]);
6497 float sample4 = SDL_SwapFloatLE(src[4]);
6498 float sample3 = SDL_SwapFloatLE(src[3]);
6499 float sample2 = SDL_SwapFloatLE(src[2]);
6500 float sample1 = SDL_SwapFloatLE(src[1]);
6501 float sample0 = SDL_SwapFloatLE(src[0]);
6502 float last_sample7 = sample7;
6503 float last_sample6 = sample6;
6504 float last_sample5 = sample5;
6505 float last_sample4 = sample4;
6506 float last_sample3 = sample3;
6507 float last_sample2 = sample2;
6508 float last_sample1 = sample1;
6509 float last_sample0 = sample0;
6510 while (dst >= target) {
6511 dst[7] = SDL_SwapFloatLE(sample7);
6512 dst[6] = SDL_SwapFloatLE(sample6);
6513 dst[5] = SDL_SwapFloatLE(sample5);
6514 dst[4] = SDL_SwapFloatLE(sample4);
6515 dst[3] = SDL_SwapFloatLE(sample3);
6516 dst[2] = SDL_SwapFloatLE(sample2);
6517 dst[1] = SDL_SwapFloatLE(sample1);
6518 dst[0] = SDL_SwapFloatLE(sample0);
6519 dst -= 8;
6520 eps += srcsize;
6521 if ((eps << 1) >= dstsize) {
6522 src -= 8;
6523 sample7 = (float) ((((double) SDL_SwapFloatLE(src[7])) + ((double) last_sample7)) * 0.5);
6524 sample6 = (float) ((((double) SDL_SwapFloatLE(src[6])) + ((double) last_sample6)) * 0.5);
6525 sample5 = (float) ((((double) SDL_SwapFloatLE(src[5])) + ((double) last_sample5)) * 0.5);
6526 sample4 = (float) ((((double) SDL_SwapFloatLE(src[4])) + ((double) last_sample4)) * 0.5);
6527 sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
6528 sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
6529 sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
6530 sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
6531 last_sample7 = sample7;
6532 last_sample6 = sample6;
6533 last_sample5 = sample5;
6534 last_sample4 = sample4;
6535 last_sample3 = sample3;
6536 last_sample2 = sample2;
6537 last_sample1 = sample1;
6538 last_sample0 = sample0;
6539 eps -= dstsize;
6540 }
6541 }
6542 cvt->len_cvt = dstsize;
6543 if (cvt->filters[++cvt->filter_index]) {
6544 cvt->filters[cvt->filter_index] (cvt, format);
6545 }
6546 }
6547
6548 static void SDLCALL
6549 SDL_Downsample_F32LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6550 {
6551 #if DEBUG_CONVERT
6552 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32LSB, 8 channels.\n", cvt->rate_incr);
6553 #endif
6554
6555 const int srcsize = cvt->len_cvt - 512;
6556 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6557 register int eps = 0;
6558 float *dst = (float *) cvt->buf;
6559 const float *src = (float *) cvt->buf;
6560 const float *target = (const float *) (cvt->buf + dstsize);
6561 float sample0 = SDL_SwapFloatLE(src[0]);
6562 float sample1 = SDL_SwapFloatLE(src[1]);
6563 float sample2 = SDL_SwapFloatLE(src[2]);
6564 float sample3 = SDL_SwapFloatLE(src[3]);
6565 float sample4 = SDL_SwapFloatLE(src[4]);
6566 float sample5 = SDL_SwapFloatLE(src[5]);
6567 float sample6 = SDL_SwapFloatLE(src[6]);
6568 float sample7 = SDL_SwapFloatLE(src[7]);
6569 float last_sample0 = sample0;
6570 float last_sample1 = sample1;
6571 float last_sample2 = sample2;
6572 float last_sample3 = sample3;
6573 float last_sample4 = sample4;
6574 float last_sample5 = sample5;
6575 float last_sample6 = sample6;
6576 float last_sample7 = sample7;
6577 while (dst < target) {
6578 src += 8;
6579 eps += dstsize;
6580 if ((eps << 1) >= srcsize) {
6581 dst[0] = SDL_SwapFloatLE(sample0);
6582 dst[1] = SDL_SwapFloatLE(sample1);
6583 dst[2] = SDL_SwapFloatLE(sample2);
6584 dst[3] = SDL_SwapFloatLE(sample3);
6585 dst[4] = SDL_SwapFloatLE(sample4);
6586 dst[5] = SDL_SwapFloatLE(sample5);
6587 dst[6] = SDL_SwapFloatLE(sample6);
6588 dst[7] = SDL_SwapFloatLE(sample7);
6589 dst += 8;
6590 sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
6591 sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
6592 sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
6593 sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
6594 sample4 = (float) ((((double) SDL_SwapFloatLE(src[4])) + ((double) last_sample4)) * 0.5);
6595 sample5 = (float) ((((double) SDL_SwapFloatLE(src[5])) + ((double) last_sample5)) * 0.5);
6596 sample6 = (float) ((((double) SDL_SwapFloatLE(src[6])) + ((double) last_sample6)) * 0.5);
6597 sample7 = (float) ((((double) SDL_SwapFloatLE(src[7])) + ((double) last_sample7)) * 0.5);
6598 last_sample0 = sample0;
6599 last_sample1 = sample1;
6600 last_sample2 = sample2;
6601 last_sample3 = sample3;
6602 last_sample4 = sample4;
6603 last_sample5 = sample5;
6604 last_sample6 = sample6;
6605 last_sample7 = sample7;
6606 eps -= srcsize;
6607 }
6608 }
6609 cvt->len_cvt = dstsize;
6610 if (cvt->filters[++cvt->filter_index]) {
6611 cvt->filters[cvt->filter_index] (cvt, format);
6612 }
6613 }
6614
6615 static void SDLCALL
6616 SDL_Upsample_F32MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6617 {
6618 #if DEBUG_CONVERT
6619 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32MSB, 1 channels.\n", cvt->rate_incr);
6620 #endif
6621
6622 const int srcsize = cvt->len_cvt - 64;
6623 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6624 register int eps = 0;
6625 float *dst = ((float *) (cvt->buf + dstsize)) - 1;
6626 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
6627 const float *target = ((const float *) cvt->buf);
6628 float sample0 = SDL_SwapFloatBE(src[0]);
6629 float last_sample0 = sample0;
6630 while (dst >= target) {
6631 dst[0] = SDL_SwapFloatBE(sample0);
6632 dst--;
6633 eps += srcsize;
6634 if ((eps << 1) >= dstsize) {
6635 src--;
6636 sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
6637 last_sample0 = sample0;
6638 eps -= dstsize;
6639 }
6640 }
6641 cvt->len_cvt = dstsize;
6642 if (cvt->filters[++cvt->filter_index]) {
6643 cvt->filters[cvt->filter_index] (cvt, format);
6644 }
6645 }
6646
6647 static void SDLCALL
6648 SDL_Downsample_F32MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6649 {
6650 #if DEBUG_CONVERT
6651 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32MSB, 1 channels.\n", cvt->rate_incr);
6652 #endif
6653
6654 const int srcsize = cvt->len_cvt - 64;
6655 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6656 register int eps = 0;
6657 float *dst = (float *) cvt->buf;
6658 const float *src = (float *) cvt->buf;
6659 const float *target = (const float *) (cvt->buf + dstsize);
6660 float sample0 = SDL_SwapFloatBE(src[0]);
6661 float last_sample0 = sample0;
6662 while (dst < target) {
6663 src++;
6664 eps += dstsize;
6665 if ((eps << 1) >= srcsize) {
6666 dst[0] = SDL_SwapFloatBE(sample0);
6667 dst++;
6668 sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
6669 last_sample0 = sample0;
6670 eps -= srcsize;
6671 }
6672 }
6673 cvt->len_cvt = dstsize;
6674 if (cvt->filters[++cvt->filter_index]) {
6675 cvt->filters[cvt->filter_index] (cvt, format);
6676 }
6677 }
6678
6679 static void SDLCALL
6680 SDL_Upsample_F32MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6681 {
6682 #if DEBUG_CONVERT
6683 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32MSB, 2 channels.\n", cvt->rate_incr);
6684 #endif
6685
6686 const int srcsize = cvt->len_cvt - 128;
6687 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6688 register int eps = 0;
6689 float *dst = ((float *) (cvt->buf + dstsize)) - 2;
6690 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
6691 const float *target = ((const float *) cvt->buf);
6692 float sample1 = SDL_SwapFloatBE(src[1]);
6693 float sample0 = SDL_SwapFloatBE(src[0]);
6694 float last_sample1 = sample1;
6695 float last_sample0 = sample0;
6696 while (dst >= target) {
6697 dst[1] = SDL_SwapFloatBE(sample1);
6698 dst[0] = SDL_SwapFloatBE(sample0);
6699 dst -= 2;
6700 eps += srcsize;
6701 if ((eps << 1) >= dstsize) {
6702 src -= 2;
6703 sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
6704 sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
6705 last_sample1 = sample1;
6706 last_sample0 = sample0;
6707 eps -= dstsize;
6708 }
6709 }
6710 cvt->len_cvt = dstsize;
6711 if (cvt->filters[++cvt->filter_index]) {
6712 cvt->filters[cvt->filter_index] (cvt, format);
6713 }
6714 }
6715
6716 static void SDLCALL
6717 SDL_Downsample_F32MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6718 {
6719 #if DEBUG_CONVERT
6720 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32MSB, 2 channels.\n", cvt->rate_incr);
6721 #endif
6722
6723 const int srcsize = cvt->len_cvt - 128;
6724 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6725 register int eps = 0;
6726 float *dst = (float *) cvt->buf;
6727 const float *src = (float *) cvt->buf;
6728 const float *target = (const float *) (cvt->buf + dstsize);
6729 float sample0 = SDL_SwapFloatBE(src[0]);
6730 float sample1 = SDL_SwapFloatBE(src[1]);
6731 float last_sample0 = sample0;
6732 float last_sample1 = sample1;
6733 while (dst < target) {
6734 src += 2;
6735 eps += dstsize;
6736 if ((eps << 1) >= srcsize) {
6737 dst[0] = SDL_SwapFloatBE(sample0);
6738 dst[1] = SDL_SwapFloatBE(sample1);
6739 dst += 2;
6740 sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
6741 sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
6742 last_sample0 = sample0;
6743 last_sample1 = sample1;
6744 eps -= srcsize;
6745 }
6746 }
6747 cvt->len_cvt = dstsize;
6748 if (cvt->filters[++cvt->filter_index]) {
6749 cvt->filters[cvt->filter_index] (cvt, format);
6750 }
6751 }
6752
6753 static void SDLCALL
6754 SDL_Upsample_F32MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6755 {
6756 #if DEBUG_CONVERT
6757 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32MSB, 4 channels.\n", cvt->rate_incr);
6758 #endif
6759
6760 const int srcsize = cvt->len_cvt - 256;
6761 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6762 register int eps = 0;
6763 float *dst = ((float *) (cvt->buf + dstsize)) - 4;
6764 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
6765 const float *target = ((const float *) cvt->buf);
6766 float sample3 = SDL_SwapFloatBE(src[3]);
6767 float sample2 = SDL_SwapFloatBE(src[2]);
6768 float sample1 = SDL_SwapFloatBE(src[1]);
6769 float sample0 = SDL_SwapFloatBE(src[0]);
6770 float last_sample3 = sample3;
6771 float last_sample2 = sample2;
6772 float last_sample1 = sample1;
6773 float last_sample0 = sample0;
6774 while (dst >= target) {
6775 dst[3] = SDL_SwapFloatBE(sample3);
6776 dst[2] = SDL_SwapFloatBE(sample2);
6777 dst[1] = SDL_SwapFloatBE(sample1);
6778 dst[0] = SDL_SwapFloatBE(sample0);
6779 dst -= 4;
6780 eps += srcsize;
6781 if ((eps << 1) >= dstsize) {
6782 src -= 4;
6783 sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
6784 sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
6785 sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
6786 sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
6787 last_sample3 = sample3;
6788 last_sample2 = sample2;
6789 last_sample1 = sample1;
6790 last_sample0 = sample0;
6791 eps -= dstsize;
6792 }
6793 }
6794 cvt->len_cvt = dstsize;
6795 if (cvt->filters[++cvt->filter_index]) {
6796 cvt->filters[cvt->filter_index] (cvt, format);
6797 }
6798 }
6799
6800 static void SDLCALL
6801 SDL_Downsample_F32MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6802 {
6803 #if DEBUG_CONVERT
6804 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32MSB, 4 channels.\n", cvt->rate_incr);
6805 #endif
6806
6807 const int srcsize = cvt->len_cvt - 256;
6808 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6809 register int eps = 0;
6810 float *dst = (float *) cvt->buf;
6811 const float *src = (float *) cvt->buf;
6812 const float *target = (const float *) (cvt->buf + dstsize);
6813 float sample0 = SDL_SwapFloatBE(src[0]);
6814 float sample1 = SDL_SwapFloatBE(src[1]);
6815 float sample2 = SDL_SwapFloatBE(src[2]);
6816 float sample3 = SDL_SwapFloatBE(src[3]);
6817 float last_sample0 = sample0;
6818 float last_sample1 = sample1;
6819 float last_sample2 = sample2;
6820 float last_sample3 = sample3;
6821 while (dst < target) {
6822 src += 4;
6823 eps += dstsize;
6824 if ((eps << 1) >= srcsize) {
6825 dst[0] = SDL_SwapFloatBE(sample0);
6826 dst[1] = SDL_SwapFloatBE(sample1);
6827 dst[2] = SDL_SwapFloatBE(sample2);
6828 dst[3] = SDL_SwapFloatBE(sample3);
6829 dst += 4;
6830 sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
6831 sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
6832 sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
6833 sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
6834 last_sample0 = sample0;
6835 last_sample1 = sample1;
6836 last_sample2 = sample2;
6837 last_sample3 = sample3;
6838 eps -= srcsize;
6839 }
6840 }
6841 cvt->len_cvt = dstsize;
6842 if (cvt->filters[++cvt->filter_index]) {
6843 cvt->filters[cvt->filter_index] (cvt, format);
6844 }
6845 }
6846
6847 static void SDLCALL
6848 SDL_Upsample_F32MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6849 {
6850 #if DEBUG_CONVERT
6851 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32MSB, 6 channels.\n", cvt->rate_incr);
6852 #endif
6853
6854 const int srcsize = cvt->len_cvt - 384;
6855 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6856 register int eps = 0;
6857 float *dst = ((float *) (cvt->buf + dstsize)) - 6;
6858 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
6859 const float *target = ((const float *) cvt->buf);
6860 float sample5 = SDL_SwapFloatBE(src[5]);
6861 float sample4 = SDL_SwapFloatBE(src[4]);
6862 float sample3 = SDL_SwapFloatBE(src[3]);
6863 float sample2 = SDL_SwapFloatBE(src[2]);
6864 float sample1 = SDL_SwapFloatBE(src[1]);
6865 float sample0 = SDL_SwapFloatBE(src[0]);
6866 float last_sample5 = sample5;
6867 float last_sample4 = sample4;
6868 float last_sample3 = sample3;
6869 float last_sample2 = sample2;
6870 float last_sample1 = sample1;
6871 float last_sample0 = sample0;
6872 while (dst >= target) {
6873 dst[5] = SDL_SwapFloatBE(sample5);
6874 dst[4] = SDL_SwapFloatBE(sample4);
6875 dst[3] = SDL_SwapFloatBE(sample3);
6876 dst[2] = SDL_SwapFloatBE(sample2);
6877 dst[1] = SDL_SwapFloatBE(sample1);
6878 dst[0] = SDL_SwapFloatBE(sample0);
6879 dst -= 6;
6880 eps += srcsize;
6881 if ((eps << 1) >= dstsize) {
6882 src -= 6;
6883 sample5 = (float) ((((double) SDL_SwapFloatBE(src[5])) + ((double) last_sample5)) * 0.5);
6884 sample4 = (float) ((((double) SDL_SwapFloatBE(src[4])) + ((double) last_sample4)) * 0.5);
6885 sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
6886 sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
6887 sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
6888 sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
6889 last_sample5 = sample5;
6890 last_sample4 = sample4;
6891 last_sample3 = sample3;
6892 last_sample2 = sample2;
6893 last_sample1 = sample1;
6894 last_sample0 = sample0;
6895 eps -= dstsize;
6896 }
6897 }
6898 cvt->len_cvt = dstsize;
6899 if (cvt->filters[++cvt->filter_index]) {
6900 cvt->filters[cvt->filter_index] (cvt, format);
6901 }
6902 }
6903
6904 static void SDLCALL
6905 SDL_Downsample_F32MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6906 {
6907 #if DEBUG_CONVERT
6908 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32MSB, 6 channels.\n", cvt->rate_incr);
6909 #endif
6910
6911 const int srcsize = cvt->len_cvt - 384;
6912 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6913 register int eps = 0;
6914 float *dst = (float *) cvt->buf;
6915 const float *src = (float *) cvt->buf;
6916 const float *target = (const float *) (cvt->buf + dstsize);
6917 float sample0 = SDL_SwapFloatBE(src[0]);
6918 float sample1 = SDL_SwapFloatBE(src[1]);
6919 float sample2 = SDL_SwapFloatBE(src[2]);
6920 float sample3 = SDL_SwapFloatBE(src[3]);
6921 float sample4 = SDL_SwapFloatBE(src[4]);
6922 float sample5 = SDL_SwapFloatBE(src[5]);
6923 float last_sample0 = sample0;
6924 float last_sample1 = sample1;
6925 float last_sample2 = sample2;
6926 float last_sample3 = sample3;
6927 float last_sample4 = sample4;
6928 float last_sample5 = sample5;
6929 while (dst < target) {
6930 src += 6;
6931 eps += dstsize;
6932 if ((eps << 1) >= srcsize) {
6933 dst[0] = SDL_SwapFloatBE(sample0);
6934 dst[1] = SDL_SwapFloatBE(sample1);
6935 dst[2] = SDL_SwapFloatBE(sample2);
6936 dst[3] = SDL_SwapFloatBE(sample3);
6937 dst[4] = SDL_SwapFloatBE(sample4);
6938 dst[5] = SDL_SwapFloatBE(sample5);
6939 dst += 6;
6940 sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
6941 sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
6942 sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
6943 sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
6944 sample4 = (float) ((((double) SDL_SwapFloatBE(src[4])) + ((double) last_sample4)) * 0.5);
6945 sample5 = (float) ((((double) SDL_SwapFloatBE(src[5])) + ((double) last_sample5)) * 0.5);
6946 last_sample0 = sample0;
6947 last_sample1 = sample1;
6948 last_sample2 = sample2;
6949 last_sample3 = sample3;
6950 last_sample4 = sample4;
6951 last_sample5 = sample5;
6952 eps -= srcsize;
6953 }
6954 }
6955 cvt->len_cvt = dstsize;
6956 if (cvt->filters[++cvt->filter_index]) {
6957 cvt->filters[cvt->filter_index] (cvt, format);
6958 }
6959 }
6960
6961 static void SDLCALL
6962 SDL_Upsample_F32MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
6963 {
6964 #if DEBUG_CONVERT
6965 fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32MSB, 8 channels.\n", cvt->rate_incr);
6966 #endif
6967
6968 const int srcsize = cvt->len_cvt - 512;
6969 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
6970 register int eps = 0;
6971 float *dst = ((float *) (cvt->buf + dstsize)) - 8;
6972 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
6973 const float *target = ((const float *) cvt->buf);
6974 float sample7 = SDL_SwapFloatBE(src[7]);
6975 float sample6 = SDL_SwapFloatBE(src[6]);
6976 float sample5 = SDL_SwapFloatBE(src[5]);
6977 float sample4 = SDL_SwapFloatBE(src[4]);
6978 float sample3 = SDL_SwapFloatBE(src[3]);
6979 float sample2 = SDL_SwapFloatBE(src[2]);
6980 float sample1 = SDL_SwapFloatBE(src[1]);
6981 float sample0 = SDL_SwapFloatBE(src[0]);
6982 float last_sample7 = sample7;
6983 float last_sample6 = sample6;
6984 float last_sample5 = sample5;
6985 float last_sample4 = sample4;
6986 float last_sample3 = sample3;
6987 float last_sample2 = sample2;
6988 float last_sample1 = sample1;
6989 float last_sample0 = sample0;
6990 while (dst >= target) {
6991 dst[7] = SDL_SwapFloatBE(sample7);
6992 dst[6] = SDL_SwapFloatBE(sample6);
6993 dst[5] = SDL_SwapFloatBE(sample5);
6994 dst[4] = SDL_SwapFloatBE(sample4);
6995 dst[3] = SDL_SwapFloatBE(sample3);
6996 dst[2] = SDL_SwapFloatBE(sample2);
6997 dst[1] = SDL_SwapFloatBE(sample1);
6998 dst[0] = SDL_SwapFloatBE(sample0);
6999 dst -= 8;
7000 eps += srcsize;
7001 if ((eps << 1) >= dstsize) {
7002 src -= 8;
7003 sample7 = (float) ((((double) SDL_SwapFloatBE(src[7])) + ((double) last_sample7)) * 0.5);
7004 sample6 = (float) ((((double) SDL_SwapFloatBE(src[6])) + ((double) last_sample6)) * 0.5);
7005 sample5 = (float) ((((double) SDL_SwapFloatBE(src[5])) + ((double) last_sample5)) * 0.5);
7006 sample4 = (float) ((((double) SDL_SwapFloatBE(src[4])) + ((double) last_sample4)) * 0.5);
7007 sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
7008 sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
7009 sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
7010 sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
7011 last_sample7 = sample7;
7012 last_sample6 = sample6;
7013 last_sample5 = sample5;
7014 last_sample4 = sample4;
7015 last_sample3 = sample3;
7016 last_sample2 = sample2;
7017 last_sample1 = sample1;
7018 last_sample0 = sample0;
7019 eps -= dstsize;
7020 }
7021 }
7022 cvt->len_cvt = dstsize;
7023 if (cvt->filters[++cvt->filter_index]) {
7024 cvt->filters[cvt->filter_index] (cvt, format);
7025 }
7026 }
7027
7028 static void SDLCALL
7029 SDL_Downsample_F32MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7030 {
7031 #if DEBUG_CONVERT
7032 fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32MSB, 8 channels.\n", cvt->rate_incr);
7033 #endif
7034
7035 const int srcsize = cvt->len_cvt - 512;
7036 const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
7037 register int eps = 0;
7038 float *dst = (float *) cvt->buf;
7039 const float *src = (float *) cvt->buf;
7040 const float *target = (const float *) (cvt->buf + dstsize);
7041 float sample0 = SDL_SwapFloatBE(src[0]);
7042 float sample1 = SDL_SwapFloatBE(src[1]);
7043 float sample2 = SDL_SwapFloatBE(src[2]);
7044 float sample3 = SDL_SwapFloatBE(src[3]);
7045 float sample4 = SDL_SwapFloatBE(src[4]);
7046 float sample5 = SDL_SwapFloatBE(src[5]);
7047 float sample6 = SDL_SwapFloatBE(src[6]);
7048 float sample7 = SDL_SwapFloatBE(src[7]);
7049 float last_sample0 = sample0;
7050 float last_sample1 = sample1;
7051 float last_sample2 = sample2;
7052 float last_sample3 = sample3;
7053 float last_sample4 = sample4;
7054 float last_sample5 = sample5;
7055 float last_sample6 = sample6;
7056 float last_sample7 = sample7;
7057 while (dst < target) {
7058 src += 8;
7059 eps += dstsize;
7060 if ((eps << 1) >= srcsize) {
7061 dst[0] = SDL_SwapFloatBE(sample0);
7062 dst[1] = SDL_SwapFloatBE(sample1);
7063 dst[2] = SDL_SwapFloatBE(sample2);
7064 dst[3] = SDL_SwapFloatBE(sample3);
7065 dst[4] = SDL_SwapFloatBE(sample4);
7066 dst[5] = SDL_SwapFloatBE(sample5);
7067 dst[6] = SDL_SwapFloatBE(sample6);
7068 dst[7] = SDL_SwapFloatBE(sample7);
7069 dst += 8;
7070 sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
7071 sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
7072 sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
7073 sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
7074 sample4 = (float) ((((double) SDL_SwapFloatBE(src[4])) + ((double) last_sample4)) * 0.5);
7075 sample5 = (float) ((((double) SDL_SwapFloatBE(src[5])) + ((double) last_sample5)) * 0.5);
7076 sample6 = (float) ((((double) SDL_SwapFloatBE(src[6])) + ((double) last_sample6)) * 0.5);
7077 sample7 = (float) ((((double) SDL_SwapFloatBE(src[7])) + ((double) last_sample7)) * 0.5);
7078 last_sample0 = sample0;
7079 last_sample1 = sample1;
7080 last_sample2 = sample2;
7081 last_sample3 = sample3;
7082 last_sample4 = sample4;
7083 last_sample5 = sample5;
7084 last_sample6 = sample6;
7085 last_sample7 = sample7;
7086 eps -= srcsize;
7087 }
7088 }
7089 cvt->len_cvt = dstsize;
7090 if (cvt->filters[++cvt->filter_index]) {
7091 cvt->filters[cvt->filter_index] (cvt, format);
7092 }
7093 }
7094
7095
7096 #if !LESS_RESAMPLERS
7097
7098 static void SDLCALL
7099 SDL_Upsample_U8_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7100 {
7101 #if DEBUG_CONVERT
7102 fprintf(stderr, "Upsample (x2) AUDIO_U8, 1 channels.\n");
7103 #endif
7104
7105 const int dstsize = cvt->len_cvt * 2;
7106 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 1 * 2;
7107 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
7108 const Uint8 *target = ((const Uint8 *) cvt->buf);
7109 Sint16 last_sample0 = (Sint16) src[0];
7110 while (dst >= target) {
7111 const Sint16 sample0 = (Sint16) src[0];
7112 src--;
7113 dst[1] = (Uint8) ((sample0 + last_sample0) >> 1);
7114 dst[0] = (Uint8) sample0;
7115 last_sample0 = sample0;
7116 dst -= 2;
7117 }
7118
7119 cvt->len_cvt = dstsize;
7120 if (cvt->filters[++cvt->filter_index]) {
7121 cvt->filters[cvt->filter_index] (cvt, format);
7122 }
7123 }
7124
7125 static void SDLCALL
7126 SDL_Downsample_U8_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7127 {
7128 #if DEBUG_CONVERT
7129 fprintf(stderr, "Downsample (x2) AUDIO_U8, 1 channels.\n");
7130 #endif
7131
7132 const int dstsize = cvt->len_cvt / 2;
7133 Uint8 *dst = (Uint8 *) cvt->buf;
7134 const Uint8 *src = (Uint8 *) cvt->buf;
7135 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
7136 Sint16 last_sample0 = (Sint16) src[0];
7137 while (dst < target) {
7138 const Sint16 sample0 = (Sint16) src[0];
7139 src += 2;
7140 dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
7141 last_sample0 = sample0;
7142 dst++;
7143 }
7144
7145 cvt->len_cvt = dstsize;
7146 if (cvt->filters[++cvt->filter_index]) {
7147 cvt->filters[cvt->filter_index] (cvt, format);
7148 }
7149 }
7150
7151 static void SDLCALL
7152 SDL_Upsample_U8_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7153 {
7154 #if DEBUG_CONVERT
7155 fprintf(stderr, "Upsample (x4) AUDIO_U8, 1 channels.\n");
7156 #endif
7157
7158 const int dstsize = cvt->len_cvt * 4;
7159 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 1 * 4;
7160 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
7161 const Uint8 *target = ((const Uint8 *) cvt->buf);
7162 Sint16 last_sample0 = (Sint16) src[0];
7163 while (dst >= target) {
7164 const Sint16 sample0 = (Sint16) src[0];
7165 src--;
7166 dst[3] = (Uint8) ((sample0 + (3 * last_sample0)) >> 2);
7167 dst[2] = (Uint8) ((sample0 + last_sample0) >> 1);
7168 dst[1] = (Uint8) (((3 * sample0) + last_sample0) >> 2);
7169 dst[0] = (Uint8) sample0;
7170 last_sample0 = sample0;
7171 dst -= 4;
7172 }
7173
7174 cvt->len_cvt = dstsize;
7175 if (cvt->filters[++cvt->filter_index]) {
7176 cvt->filters[cvt->filter_index] (cvt, format);
7177 }
7178 }
7179
7180 static void SDLCALL
7181 SDL_Downsample_U8_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7182 {
7183 #if DEBUG_CONVERT
7184 fprintf(stderr, "Downsample (x4) AUDIO_U8, 1 channels.\n");
7185 #endif
7186
7187 const int dstsize = cvt->len_cvt / 4;
7188 Uint8 *dst = (Uint8 *) cvt->buf;
7189 const Uint8 *src = (Uint8 *) cvt->buf;
7190 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
7191 Sint16 last_sample0 = (Sint16) src[0];
7192 while (dst < target) {
7193 const Sint16 sample0 = (Sint16) src[0];
7194 src += 4;
7195 dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
7196 last_sample0 = sample0;
7197 dst++;
7198 }
7199
7200 cvt->len_cvt = dstsize;
7201 if (cvt->filters[++cvt->filter_index]) {
7202 cvt->filters[cvt->filter_index] (cvt, format);
7203 }
7204 }
7205
7206 static void SDLCALL
7207 SDL_Upsample_U8_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7208 {
7209 #if DEBUG_CONVERT
7210 fprintf(stderr, "Upsample (x2) AUDIO_U8, 2 channels.\n");
7211 #endif
7212
7213 const int dstsize = cvt->len_cvt * 2;
7214 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 2 * 2;
7215 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 2;
7216 const Uint8 *target = ((const Uint8 *) cvt->buf);
7217 Sint16 last_sample1 = (Sint16) src[1];
7218 Sint16 last_sample0 = (Sint16) src[0];
7219 while (dst >= target) {
7220 const Sint16 sample1 = (Sint16) src[1];
7221 const Sint16 sample0 = (Sint16) src[0];
7222 src -= 2;
7223 dst[3] = (Uint8) ((sample1 + last_sample1) >> 1);
7224 dst[2] = (Uint8) ((sample0 + last_sample0) >> 1);
7225 dst[1] = (Uint8) sample1;
7226 dst[0] = (Uint8) sample0;
7227 last_sample1 = sample1;
7228 last_sample0 = sample0;
7229 dst -= 4;
7230 }
7231
7232 cvt->len_cvt = dstsize;
7233 if (cvt->filters[++cvt->filter_index]) {
7234 cvt->filters[cvt->filter_index] (cvt, format);
7235 }
7236 }
7237
7238 static void SDLCALL
7239 SDL_Downsample_U8_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7240 {
7241 #if DEBUG_CONVERT
7242 fprintf(stderr, "Downsample (x2) AUDIO_U8, 2 channels.\n");
7243 #endif
7244
7245 const int dstsize = cvt->len_cvt / 2;
7246 Uint8 *dst = (Uint8 *) cvt->buf;
7247 const Uint8 *src = (Uint8 *) cvt->buf;
7248 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
7249 Sint16 last_sample0 = (Sint16) src[0];
7250 Sint16 last_sample1 = (Sint16) src[1];
7251 while (dst < target) {
7252 const Sint16 sample0 = (Sint16) src[0];
7253 const Sint16 sample1 = (Sint16) src[1];
7254 src += 4;
7255 dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
7256 dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
7257 last_sample0 = sample0;
7258 last_sample1 = sample1;
7259 dst += 2;
7260 }
7261
7262 cvt->len_cvt = dstsize;
7263 if (cvt->filters[++cvt->filter_index]) {
7264 cvt->filters[cvt->filter_index] (cvt, format);
7265 }
7266 }
7267
7268 static void SDLCALL
7269 SDL_Upsample_U8_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7270 {
7271 #if DEBUG_CONVERT
7272 fprintf(stderr, "Upsample (x4) AUDIO_U8, 2 channels.\n");
7273 #endif
7274
7275 const int dstsize = cvt->len_cvt * 4;
7276 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 2 * 4;
7277 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 2;
7278 const Uint8 *target = ((const Uint8 *) cvt->buf);
7279 Sint16 last_sample1 = (Sint16) src[1];
7280 Sint16 last_sample0 = (Sint16) src[0];
7281 while (dst >= target) {
7282 const Sint16 sample1 = (Sint16) src[1];
7283 const Sint16 sample0 = (Sint16) src[0];
7284 src -= 2;
7285 dst[7] = (Uint8) ((sample1 + (3 * last_sample1)) >> 2);
7286 dst[6] = (Uint8) ((sample0 + (3 * last_sample0)) >> 2);
7287 dst[5] = (Uint8) ((sample1 + last_sample1) >> 1);
7288 dst[4] = (Uint8) ((sample0 + last_sample0) >> 1);
7289 dst[3] = (Uint8) (((3 * sample1) + last_sample1) >> 2);
7290 dst[2] = (Uint8) (((3 * sample0) + last_sample0) >> 2);
7291 dst[1] = (Uint8) sample1;
7292 dst[0] = (Uint8) sample0;
7293 last_sample1 = sample1;
7294 last_sample0 = sample0;
7295 dst -= 8;
7296 }
7297
7298 cvt->len_cvt = dstsize;
7299 if (cvt->filters[++cvt->filter_index]) {
7300 cvt->filters[cvt->filter_index] (cvt, format);
7301 }
7302 }
7303
7304 static void SDLCALL
7305 SDL_Downsample_U8_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7306 {
7307 #if DEBUG_CONVERT
7308 fprintf(stderr, "Downsample (x4) AUDIO_U8, 2 channels.\n");
7309 #endif
7310
7311 const int dstsize = cvt->len_cvt / 4;
7312 Uint8 *dst = (Uint8 *) cvt->buf;
7313 const Uint8 *src = (Uint8 *) cvt->buf;
7314 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
7315 Sint16 last_sample0 = (Sint16) src[0];
7316 Sint16 last_sample1 = (Sint16) src[1];
7317 while (dst < target) {
7318 const Sint16 sample0 = (Sint16) src[0];
7319 const Sint16 sample1 = (Sint16) src[1];
7320 src += 8;
7321 dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
7322 dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
7323 last_sample0 = sample0;
7324 last_sample1 = sample1;
7325 dst += 2;
7326 }
7327
7328 cvt->len_cvt = dstsize;
7329 if (cvt->filters[++cvt->filter_index]) {
7330 cvt->filters[cvt->filter_index] (cvt, format);
7331 }
7332 }
7333
7334 static void SDLCALL
7335 SDL_Upsample_U8_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7336 {
7337 #if DEBUG_CONVERT
7338 fprintf(stderr, "Upsample (x2) AUDIO_U8, 4 channels.\n");
7339 #endif
7340
7341 const int dstsize = cvt->len_cvt * 2;
7342 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 4 * 2;
7343 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 4;
7344 const Uint8 *target = ((const Uint8 *) cvt->buf);
7345 Sint16 last_sample3 = (Sint16) src[3];
7346 Sint16 last_sample2 = (Sint16) src[2];
7347 Sint16 last_sample1 = (Sint16) src[1];
7348 Sint16 last_sample0 = (Sint16) src[0];
7349 while (dst >= target) {
7350 const Sint16 sample3 = (Sint16) src[3];
7351 const Sint16 sample2 = (Sint16) src[2];
7352 const Sint16 sample1 = (Sint16) src[1];
7353 const Sint16 sample0 = (Sint16) src[0];
7354 src -= 4;
7355 dst[7] = (Uint8) ((sample3 + last_sample3) >> 1);
7356 dst[6] = (Uint8) ((sample2 + last_sample2) >> 1);
7357 dst[5] = (Uint8) ((sample1 + last_sample1) >> 1);
7358 dst[4] = (Uint8) ((sample0 + last_sample0) >> 1);
7359 dst[3] = (Uint8) sample3;
7360 dst[2] = (Uint8) sample2;
7361 dst[1] = (Uint8) sample1;
7362 dst[0] = (Uint8) sample0;
7363 last_sample3 = sample3;
7364 last_sample2 = sample2;
7365 last_sample1 = sample1;
7366 last_sample0 = sample0;
7367 dst -= 8;
7368 }
7369
7370 cvt->len_cvt = dstsize;
7371 if (cvt->filters[++cvt->filter_index]) {
7372 cvt->filters[cvt->filter_index] (cvt, format);
7373 }
7374 }
7375
7376 static void SDLCALL
7377 SDL_Downsample_U8_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7378 {
7379 #if DEBUG_CONVERT
7380 fprintf(stderr, "Downsample (x2) AUDIO_U8, 4 channels.\n");
7381 #endif
7382
7383 const int dstsize = cvt->len_cvt / 2;
7384 Uint8 *dst = (Uint8 *) cvt->buf;
7385 const Uint8 *src = (Uint8 *) cvt->buf;
7386 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
7387 Sint16 last_sample0 = (Sint16) src[0];
7388 Sint16 last_sample1 = (Sint16) src[1];
7389 Sint16 last_sample2 = (Sint16) src[2];
7390 Sint16 last_sample3 = (Sint16) src[3];
7391 while (dst < target) {
7392 const Sint16 sample0 = (Sint16) src[0];
7393 const Sint16 sample1 = (Sint16) src[1];
7394 const Sint16 sample2 = (Sint16) src[2];
7395 const Sint16 sample3 = (Sint16) src[3];
7396 src += 8;
7397 dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
7398 dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
7399 dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
7400 dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
7401 last_sample0 = sample0;
7402 last_sample1 = sample1;
7403 last_sample2 = sample2;
7404 last_sample3 = sample3;
7405 dst += 4;
7406 }
7407
7408 cvt->len_cvt = dstsize;
7409 if (cvt->filters[++cvt->filter_index]) {
7410 cvt->filters[cvt->filter_index] (cvt, format);
7411 }
7412 }
7413
7414 static void SDLCALL
7415 SDL_Upsample_U8_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7416 {
7417 #if DEBUG_CONVERT
7418 fprintf(stderr, "Upsample (x4) AUDIO_U8, 4 channels.\n");
7419 #endif
7420
7421 const int dstsize = cvt->len_cvt * 4;
7422 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 4 * 4;
7423 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 4;
7424 const Uint8 *target = ((const Uint8 *) cvt->buf);
7425 Sint16 last_sample3 = (Sint16) src[3];
7426 Sint16 last_sample2 = (Sint16) src[2];
7427 Sint16 last_sample1 = (Sint16) src[1];
7428 Sint16 last_sample0 = (Sint16) src[0];
7429 while (dst >= target) {
7430 const Sint16 sample3 = (Sint16) src[3];
7431 const Sint16 sample2 = (Sint16) src[2];
7432 const Sint16 sample1 = (Sint16) src[1];
7433 const Sint16 sample0 = (Sint16) src[0];
7434 src -= 4;
7435 dst[15] = (Uint8) ((sample3 + (3 * last_sample3)) >> 2);
7436 dst[14] = (Uint8) ((sample2 + (3 * last_sample2)) >> 2);
7437 dst[13] = (Uint8) ((sample1 + (3 * last_sample1)) >> 2);
7438 dst[12] = (Uint8) ((sample0 + (3 * last_sample0)) >> 2);
7439 dst[11] = (Uint8) ((sample3 + last_sample3) >> 1);
7440 dst[10] = (Uint8) ((sample2 + last_sample2) >> 1);
7441 dst[9] = (Uint8) ((sample1 + last_sample1) >> 1);
7442 dst[8] = (Uint8) ((sample0 + last_sample0) >> 1);
7443 dst[7] = (Uint8) (((3 * sample3) + last_sample3) >> 2);
7444 dst[6] = (Uint8) (((3 * sample2) + last_sample2) >> 2);
7445 dst[5] = (Uint8) (((3 * sample1) + last_sample1) >> 2);
7446 dst[4] = (Uint8) (((3 * sample0) + last_sample0) >> 2);
7447 dst[3] = (Uint8) sample3;
7448 dst[2] = (Uint8) sample2;
7449 dst[1] = (Uint8) sample1;
7450 dst[0] = (Uint8) sample0;
7451 last_sample3 = sample3;
7452 last_sample2 = sample2;
7453 last_sample1 = sample1;
7454 last_sample0 = sample0;
7455 dst -= 16;
7456 }
7457
7458 cvt->len_cvt = dstsize;
7459 if (cvt->filters[++cvt->filter_index]) {
7460 cvt->filters[cvt->filter_index] (cvt, format);
7461 }
7462 }
7463
7464 static void SDLCALL
7465 SDL_Downsample_U8_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7466 {
7467 #if DEBUG_CONVERT
7468 fprintf(stderr, "Downsample (x4) AUDIO_U8, 4 channels.\n");
7469 #endif
7470
7471 const int dstsize = cvt->len_cvt / 4;
7472 Uint8 *dst = (Uint8 *) cvt->buf;
7473 const Uint8 *src = (Uint8 *) cvt->buf;
7474 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
7475 Sint16 last_sample0 = (Sint16) src[0];
7476 Sint16 last_sample1 = (Sint16) src[1];
7477 Sint16 last_sample2 = (Sint16) src[2];
7478 Sint16 last_sample3 = (Sint16) src[3];
7479 while (dst < target) {
7480 const Sint16 sample0 = (Sint16) src[0];
7481 const Sint16 sample1 = (Sint16) src[1];
7482 const Sint16 sample2 = (Sint16) src[2];
7483 const Sint16 sample3 = (Sint16) src[3];
7484 src += 16;
7485 dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
7486 dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
7487 dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
7488 dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
7489 last_sample0 = sample0;
7490 last_sample1 = sample1;
7491 last_sample2 = sample2;
7492 last_sample3 = sample3;
7493 dst += 4;
7494 }
7495
7496 cvt->len_cvt = dstsize;
7497 if (cvt->filters[++cvt->filter_index]) {
7498 cvt->filters[cvt->filter_index] (cvt, format);
7499 }
7500 }
7501
7502 static void SDLCALL
7503 SDL_Upsample_U8_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7504 {
7505 #if DEBUG_CONVERT
7506 fprintf(stderr, "Upsample (x2) AUDIO_U8, 6 channels.\n");
7507 #endif
7508
7509 const int dstsize = cvt->len_cvt * 2;
7510 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 6 * 2;
7511 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 6;
7512 const Uint8 *target = ((const Uint8 *) cvt->buf);
7513 Sint16 last_sample5 = (Sint16) src[5];
7514 Sint16 last_sample4 = (Sint16) src[4];
7515 Sint16 last_sample3 = (Sint16) src[3];
7516 Sint16 last_sample2 = (Sint16) src[2];
7517 Sint16 last_sample1 = (Sint16) src[1];
7518 Sint16 last_sample0 = (Sint16) src[0];
7519 while (dst >= target) {
7520 const Sint16 sample5 = (Sint16) src[5];
7521 const Sint16 sample4 = (Sint16) src[4];
7522 const Sint16 sample3 = (Sint16) src[3];
7523 const Sint16 sample2 = (Sint16) src[2];
7524 const Sint16 sample1 = (Sint16) src[1];
7525 const Sint16 sample0 = (Sint16) src[0];
7526 src -= 6;
7527 dst[11] = (Uint8) ((sample5 + last_sample5) >> 1);
7528 dst[10] = (Uint8) ((sample4 + last_sample4) >> 1);
7529 dst[9] = (Uint8) ((sample3 + last_sample3) >> 1);
7530 dst[8] = (Uint8) ((sample2 + last_sample2) >> 1);
7531 dst[7] = (Uint8) ((sample1 + last_sample1) >> 1);
7532 dst[6] = (Uint8) ((sample0 + last_sample0) >> 1);
7533 dst[5] = (Uint8) sample5;
7534 dst[4] = (Uint8) sample4;
7535 dst[3] = (Uint8) sample3;
7536 dst[2] = (Uint8) sample2;
7537 dst[1] = (Uint8) sample1;
7538 dst[0] = (Uint8) sample0;
7539 last_sample5 = sample5;
7540 last_sample4 = sample4;
7541 last_sample3 = sample3;
7542 last_sample2 = sample2;
7543 last_sample1 = sample1;
7544 last_sample0 = sample0;
7545 dst -= 12;
7546 }
7547
7548 cvt->len_cvt = dstsize;
7549 if (cvt->filters[++cvt->filter_index]) {
7550 cvt->filters[cvt->filter_index] (cvt, format);
7551 }
7552 }
7553
7554 static void SDLCALL
7555 SDL_Downsample_U8_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7556 {
7557 #if DEBUG_CONVERT
7558 fprintf(stderr, "Downsample (x2) AUDIO_U8, 6 channels.\n");
7559 #endif
7560
7561 const int dstsize = cvt->len_cvt / 2;
7562 Uint8 *dst = (Uint8 *) cvt->buf;
7563 const Uint8 *src = (Uint8 *) cvt->buf;
7564 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
7565 Sint16 last_sample0 = (Sint16) src[0];
7566 Sint16 last_sample1 = (Sint16) src[1];
7567 Sint16 last_sample2 = (Sint16) src[2];
7568 Sint16 last_sample3 = (Sint16) src[3];
7569 Sint16 last_sample4 = (Sint16) src[4];
7570 Sint16 last_sample5 = (Sint16) src[5];
7571 while (dst < target) {
7572 const Sint16 sample0 = (Sint16) src[0];
7573 const Sint16 sample1 = (Sint16) src[1];
7574 const Sint16 sample2 = (Sint16) src[2];
7575 const Sint16 sample3 = (Sint16) src[3];
7576 const Sint16 sample4 = (Sint16) src[4];
7577 const Sint16 sample5 = (Sint16) src[5];
7578 src += 12;
7579 dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
7580 dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
7581 dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
7582 dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
7583 dst[4] = (Uint8) ((sample4 + last_sample4) >> 1);
7584 dst[5] = (Uint8) ((sample5 + last_sample5) >> 1);
7585 last_sample0 = sample0;
7586 last_sample1 = sample1;
7587 last_sample2 = sample2;
7588 last_sample3 = sample3;
7589 last_sample4 = sample4;
7590 last_sample5 = sample5;
7591 dst += 6;
7592 }
7593
7594 cvt->len_cvt = dstsize;
7595 if (cvt->filters[++cvt->filter_index]) {
7596 cvt->filters[cvt->filter_index] (cvt, format);
7597 }
7598 }
7599
7600 static void SDLCALL
7601 SDL_Upsample_U8_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7602 {
7603 #if DEBUG_CONVERT
7604 fprintf(stderr, "Upsample (x4) AUDIO_U8, 6 channels.\n");
7605 #endif
7606
7607 const int dstsize = cvt->len_cvt * 4;
7608 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 6 * 4;
7609 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 6;
7610 const Uint8 *target = ((const Uint8 *) cvt->buf);
7611 Sint16 last_sample5 = (Sint16) src[5];
7612 Sint16 last_sample4 = (Sint16) src[4];
7613 Sint16 last_sample3 = (Sint16) src[3];
7614 Sint16 last_sample2 = (Sint16) src[2];
7615 Sint16 last_sample1 = (Sint16) src[1];
7616 Sint16 last_sample0 = (Sint16) src[0];
7617 while (dst >= target) {
7618 const Sint16 sample5 = (Sint16) src[5];
7619 const Sint16 sample4 = (Sint16) src[4];
7620 const Sint16 sample3 = (Sint16) src[3];
7621 const Sint16 sample2 = (Sint16) src[2];
7622 const Sint16 sample1 = (Sint16) src[1];
7623 const Sint16 sample0 = (Sint16) src[0];
7624 src -= 6;
7625 dst[23] = (Uint8) ((sample5 + (3 * last_sample5)) >> 2);
7626 dst[22] = (Uint8) ((sample4 + (3 * last_sample4)) >> 2);
7627 dst[21] = (Uint8) ((sample3 + (3 * last_sample3)) >> 2);
7628 dst[20] = (Uint8) ((sample2 + (3 * last_sample2)) >> 2);
7629 dst[19] = (Uint8) ((sample1 + (3 * last_sample1)) >> 2);
7630 dst[18] = (Uint8) ((sample0 + (3 * last_sample0)) >> 2);
7631 dst[17] = (Uint8) ((sample5 + last_sample5) >> 1);
7632 dst[16] = (Uint8) ((sample4 + last_sample4) >> 1);
7633 dst[15] = (Uint8) ((sample3 + last_sample3) >> 1);
7634 dst[14] = (Uint8) ((sample2 + last_sample2) >> 1);
7635 dst[13] = (Uint8) ((sample1 + last_sample1) >> 1);
7636 dst[12] = (Uint8) ((sample0 + last_sample0) >> 1);
7637 dst[11] = (Uint8) (((3 * sample5) + last_sample5) >> 2);
7638 dst[10] = (Uint8) (((3 * sample4) + last_sample4) >> 2);
7639 dst[9] = (Uint8) (((3 * sample3) + last_sample3) >> 2);
7640 dst[8] = (Uint8) (((3 * sample2) + last_sample2) >> 2);
7641 dst[7] = (Uint8) (((3 * sample1) + last_sample1) >> 2);
7642 dst[6] = (Uint8) (((3 * sample0) + last_sample0) >> 2);
7643 dst[5] = (Uint8) sample5;
7644 dst[4] = (Uint8) sample4;
7645 dst[3] = (Uint8) sample3;
7646 dst[2] = (Uint8) sample2;
7647 dst[1] = (Uint8) sample1;
7648 dst[0] = (Uint8) sample0;
7649 last_sample5 = sample5;
7650 last_sample4 = sample4;
7651 last_sample3 = sample3;
7652 last_sample2 = sample2;
7653 last_sample1 = sample1;
7654 last_sample0 = sample0;
7655 dst -= 24;
7656 }
7657
7658 cvt->len_cvt = dstsize;
7659 if (cvt->filters[++cvt->filter_index]) {
7660 cvt->filters[cvt->filter_index] (cvt, format);
7661 }
7662 }
7663
7664 static void SDLCALL
7665 SDL_Downsample_U8_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7666 {
7667 #if DEBUG_CONVERT
7668 fprintf(stderr, "Downsample (x4) AUDIO_U8, 6 channels.\n");
7669 #endif
7670
7671 const int dstsize = cvt->len_cvt / 4;
7672 Uint8 *dst = (Uint8 *) cvt->buf;
7673 const Uint8 *src = (Uint8 *) cvt->buf;
7674 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
7675 Sint16 last_sample0 = (Sint16) src[0];
7676 Sint16 last_sample1 = (Sint16) src[1];
7677 Sint16 last_sample2 = (Sint16) src[2];
7678 Sint16 last_sample3 = (Sint16) src[3];
7679 Sint16 last_sample4 = (Sint16) src[4];
7680 Sint16 last_sample5 = (Sint16) src[5];
7681 while (dst < target) {
7682 const Sint16 sample0 = (Sint16) src[0];
7683 const Sint16 sample1 = (Sint16) src[1];
7684 const Sint16 sample2 = (Sint16) src[2];
7685 const Sint16 sample3 = (Sint16) src[3];
7686 const Sint16 sample4 = (Sint16) src[4];
7687 const Sint16 sample5 = (Sint16) src[5];
7688 src += 24;
7689 dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
7690 dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
7691 dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
7692 dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
7693 dst[4] = (Uint8) ((sample4 + last_sample4) >> 1);
7694 dst[5] = (Uint8) ((sample5 + last_sample5) >> 1);
7695 last_sample0 = sample0;
7696 last_sample1 = sample1;
7697 last_sample2 = sample2;
7698 last_sample3 = sample3;
7699 last_sample4 = sample4;
7700 last_sample5 = sample5;
7701 dst += 6;
7702 }
7703
7704 cvt->len_cvt = dstsize;
7705 if (cvt->filters[++cvt->filter_index]) {
7706 cvt->filters[cvt->filter_index] (cvt, format);
7707 }
7708 }
7709
7710 static void SDLCALL
7711 SDL_Upsample_U8_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7712 {
7713 #if DEBUG_CONVERT
7714 fprintf(stderr, "Upsample (x2) AUDIO_U8, 8 channels.\n");
7715 #endif
7716
7717 const int dstsize = cvt->len_cvt * 2;
7718 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 8 * 2;
7719 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 8;
7720 const Uint8 *target = ((const Uint8 *) cvt->buf);
7721 Sint16 last_sample7 = (Sint16) src[7];
7722 Sint16 last_sample6 = (Sint16) src[6];
7723 Sint16 last_sample5 = (Sint16) src[5];
7724 Sint16 last_sample4 = (Sint16) src[4];
7725 Sint16 last_sample3 = (Sint16) src[3];
7726 Sint16 last_sample2 = (Sint16) src[2];
7727 Sint16 last_sample1 = (Sint16) src[1];
7728 Sint16 last_sample0 = (Sint16) src[0];
7729 while (dst >= target) {
7730 const Sint16 sample7 = (Sint16) src[7];
7731 const Sint16 sample6 = (Sint16) src[6];
7732 const Sint16 sample5 = (Sint16) src[5];
7733 const Sint16 sample4 = (Sint16) src[4];
7734 const Sint16 sample3 = (Sint16) src[3];
7735 const Sint16 sample2 = (Sint16) src[2];
7736 const Sint16 sample1 = (Sint16) src[1];
7737 const Sint16 sample0 = (Sint16) src[0];
7738 src -= 8;
7739 dst[15] = (Uint8) ((sample7 + last_sample7) >> 1);
7740 dst[14] = (Uint8) ((sample6 + last_sample6) >> 1);
7741 dst[13] = (Uint8) ((sample5 + last_sample5) >> 1);
7742 dst[12] = (Uint8) ((sample4 + last_sample4) >> 1);
7743 dst[11] = (Uint8) ((sample3 + last_sample3) >> 1);
7744 dst[10] = (Uint8) ((sample2 + last_sample2) >> 1);
7745 dst[9] = (Uint8) ((sample1 + last_sample1) >> 1);
7746 dst[8] = (Uint8) ((sample0 + last_sample0) >> 1);
7747 dst[7] = (Uint8) sample7;
7748 dst[6] = (Uint8) sample6;
7749 dst[5] = (Uint8) sample5;
7750 dst[4] = (Uint8) sample4;
7751 dst[3] = (Uint8) sample3;
7752 dst[2] = (Uint8) sample2;
7753 dst[1] = (Uint8) sample1;
7754 dst[0] = (Uint8) sample0;
7755 last_sample7 = sample7;
7756 last_sample6 = sample6;
7757 last_sample5 = sample5;
7758 last_sample4 = sample4;
7759 last_sample3 = sample3;
7760 last_sample2 = sample2;
7761 last_sample1 = sample1;
7762 last_sample0 = sample0;
7763 dst -= 16;
7764 }
7765
7766 cvt->len_cvt = dstsize;
7767 if (cvt->filters[++cvt->filter_index]) {
7768 cvt->filters[cvt->filter_index] (cvt, format);
7769 }
7770 }
7771
7772 static void SDLCALL
7773 SDL_Downsample_U8_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7774 {
7775 #if DEBUG_CONVERT
7776 fprintf(stderr, "Downsample (x2) AUDIO_U8, 8 channels.\n");
7777 #endif
7778
7779 const int dstsize = cvt->len_cvt / 2;
7780 Uint8 *dst = (Uint8 *) cvt->buf;
7781 const Uint8 *src = (Uint8 *) cvt->buf;
7782 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
7783 Sint16 last_sample0 = (Sint16) src[0];
7784 Sint16 last_sample1 = (Sint16) src[1];
7785 Sint16 last_sample2 = (Sint16) src[2];
7786 Sint16 last_sample3 = (Sint16) src[3];
7787 Sint16 last_sample4 = (Sint16) src[4];
7788 Sint16 last_sample5 = (Sint16) src[5];
7789 Sint16 last_sample6 = (Sint16) src[6];
7790 Sint16 last_sample7 = (Sint16) src[7];
7791 while (dst < target) {
7792 const Sint16 sample0 = (Sint16) src[0];
7793 const Sint16 sample1 = (Sint16) src[1];
7794 const Sint16 sample2 = (Sint16) src[2];
7795 const Sint16 sample3 = (Sint16) src[3];
7796 const Sint16 sample4 = (Sint16) src[4];
7797 const Sint16 sample5 = (Sint16) src[5];
7798 const Sint16 sample6 = (Sint16) src[6];
7799 const Sint16 sample7 = (Sint16) src[7];
7800 src += 16;
7801 dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
7802 dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
7803 dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
7804 dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
7805 dst[4] = (Uint8) ((sample4 + last_sample4) >> 1);
7806 dst[5] = (Uint8) ((sample5 + last_sample5) >> 1);
7807 dst[6] = (Uint8) ((sample6 + last_sample6) >> 1);
7808 dst[7] = (Uint8) ((sample7 + last_sample7) >> 1);
7809 last_sample0 = sample0;
7810 last_sample1 = sample1;
7811 last_sample2 = sample2;
7812 last_sample3 = sample3;
7813 last_sample4 = sample4;
7814 last_sample5 = sample5;
7815 last_sample6 = sample6;
7816 last_sample7 = sample7;
7817 dst += 8;
7818 }
7819
7820 cvt->len_cvt = dstsize;
7821 if (cvt->filters[++cvt->filter_index]) {
7822 cvt->filters[cvt->filter_index] (cvt, format);
7823 }
7824 }
7825
7826 static void SDLCALL
7827 SDL_Upsample_U8_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7828 {
7829 #if DEBUG_CONVERT
7830 fprintf(stderr, "Upsample (x4) AUDIO_U8, 8 channels.\n");
7831 #endif
7832
7833 const int dstsize = cvt->len_cvt * 4;
7834 Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 8 * 4;
7835 const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 8;
7836 const Uint8 *target = ((const Uint8 *) cvt->buf);
7837 Sint16 last_sample7 = (Sint16) src[7];
7838 Sint16 last_sample6 = (Sint16) src[6];
7839 Sint16 last_sample5 = (Sint16) src[5];
7840 Sint16 last_sample4 = (Sint16) src[4];
7841 Sint16 last_sample3 = (Sint16) src[3];
7842 Sint16 last_sample2 = (Sint16) src[2];
7843 Sint16 last_sample1 = (Sint16) src[1];
7844 Sint16 last_sample0 = (Sint16) src[0];
7845 while (dst >= target) {
7846 const Sint16 sample7 = (Sint16) src[7];
7847 const Sint16 sample6 = (Sint16) src[6];
7848 const Sint16 sample5 = (Sint16) src[5];
7849 const Sint16 sample4 = (Sint16) src[4];
7850 const Sint16 sample3 = (Sint16) src[3];
7851 const Sint16 sample2 = (Sint16) src[2];
7852 const Sint16 sample1 = (Sint16) src[1];
7853 const Sint16 sample0 = (Sint16) src[0];
7854 src -= 8;
7855 dst[31] = (Uint8) ((sample7 + (3 * last_sample7)) >> 2);
7856 dst[30] = (Uint8) ((sample6 + (3 * last_sample6)) >> 2);
7857 dst[29] = (Uint8) ((sample5 + (3 * last_sample5)) >> 2);
7858 dst[28] = (Uint8) ((sample4 + (3 * last_sample4)) >> 2);
7859 dst[27] = (Uint8) ((sample3 + (3 * last_sample3)) >> 2);
7860 dst[26] = (Uint8) ((sample2 + (3 * last_sample2)) >> 2);
7861 dst[25] = (Uint8) ((sample1 + (3 * last_sample1)) >> 2);
7862 dst[24] = (Uint8) ((sample0 + (3 * last_sample0)) >> 2);
7863 dst[23] = (Uint8) ((sample7 + last_sample7) >> 1);
7864 dst[22] = (Uint8) ((sample6 + last_sample6) >> 1);
7865 dst[21] = (Uint8) ((sample5 + last_sample5) >> 1);
7866 dst[20] = (Uint8) ((sample4 + last_sample4) >> 1);
7867 dst[19] = (Uint8) ((sample3 + last_sample3) >> 1);
7868 dst[18] = (Uint8) ((sample2 + last_sample2) >> 1);
7869 dst[17] = (Uint8) ((sample1 + last_sample1) >> 1);
7870 dst[16] = (Uint8) ((sample0 + last_sample0) >> 1);
7871 dst[15] = (Uint8) (((3 * sample7) + last_sample7) >> 2);
7872 dst[14] = (Uint8) (((3 * sample6) + last_sample6) >> 2);
7873 dst[13] = (Uint8) (((3 * sample5) + last_sample5) >> 2);
7874 dst[12] = (Uint8) (((3 * sample4) + last_sample4) >> 2);
7875 dst[11] = (Uint8) (((3 * sample3) + last_sample3) >> 2);
7876 dst[10] = (Uint8) (((3 * sample2) + last_sample2) >> 2);
7877 dst[9] = (Uint8) (((3 * sample1) + last_sample1) >> 2);
7878 dst[8] = (Uint8) (((3 * sample0) + last_sample0) >> 2);
7879 dst[7] = (Uint8) sample7;
7880 dst[6] = (Uint8) sample6;
7881 dst[5] = (Uint8) sample5;
7882 dst[4] = (Uint8) sample4;
7883 dst[3] = (Uint8) sample3;
7884 dst[2] = (Uint8) sample2;
7885 dst[1] = (Uint8) sample1;
7886 dst[0] = (Uint8) sample0;
7887 last_sample7 = sample7;
7888 last_sample6 = sample6;
7889 last_sample5 = sample5;
7890 last_sample4 = sample4;
7891 last_sample3 = sample3;
7892 last_sample2 = sample2;
7893 last_sample1 = sample1;
7894 last_sample0 = sample0;
7895 dst -= 32;
7896 }
7897
7898 cvt->len_cvt = dstsize;
7899 if (cvt->filters[++cvt->filter_index]) {
7900 cvt->filters[cvt->filter_index] (cvt, format);
7901 }
7902 }
7903
7904 static void SDLCALL
7905 SDL_Downsample_U8_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7906 {
7907 #if DEBUG_CONVERT
7908 fprintf(stderr, "Downsample (x4) AUDIO_U8, 8 channels.\n");
7909 #endif
7910
7911 const int dstsize = cvt->len_cvt / 4;
7912 Uint8 *dst = (Uint8 *) cvt->buf;
7913 const Uint8 *src = (Uint8 *) cvt->buf;
7914 const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
7915 Sint16 last_sample0 = (Sint16) src[0];
7916 Sint16 last_sample1 = (Sint16) src[1];
7917 Sint16 last_sample2 = (Sint16) src[2];
7918 Sint16 last_sample3 = (Sint16) src[3];
7919 Sint16 last_sample4 = (Sint16) src[4];
7920 Sint16 last_sample5 = (Sint16) src[5];
7921 Sint16 last_sample6 = (Sint16) src[6];
7922 Sint16 last_sample7 = (Sint16) src[7];
7923 while (dst < target) {
7924 const Sint16 sample0 = (Sint16) src[0];
7925 const Sint16 sample1 = (Sint16) src[1];
7926 const Sint16 sample2 = (Sint16) src[2];
7927 const Sint16 sample3 = (Sint16) src[3];
7928 const Sint16 sample4 = (Sint16) src[4];
7929 const Sint16 sample5 = (Sint16) src[5];
7930 const Sint16 sample6 = (Sint16) src[6];
7931 const Sint16 sample7 = (Sint16) src[7];
7932 src += 32;
7933 dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
7934 dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
7935 dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
7936 dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
7937 dst[4] = (Uint8) ((sample4 + last_sample4) >> 1);
7938 dst[5] = (Uint8) ((sample5 + last_sample5) >> 1);
7939 dst[6] = (Uint8) ((sample6 + last_sample6) >> 1);
7940 dst[7] = (Uint8) ((sample7 + last_sample7) >> 1);
7941 last_sample0 = sample0;
7942 last_sample1 = sample1;
7943 last_sample2 = sample2;
7944 last_sample3 = sample3;
7945 last_sample4 = sample4;
7946 last_sample5 = sample5;
7947 last_sample6 = sample6;
7948 last_sample7 = sample7;
7949 dst += 8;
7950 }
7951
7952 cvt->len_cvt = dstsize;
7953 if (cvt->filters[++cvt->filter_index]) {
7954 cvt->filters[cvt->filter_index] (cvt, format);
7955 }
7956 }
7957
7958 static void SDLCALL
7959 SDL_Upsample_S8_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7960 {
7961 #if DEBUG_CONVERT
7962 fprintf(stderr, "Upsample (x2) AUDIO_S8, 1 channels.\n");
7963 #endif
7964
7965 const int dstsize = cvt->len_cvt * 2;
7966 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 1 * 2;
7967 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 1;
7968 const Sint8 *target = ((const Sint8 *) cvt->buf);
7969 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
7970 while (dst >= target) {
7971 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
7972 src--;
7973 dst[1] = (Sint8) ((sample0 + last_sample0) >> 1);
7974 dst[0] = (Sint8) sample0;
7975 last_sample0 = sample0;
7976 dst -= 2;
7977 }
7978
7979 cvt->len_cvt = dstsize;
7980 if (cvt->filters[++cvt->filter_index]) {
7981 cvt->filters[cvt->filter_index] (cvt, format);
7982 }
7983 }
7984
7985 static void SDLCALL
7986 SDL_Downsample_S8_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
7987 {
7988 #if DEBUG_CONVERT
7989 fprintf(stderr, "Downsample (x2) AUDIO_S8, 1 channels.\n");
7990 #endif
7991
7992 const int dstsize = cvt->len_cvt / 2;
7993 Sint8 *dst = (Sint8 *) cvt->buf;
7994 const Sint8 *src = (Sint8 *) cvt->buf;
7995 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
7996 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
7997 while (dst < target) {
7998 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
7999 src += 2;
8000 dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
8001 last_sample0 = sample0;
8002 dst++;
8003 }
8004
8005 cvt->len_cvt = dstsize;
8006 if (cvt->filters[++cvt->filter_index]) {
8007 cvt->filters[cvt->filter_index] (cvt, format);
8008 }
8009 }
8010
8011 static void SDLCALL
8012 SDL_Upsample_S8_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8013 {
8014 #if DEBUG_CONVERT
8015 fprintf(stderr, "Upsample (x4) AUDIO_S8, 1 channels.\n");
8016 #endif
8017
8018 const int dstsize = cvt->len_cvt * 4;
8019 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 1 * 4;
8020 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 1;
8021 const Sint8 *target = ((const Sint8 *) cvt->buf);
8022 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8023 while (dst >= target) {
8024 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8025 src--;
8026 dst[3] = (Sint8) ((sample0 + (3 * last_sample0)) >> 2);
8027 dst[2] = (Sint8) ((sample0 + last_sample0) >> 1);
8028 dst[1] = (Sint8) (((3 * sample0) + last_sample0) >> 2);
8029 dst[0] = (Sint8) sample0;
8030 last_sample0 = sample0;
8031 dst -= 4;
8032 }
8033
8034 cvt->len_cvt = dstsize;
8035 if (cvt->filters[++cvt->filter_index]) {
8036 cvt->filters[cvt->filter_index] (cvt, format);
8037 }
8038 }
8039
8040 static void SDLCALL
8041 SDL_Downsample_S8_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8042 {
8043 #if DEBUG_CONVERT
8044 fprintf(stderr, "Downsample (x4) AUDIO_S8, 1 channels.\n");
8045 #endif
8046
8047 const int dstsize = cvt->len_cvt / 4;
8048 Sint8 *dst = (Sint8 *) cvt->buf;
8049 const Sint8 *src = (Sint8 *) cvt->buf;
8050 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
8051 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8052 while (dst < target) {
8053 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8054 src += 4;
8055 dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
8056 last_sample0 = sample0;
8057 dst++;
8058 }
8059
8060 cvt->len_cvt = dstsize;
8061 if (cvt->filters[++cvt->filter_index]) {
8062 cvt->filters[cvt->filter_index] (cvt, format);
8063 }
8064 }
8065
8066 static void SDLCALL
8067 SDL_Upsample_S8_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8068 {
8069 #if DEBUG_CONVERT
8070 fprintf(stderr, "Upsample (x2) AUDIO_S8, 2 channels.\n");
8071 #endif
8072
8073 const int dstsize = cvt->len_cvt * 2;
8074 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 2 * 2;
8075 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 2;
8076 const Sint8 *target = ((const Sint8 *) cvt->buf);
8077 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8078 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8079 while (dst >= target) {
8080 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8081 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8082 src -= 2;
8083 dst[3] = (Sint8) ((sample1 + last_sample1) >> 1);
8084 dst[2] = (Sint8) ((sample0 + last_sample0) >> 1);
8085 dst[1] = (Sint8) sample1;
8086 dst[0] = (Sint8) sample0;
8087 last_sample1 = sample1;
8088 last_sample0 = sample0;
8089 dst -= 4;
8090 }
8091
8092 cvt->len_cvt = dstsize;
8093 if (cvt->filters[++cvt->filter_index]) {
8094 cvt->filters[cvt->filter_index] (cvt, format);
8095 }
8096 }
8097
8098 static void SDLCALL
8099 SDL_Downsample_S8_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8100 {
8101 #if DEBUG_CONVERT
8102 fprintf(stderr, "Downsample (x2) AUDIO_S8, 2 channels.\n");
8103 #endif
8104
8105 const int dstsize = cvt->len_cvt / 2;
8106 Sint8 *dst = (Sint8 *) cvt->buf;
8107 const Sint8 *src = (Sint8 *) cvt->buf;
8108 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
8109 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8110 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8111 while (dst < target) {
8112 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8113 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8114 src += 4;
8115 dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
8116 dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
8117 last_sample0 = sample0;
8118 last_sample1 = sample1;
8119 dst += 2;
8120 }
8121
8122 cvt->len_cvt = dstsize;
8123 if (cvt->filters[++cvt->filter_index]) {
8124 cvt->filters[cvt->filter_index] (cvt, format);
8125 }
8126 }
8127
8128 static void SDLCALL
8129 SDL_Upsample_S8_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8130 {
8131 #if DEBUG_CONVERT
8132 fprintf(stderr, "Upsample (x4) AUDIO_S8, 2 channels.\n");
8133 #endif
8134
8135 const int dstsize = cvt->len_cvt * 4;
8136 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 2 * 4;
8137 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 2;
8138 const Sint8 *target = ((const Sint8 *) cvt->buf);
8139 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8140 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8141 while (dst >= target) {
8142 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8143 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8144 src -= 2;
8145 dst[7] = (Sint8) ((sample1 + (3 * last_sample1)) >> 2);
8146 dst[6] = (Sint8) ((sample0 + (3 * last_sample0)) >> 2);
8147 dst[5] = (Sint8) ((sample1 + last_sample1) >> 1);
8148 dst[4] = (Sint8) ((sample0 + last_sample0) >> 1);
8149 dst[3] = (Sint8) (((3 * sample1) + last_sample1) >> 2);
8150 dst[2] = (Sint8) (((3 * sample0) + last_sample0) >> 2);
8151 dst[1] = (Sint8) sample1;
8152 dst[0] = (Sint8) sample0;
8153 last_sample1 = sample1;
8154 last_sample0 = sample0;
8155 dst -= 8;
8156 }
8157
8158 cvt->len_cvt = dstsize;
8159 if (cvt->filters[++cvt->filter_index]) {
8160 cvt->filters[cvt->filter_index] (cvt, format);
8161 }
8162 }
8163
8164 static void SDLCALL
8165 SDL_Downsample_S8_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8166 {
8167 #if DEBUG_CONVERT
8168 fprintf(stderr, "Downsample (x4) AUDIO_S8, 2 channels.\n");
8169 #endif
8170
8171 const int dstsize = cvt->len_cvt / 4;
8172 Sint8 *dst = (Sint8 *) cvt->buf;
8173 const Sint8 *src = (Sint8 *) cvt->buf;
8174 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
8175 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8176 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8177 while (dst < target) {
8178 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8179 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8180 src += 8;
8181 dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
8182 dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
8183 last_sample0 = sample0;
8184 last_sample1 = sample1;
8185 dst += 2;
8186 }
8187
8188 cvt->len_cvt = dstsize;
8189 if (cvt->filters[++cvt->filter_index]) {
8190 cvt->filters[cvt->filter_index] (cvt, format);
8191 }
8192 }
8193
8194 static void SDLCALL
8195 SDL_Upsample_S8_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8196 {
8197 #if DEBUG_CONVERT
8198 fprintf(stderr, "Upsample (x2) AUDIO_S8, 4 channels.\n");
8199 #endif
8200
8201 const int dstsize = cvt->len_cvt * 2;
8202 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 4 * 2;
8203 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 4;
8204 const Sint8 *target = ((const Sint8 *) cvt->buf);
8205 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8206 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8207 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8208 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8209 while (dst >= target) {
8210 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8211 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8212 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8213 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8214 src -= 4;
8215 dst[7] = (Sint8) ((sample3 + last_sample3) >> 1);
8216 dst[6] = (Sint8) ((sample2 + last_sample2) >> 1);
8217 dst[5] = (Sint8) ((sample1 + last_sample1) >> 1);
8218 dst[4] = (Sint8) ((sample0 + last_sample0) >> 1);
8219 dst[3] = (Sint8) sample3;
8220 dst[2] = (Sint8) sample2;
8221 dst[1] = (Sint8) sample1;
8222 dst[0] = (Sint8) sample0;
8223 last_sample3 = sample3;
8224 last_sample2 = sample2;
8225 last_sample1 = sample1;
8226 last_sample0 = sample0;
8227 dst -= 8;
8228 }
8229
8230 cvt->len_cvt = dstsize;
8231 if (cvt->filters[++cvt->filter_index]) {
8232 cvt->filters[cvt->filter_index] (cvt, format);
8233 }
8234 }
8235
8236 static void SDLCALL
8237 SDL_Downsample_S8_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8238 {
8239 #if DEBUG_CONVERT
8240 fprintf(stderr, "Downsample (x2) AUDIO_S8, 4 channels.\n");
8241 #endif
8242
8243 const int dstsize = cvt->len_cvt / 2;
8244 Sint8 *dst = (Sint8 *) cvt->buf;
8245 const Sint8 *src = (Sint8 *) cvt->buf;
8246 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
8247 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8248 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8249 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8250 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8251 while (dst < target) {
8252 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8253 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8254 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8255 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8256 src += 8;
8257 dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
8258 dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
8259 dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
8260 dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
8261 last_sample0 = sample0;
8262 last_sample1 = sample1;
8263 last_sample2 = sample2;
8264 last_sample3 = sample3;
8265 dst += 4;
8266 }
8267
8268 cvt->len_cvt = dstsize;
8269 if (cvt->filters[++cvt->filter_index]) {
8270 cvt->filters[cvt->filter_index] (cvt, format);
8271 }
8272 }
8273
8274 static void SDLCALL
8275 SDL_Upsample_S8_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8276 {
8277 #if DEBUG_CONVERT
8278 fprintf(stderr, "Upsample (x4) AUDIO_S8, 4 channels.\n");
8279 #endif
8280
8281 const int dstsize = cvt->len_cvt * 4;
8282 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 4 * 4;
8283 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 4;
8284 const Sint8 *target = ((const Sint8 *) cvt->buf);
8285 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8286 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8287 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8288 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8289 while (dst >= target) {
8290 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8291 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8292 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8293 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8294 src -= 4;
8295 dst[15] = (Sint8) ((sample3 + (3 * last_sample3)) >> 2);
8296 dst[14] = (Sint8) ((sample2 + (3 * last_sample2)) >> 2);
8297 dst[13] = (Sint8) ((sample1 + (3 * last_sample1)) >> 2);
8298 dst[12] = (Sint8) ((sample0 + (3 * last_sample0)) >> 2);
8299 dst[11] = (Sint8) ((sample3 + last_sample3) >> 1);
8300 dst[10] = (Sint8) ((sample2 + last_sample2) >> 1);
8301 dst[9] = (Sint8) ((sample1 + last_sample1) >> 1);
8302 dst[8] = (Sint8) ((sample0 + last_sample0) >> 1);
8303 dst[7] = (Sint8) (((3 * sample3) + last_sample3) >> 2);
8304 dst[6] = (Sint8) (((3 * sample2) + last_sample2) >> 2);
8305 dst[5] = (Sint8) (((3 * sample1) + last_sample1) >> 2);
8306 dst[4] = (Sint8) (((3 * sample0) + last_sample0) >> 2);
8307 dst[3] = (Sint8) sample3;
8308 dst[2] = (Sint8) sample2;
8309 dst[1] = (Sint8) sample1;
8310 dst[0] = (Sint8) sample0;
8311 last_sample3 = sample3;
8312 last_sample2 = sample2;
8313 last_sample1 = sample1;
8314 last_sample0 = sample0;
8315 dst -= 16;
8316 }
8317
8318 cvt->len_cvt = dstsize;
8319 if (cvt->filters[++cvt->filter_index]) {
8320 cvt->filters[cvt->filter_index] (cvt, format);
8321 }
8322 }
8323
8324 static void SDLCALL
8325 SDL_Downsample_S8_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8326 {
8327 #if DEBUG_CONVERT
8328 fprintf(stderr, "Downsample (x4) AUDIO_S8, 4 channels.\n");
8329 #endif
8330
8331 const int dstsize = cvt->len_cvt / 4;
8332 Sint8 *dst = (Sint8 *) cvt->buf;
8333 const Sint8 *src = (Sint8 *) cvt->buf;
8334 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
8335 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8336 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8337 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8338 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8339 while (dst < target) {
8340 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8341 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8342 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8343 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8344 src += 16;
8345 dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
8346 dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
8347 dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
8348 dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
8349 last_sample0 = sample0;
8350 last_sample1 = sample1;
8351 last_sample2 = sample2;
8352 last_sample3 = sample3;
8353 dst += 4;
8354 }
8355
8356 cvt->len_cvt = dstsize;
8357 if (cvt->filters[++cvt->filter_index]) {
8358 cvt->filters[cvt->filter_index] (cvt, format);
8359 }
8360 }
8361
8362 static void SDLCALL
8363 SDL_Upsample_S8_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8364 {
8365 #if DEBUG_CONVERT
8366 fprintf(stderr, "Upsample (x2) AUDIO_S8, 6 channels.\n");
8367 #endif
8368
8369 const int dstsize = cvt->len_cvt * 2;
8370 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 6 * 2;
8371 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 6;
8372 const Sint8 *target = ((const Sint8 *) cvt->buf);
8373 Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
8374 Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
8375 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8376 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8377 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8378 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8379 while (dst >= target) {
8380 const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
8381 const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
8382 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8383 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8384 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8385 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8386 src -= 6;
8387 dst[11] = (Sint8) ((sample5 + last_sample5) >> 1);
8388 dst[10] = (Sint8) ((sample4 + last_sample4) >> 1);
8389 dst[9] = (Sint8) ((sample3 + last_sample3) >> 1);
8390 dst[8] = (Sint8) ((sample2 + last_sample2) >> 1);
8391 dst[7] = (Sint8) ((sample1 + last_sample1) >> 1);
8392 dst[6] = (Sint8) ((sample0 + last_sample0) >> 1);
8393 dst[5] = (Sint8) sample5;
8394 dst[4] = (Sint8) sample4;
8395 dst[3] = (Sint8) sample3;
8396 dst[2] = (Sint8) sample2;
8397 dst[1] = (Sint8) sample1;
8398 dst[0] = (Sint8) sample0;
8399 last_sample5 = sample5;
8400 last_sample4 = sample4;
8401 last_sample3 = sample3;
8402 last_sample2 = sample2;
8403 last_sample1 = sample1;
8404 last_sample0 = sample0;
8405 dst -= 12;
8406 }
8407
8408 cvt->len_cvt = dstsize;
8409 if (cvt->filters[++cvt->filter_index]) {
8410 cvt->filters[cvt->filter_index] (cvt, format);
8411 }
8412 }
8413
8414 static void SDLCALL
8415 SDL_Downsample_S8_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8416 {
8417 #if DEBUG_CONVERT
8418 fprintf(stderr, "Downsample (x2) AUDIO_S8, 6 channels.\n");
8419 #endif
8420
8421 const int dstsize = cvt->len_cvt / 2;
8422 Sint8 *dst = (Sint8 *) cvt->buf;
8423 const Sint8 *src = (Sint8 *) cvt->buf;
8424 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
8425 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8426 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8427 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8428 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8429 Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
8430 Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
8431 while (dst < target) {
8432 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8433 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8434 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8435 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8436 const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
8437 const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
8438 src += 12;
8439 dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
8440 dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
8441 dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
8442 dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
8443 dst[4] = (Sint8) ((sample4 + last_sample4) >> 1);
8444 dst[5] = (Sint8) ((sample5 + last_sample5) >> 1);
8445 last_sample0 = sample0;
8446 last_sample1 = sample1;
8447 last_sample2 = sample2;
8448 last_sample3 = sample3;
8449 last_sample4 = sample4;
8450 last_sample5 = sample5;
8451 dst += 6;
8452 }
8453
8454 cvt->len_cvt = dstsize;
8455 if (cvt->filters[++cvt->filter_index]) {
8456 cvt->filters[cvt->filter_index] (cvt, format);
8457 }
8458 }
8459
8460 static void SDLCALL
8461 SDL_Upsample_S8_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8462 {
8463 #if DEBUG_CONVERT
8464 fprintf(stderr, "Upsample (x4) AUDIO_S8, 6 channels.\n");
8465 #endif
8466
8467 const int dstsize = cvt->len_cvt * 4;
8468 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 6 * 4;
8469 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 6;
8470 const Sint8 *target = ((const Sint8 *) cvt->buf);
8471 Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
8472 Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
8473 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8474 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8475 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8476 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8477 while (dst >= target) {
8478 const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
8479 const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
8480 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8481 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8482 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8483 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8484 src -= 6;
8485 dst[23] = (Sint8) ((sample5 + (3 * last_sample5)) >> 2);
8486 dst[22] = (Sint8) ((sample4 + (3 * last_sample4)) >> 2);
8487 dst[21] = (Sint8) ((sample3 + (3 * last_sample3)) >> 2);
8488 dst[20] = (Sint8) ((sample2 + (3 * last_sample2)) >> 2);
8489 dst[19] = (Sint8) ((sample1 + (3 * last_sample1)) >> 2);
8490 dst[18] = (Sint8) ((sample0 + (3 * last_sample0)) >> 2);
8491 dst[17] = (Sint8) ((sample5 + last_sample5) >> 1);
8492 dst[16] = (Sint8) ((sample4 + last_sample4) >> 1);
8493 dst[15] = (Sint8) ((sample3 + last_sample3) >> 1);
8494 dst[14] = (Sint8) ((sample2 + last_sample2) >> 1);
8495 dst[13] = (Sint8) ((sample1 + last_sample1) >> 1);
8496 dst[12] = (Sint8) ((sample0 + last_sample0) >> 1);
8497 dst[11] = (Sint8) (((3 * sample5) + last_sample5) >> 2);
8498 dst[10] = (Sint8) (((3 * sample4) + last_sample4) >> 2);
8499 dst[9] = (Sint8) (((3 * sample3) + last_sample3) >> 2);
8500 dst[8] = (Sint8) (((3 * sample2) + last_sample2) >> 2);
8501 dst[7] = (Sint8) (((3 * sample1) + last_sample1) >> 2);
8502 dst[6] = (Sint8) (((3 * sample0) + last_sample0) >> 2);
8503 dst[5] = (Sint8) sample5;
8504 dst[4] = (Sint8) sample4;
8505 dst[3] = (Sint8) sample3;
8506 dst[2] = (Sint8) sample2;
8507 dst[1] = (Sint8) sample1;
8508 dst[0] = (Sint8) sample0;
8509 last_sample5 = sample5;
8510 last_sample4 = sample4;
8511 last_sample3 = sample3;
8512 last_sample2 = sample2;
8513 last_sample1 = sample1;
8514 last_sample0 = sample0;
8515 dst -= 24;
8516 }
8517
8518 cvt->len_cvt = dstsize;
8519 if (cvt->filters[++cvt->filter_index]) {
8520 cvt->filters[cvt->filter_index] (cvt, format);
8521 }
8522 }
8523
8524 static void SDLCALL
8525 SDL_Downsample_S8_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8526 {
8527 #if DEBUG_CONVERT
8528 fprintf(stderr, "Downsample (x4) AUDIO_S8, 6 channels.\n");
8529 #endif
8530
8531 const int dstsize = cvt->len_cvt / 4;
8532 Sint8 *dst = (Sint8 *) cvt->buf;
8533 const Sint8 *src = (Sint8 *) cvt->buf;
8534 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
8535 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8536 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8537 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8538 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8539 Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
8540 Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
8541 while (dst < target) {
8542 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8543 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8544 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8545 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8546 const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
8547 const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
8548 src += 24;
8549 dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
8550 dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
8551 dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
8552 dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
8553 dst[4] = (Sint8) ((sample4 + last_sample4) >> 1);
8554 dst[5] = (Sint8) ((sample5 + last_sample5) >> 1);
8555 last_sample0 = sample0;
8556 last_sample1 = sample1;
8557 last_sample2 = sample2;
8558 last_sample3 = sample3;
8559 last_sample4 = sample4;
8560 last_sample5 = sample5;
8561 dst += 6;
8562 }
8563
8564 cvt->len_cvt = dstsize;
8565 if (cvt->filters[++cvt->filter_index]) {
8566 cvt->filters[cvt->filter_index] (cvt, format);
8567 }
8568 }
8569
8570 static void SDLCALL
8571 SDL_Upsample_S8_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8572 {
8573 #if DEBUG_CONVERT
8574 fprintf(stderr, "Upsample (x2) AUDIO_S8, 8 channels.\n");
8575 #endif
8576
8577 const int dstsize = cvt->len_cvt * 2;
8578 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 8 * 2;
8579 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 8;
8580 const Sint8 *target = ((const Sint8 *) cvt->buf);
8581 Sint16 last_sample7 = (Sint16) ((Sint8) src[7]);
8582 Sint16 last_sample6 = (Sint16) ((Sint8) src[6]);
8583 Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
8584 Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
8585 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8586 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8587 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8588 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8589 while (dst >= target) {
8590 const Sint16 sample7 = (Sint16) ((Sint8) src[7]);
8591 const Sint16 sample6 = (Sint16) ((Sint8) src[6]);
8592 const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
8593 const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
8594 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8595 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8596 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8597 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8598 src -= 8;
8599 dst[15] = (Sint8) ((sample7 + last_sample7) >> 1);
8600 dst[14] = (Sint8) ((sample6 + last_sample6) >> 1);
8601 dst[13] = (Sint8) ((sample5 + last_sample5) >> 1);
8602 dst[12] = (Sint8) ((sample4 + last_sample4) >> 1);
8603 dst[11] = (Sint8) ((sample3 + last_sample3) >> 1);
8604 dst[10] = (Sint8) ((sample2 + last_sample2) >> 1);
8605 dst[9] = (Sint8) ((sample1 + last_sample1) >> 1);
8606 dst[8] = (Sint8) ((sample0 + last_sample0) >> 1);
8607 dst[7] = (Sint8) sample7;
8608 dst[6] = (Sint8) sample6;
8609 dst[5] = (Sint8) sample5;
8610 dst[4] = (Sint8) sample4;
8611 dst[3] = (Sint8) sample3;
8612 dst[2] = (Sint8) sample2;
8613 dst[1] = (Sint8) sample1;
8614 dst[0] = (Sint8) sample0;
8615 last_sample7 = sample7;
8616 last_sample6 = sample6;
8617 last_sample5 = sample5;
8618 last_sample4 = sample4;
8619 last_sample3 = sample3;
8620 last_sample2 = sample2;
8621 last_sample1 = sample1;
8622 last_sample0 = sample0;
8623 dst -= 16;
8624 }
8625
8626 cvt->len_cvt = dstsize;
8627 if (cvt->filters[++cvt->filter_index]) {
8628 cvt->filters[cvt->filter_index] (cvt, format);
8629 }
8630 }
8631
8632 static void SDLCALL
8633 SDL_Downsample_S8_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8634 {
8635 #if DEBUG_CONVERT
8636 fprintf(stderr, "Downsample (x2) AUDIO_S8, 8 channels.\n");
8637 #endif
8638
8639 const int dstsize = cvt->len_cvt / 2;
8640 Sint8 *dst = (Sint8 *) cvt->buf;
8641 const Sint8 *src = (Sint8 *) cvt->buf;
8642 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
8643 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8644 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8645 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8646 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8647 Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
8648 Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
8649 Sint16 last_sample6 = (Sint16) ((Sint8) src[6]);
8650 Sint16 last_sample7 = (Sint16) ((Sint8) src[7]);
8651 while (dst < target) {
8652 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8653 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8654 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8655 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8656 const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
8657 const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
8658 const Sint16 sample6 = (Sint16) ((Sint8) src[6]);
8659 const Sint16 sample7 = (Sint16) ((Sint8) src[7]);
8660 src += 16;
8661 dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
8662 dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
8663 dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
8664 dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
8665 dst[4] = (Sint8) ((sample4 + last_sample4) >> 1);
8666 dst[5] = (Sint8) ((sample5 + last_sample5) >> 1);
8667 dst[6] = (Sint8) ((sample6 + last_sample6) >> 1);
8668 dst[7] = (Sint8) ((sample7 + last_sample7) >> 1);
8669 last_sample0 = sample0;
8670 last_sample1 = sample1;
8671 last_sample2 = sample2;
8672 last_sample3 = sample3;
8673 last_sample4 = sample4;
8674 last_sample5 = sample5;
8675 last_sample6 = sample6;
8676 last_sample7 = sample7;
8677 dst += 8;
8678 }
8679
8680 cvt->len_cvt = dstsize;
8681 if (cvt->filters[++cvt->filter_index]) {
8682 cvt->filters[cvt->filter_index] (cvt, format);
8683 }
8684 }
8685
8686 static void SDLCALL
8687 SDL_Upsample_S8_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8688 {
8689 #if DEBUG_CONVERT
8690 fprintf(stderr, "Upsample (x4) AUDIO_S8, 8 channels.\n");
8691 #endif
8692
8693 const int dstsize = cvt->len_cvt * 4;
8694 Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 8 * 4;
8695 const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 8;
8696 const Sint8 *target = ((const Sint8 *) cvt->buf);
8697 Sint16 last_sample7 = (Sint16) ((Sint8) src[7]);
8698 Sint16 last_sample6 = (Sint16) ((Sint8) src[6]);
8699 Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
8700 Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
8701 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8702 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8703 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8704 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8705 while (dst >= target) {
8706 const Sint16 sample7 = (Sint16) ((Sint8) src[7]);
8707 const Sint16 sample6 = (Sint16) ((Sint8) src[6]);
8708 const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
8709 const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
8710 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8711 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8712 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8713 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8714 src -= 8;
8715 dst[31] = (Sint8) ((sample7 + (3 * last_sample7)) >> 2);
8716 dst[30] = (Sint8) ((sample6 + (3 * last_sample6)) >> 2);
8717 dst[29] = (Sint8) ((sample5 + (3 * last_sample5)) >> 2);
8718 dst[28] = (Sint8) ((sample4 + (3 * last_sample4)) >> 2);
8719 dst[27] = (Sint8) ((sample3 + (3 * last_sample3)) >> 2);
8720 dst[26] = (Sint8) ((sample2 + (3 * last_sample2)) >> 2);
8721 dst[25] = (Sint8) ((sample1 + (3 * last_sample1)) >> 2);
8722 dst[24] = (Sint8) ((sample0 + (3 * last_sample0)) >> 2);
8723 dst[23] = (Sint8) ((sample7 + last_sample7) >> 1);
8724 dst[22] = (Sint8) ((sample6 + last_sample6) >> 1);
8725 dst[21] = (Sint8) ((sample5 + last_sample5) >> 1);
8726 dst[20] = (Sint8) ((sample4 + last_sample4) >> 1);
8727 dst[19] = (Sint8) ((sample3 + last_sample3) >> 1);
8728 dst[18] = (Sint8) ((sample2 + last_sample2) >> 1);
8729 dst[17] = (Sint8) ((sample1 + last_sample1) >> 1);
8730 dst[16] = (Sint8) ((sample0 + last_sample0) >> 1);
8731 dst[15] = (Sint8) (((3 * sample7) + last_sample7) >> 2);
8732 dst[14] = (Sint8) (((3 * sample6) + last_sample6) >> 2);
8733 dst[13] = (Sint8) (((3 * sample5) + last_sample5) >> 2);
8734 dst[12] = (Sint8) (((3 * sample4) + last_sample4) >> 2);
8735 dst[11] = (Sint8) (((3 * sample3) + last_sample3) >> 2);
8736 dst[10] = (Sint8) (((3 * sample2) + last_sample2) >> 2);
8737 dst[9] = (Sint8) (((3 * sample1) + last_sample1) >> 2);
8738 dst[8] = (Sint8) (((3 * sample0) + last_sample0) >> 2);
8739 dst[7] = (Sint8) sample7;
8740 dst[6] = (Sint8) sample6;
8741 dst[5] = (Sint8) sample5;
8742 dst[4] = (Sint8) sample4;
8743 dst[3] = (Sint8) sample3;
8744 dst[2] = (Sint8) sample2;
8745 dst[1] = (Sint8) sample1;
8746 dst[0] = (Sint8) sample0;
8747 last_sample7 = sample7;
8748 last_sample6 = sample6;
8749 last_sample5 = sample5;
8750 last_sample4 = sample4;
8751 last_sample3 = sample3;
8752 last_sample2 = sample2;
8753 last_sample1 = sample1;
8754 last_sample0 = sample0;
8755 dst -= 32;
8756 }
8757
8758 cvt->len_cvt = dstsize;
8759 if (cvt->filters[++cvt->filter_index]) {
8760 cvt->filters[cvt->filter_index] (cvt, format);
8761 }
8762 }
8763
8764 static void SDLCALL
8765 SDL_Downsample_S8_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8766 {
8767 #if DEBUG_CONVERT
8768 fprintf(stderr, "Downsample (x4) AUDIO_S8, 8 channels.\n");
8769 #endif
8770
8771 const int dstsize = cvt->len_cvt / 4;
8772 Sint8 *dst = (Sint8 *) cvt->buf;
8773 const Sint8 *src = (Sint8 *) cvt->buf;
8774 const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
8775 Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
8776 Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
8777 Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
8778 Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
8779 Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
8780 Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
8781 Sint16 last_sample6 = (Sint16) ((Sint8) src[6]);
8782 Sint16 last_sample7 = (Sint16) ((Sint8) src[7]);
8783 while (dst < target) {
8784 const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
8785 const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
8786 const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
8787 const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
8788 const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
8789 const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
8790 const Sint16 sample6 = (Sint16) ((Sint8) src[6]);
8791 const Sint16 sample7 = (Sint16) ((Sint8) src[7]);
8792 src += 32;
8793 dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
8794 dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
8795 dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
8796 dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
8797 dst[4] = (Sint8) ((sample4 + last_sample4) >> 1);
8798 dst[5] = (Sint8) ((sample5 + last_sample5) >> 1);
8799 dst[6] = (Sint8) ((sample6 + last_sample6) >> 1);
8800 dst[7] = (Sint8) ((sample7 + last_sample7) >> 1);
8801 last_sample0 = sample0;
8802 last_sample1 = sample1;
8803 last_sample2 = sample2;
8804 last_sample3 = sample3;
8805 last_sample4 = sample4;
8806 last_sample5 = sample5;
8807 last_sample6 = sample6;
8808 last_sample7 = sample7;
8809 dst += 8;
8810 }
8811
8812 cvt->len_cvt = dstsize;
8813 if (cvt->filters[++cvt->filter_index]) {
8814 cvt->filters[cvt->filter_index] (cvt, format);
8815 }
8816 }
8817
8818 static void SDLCALL
8819 SDL_Upsample_U16LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8820 {
8821 #if DEBUG_CONVERT
8822 fprintf(stderr, "Upsample (x2) AUDIO_U16LSB, 1 channels.\n");
8823 #endif
8824
8825 const int dstsize = cvt->len_cvt * 2;
8826 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1 * 2;
8827 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
8828 const Uint16 *target = ((const Uint16 *) cvt->buf);
8829 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
8830 while (dst >= target) {
8831 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
8832 src--;
8833 dst[1] = (Uint16) ((sample0 + last_sample0) >> 1);
8834 dst[0] = (Uint16) sample0;
8835 last_sample0 = sample0;
8836 dst -= 2;
8837 }
8838
8839 cvt->len_cvt = dstsize;
8840 if (cvt->filters[++cvt->filter_index]) {
8841 cvt->filters[cvt->filter_index] (cvt, format);
8842 }
8843 }
8844
8845 static void SDLCALL
8846 SDL_Downsample_U16LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8847 {
8848 #if DEBUG_CONVERT
8849 fprintf(stderr, "Downsample (x2) AUDIO_U16LSB, 1 channels.\n");
8850 #endif
8851
8852 const int dstsize = cvt->len_cvt / 2;
8853 Uint16 *dst = (Uint16 *) cvt->buf;
8854 const Uint16 *src = (Uint16 *) cvt->buf;
8855 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
8856 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
8857 while (dst < target) {
8858 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
8859 src += 2;
8860 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
8861 last_sample0 = sample0;
8862 dst++;
8863 }
8864
8865 cvt->len_cvt = dstsize;
8866 if (cvt->filters[++cvt->filter_index]) {
8867 cvt->filters[cvt->filter_index] (cvt, format);
8868 }
8869 }
8870
8871 static void SDLCALL
8872 SDL_Upsample_U16LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8873 {
8874 #if DEBUG_CONVERT
8875 fprintf(stderr, "Upsample (x4) AUDIO_U16LSB, 1 channels.\n");
8876 #endif
8877
8878 const int dstsize = cvt->len_cvt * 4;
8879 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1 * 4;
8880 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
8881 const Uint16 *target = ((const Uint16 *) cvt->buf);
8882 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
8883 while (dst >= target) {
8884 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
8885 src--;
8886 dst[3] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
8887 dst[2] = (Uint16) ((sample0 + last_sample0) >> 1);
8888 dst[1] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
8889 dst[0] = (Uint16) sample0;
8890 last_sample0 = sample0;
8891 dst -= 4;
8892 }
8893
8894 cvt->len_cvt = dstsize;
8895 if (cvt->filters[++cvt->filter_index]) {
8896 cvt->filters[cvt->filter_index] (cvt, format);
8897 }
8898 }
8899
8900 static void SDLCALL
8901 SDL_Downsample_U16LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8902 {
8903 #if DEBUG_CONVERT
8904 fprintf(stderr, "Downsample (x4) AUDIO_U16LSB, 1 channels.\n");
8905 #endif
8906
8907 const int dstsize = cvt->len_cvt / 4;
8908 Uint16 *dst = (Uint16 *) cvt->buf;
8909 const Uint16 *src = (Uint16 *) cvt->buf;
8910 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
8911 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
8912 while (dst < target) {
8913 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
8914 src += 4;
8915 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
8916 last_sample0 = sample0;
8917 dst++;
8918 }
8919
8920 cvt->len_cvt = dstsize;
8921 if (cvt->filters[++cvt->filter_index]) {
8922 cvt->filters[cvt->filter_index] (cvt, format);
8923 }
8924 }
8925
8926 static void SDLCALL
8927 SDL_Upsample_U16LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8928 {
8929 #if DEBUG_CONVERT
8930 fprintf(stderr, "Upsample (x2) AUDIO_U16LSB, 2 channels.\n");
8931 #endif
8932
8933 const int dstsize = cvt->len_cvt * 2;
8934 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2 * 2;
8935 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
8936 const Uint16 *target = ((const Uint16 *) cvt->buf);
8937 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
8938 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
8939 while (dst >= target) {
8940 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
8941 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
8942 src -= 2;
8943 dst[3] = (Uint16) ((sample1 + last_sample1) >> 1);
8944 dst[2] = (Uint16) ((sample0 + last_sample0) >> 1);
8945 dst[1] = (Uint16) sample1;
8946 dst[0] = (Uint16) sample0;
8947 last_sample1 = sample1;
8948 last_sample0 = sample0;
8949 dst -= 4;
8950 }
8951
8952 cvt->len_cvt = dstsize;
8953 if (cvt->filters[++cvt->filter_index]) {
8954 cvt->filters[cvt->filter_index] (cvt, format);
8955 }
8956 }
8957
8958 static void SDLCALL
8959 SDL_Downsample_U16LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8960 {
8961 #if DEBUG_CONVERT
8962 fprintf(stderr, "Downsample (x2) AUDIO_U16LSB, 2 channels.\n");
8963 #endif
8964
8965 const int dstsize = cvt->len_cvt / 2;
8966 Uint16 *dst = (Uint16 *) cvt->buf;
8967 const Uint16 *src = (Uint16 *) cvt->buf;
8968 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
8969 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
8970 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
8971 while (dst < target) {
8972 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
8973 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
8974 src += 4;
8975 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
8976 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
8977 last_sample0 = sample0;
8978 last_sample1 = sample1;
8979 dst += 2;
8980 }
8981
8982 cvt->len_cvt = dstsize;
8983 if (cvt->filters[++cvt->filter_index]) {
8984 cvt->filters[cvt->filter_index] (cvt, format);
8985 }
8986 }
8987
8988 static void SDLCALL
8989 SDL_Upsample_U16LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
8990 {
8991 #if DEBUG_CONVERT
8992 fprintf(stderr, "Upsample (x4) AUDIO_U16LSB, 2 channels.\n");
8993 #endif
8994
8995 const int dstsize = cvt->len_cvt * 4;
8996 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2 * 4;
8997 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
8998 const Uint16 *target = ((const Uint16 *) cvt->buf);
8999 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9000 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9001 while (dst >= target) {
9002 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9003 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9004 src -= 2;
9005 dst[7] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
9006 dst[6] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
9007 dst[5] = (Uint16) ((sample1 + last_sample1) >> 1);
9008 dst[4] = (Uint16) ((sample0 + last_sample0) >> 1);
9009 dst[3] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
9010 dst[2] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
9011 dst[1] = (Uint16) sample1;
9012 dst[0] = (Uint16) sample0;
9013 last_sample1 = sample1;
9014 last_sample0 = sample0;
9015 dst -= 8;
9016 }
9017
9018 cvt->len_cvt = dstsize;
9019 if (cvt->filters[++cvt->filter_index]) {
9020 cvt->filters[cvt->filter_index] (cvt, format);
9021 }
9022 }
9023
9024 static void SDLCALL
9025 SDL_Downsample_U16LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9026 {
9027 #if DEBUG_CONVERT
9028 fprintf(stderr, "Downsample (x4) AUDIO_U16LSB, 2 channels.\n");
9029 #endif
9030
9031 const int dstsize = cvt->len_cvt / 4;
9032 Uint16 *dst = (Uint16 *) cvt->buf;
9033 const Uint16 *src = (Uint16 *) cvt->buf;
9034 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
9035 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9036 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9037 while (dst < target) {
9038 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9039 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9040 src += 8;
9041 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
9042 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
9043 last_sample0 = sample0;
9044 last_sample1 = sample1;
9045 dst += 2;
9046 }
9047
9048 cvt->len_cvt = dstsize;
9049 if (cvt->filters[++cvt->filter_index]) {
9050 cvt->filters[cvt->filter_index] (cvt, format);
9051 }
9052 }
9053
9054 static void SDLCALL
9055 SDL_Upsample_U16LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9056 {
9057 #if DEBUG_CONVERT
9058 fprintf(stderr, "Upsample (x2) AUDIO_U16LSB, 4 channels.\n");
9059 #endif
9060
9061 const int dstsize = cvt->len_cvt * 2;
9062 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4 * 2;
9063 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
9064 const Uint16 *target = ((const Uint16 *) cvt->buf);
9065 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9066 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9067 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9068 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9069 while (dst >= target) {
9070 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9071 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9072 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9073 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9074 src -= 4;
9075 dst[7] = (Uint16) ((sample3 + last_sample3) >> 1);
9076 dst[6] = (Uint16) ((sample2 + last_sample2) >> 1);
9077 dst[5] = (Uint16) ((sample1 + last_sample1) >> 1);
9078 dst[4] = (Uint16) ((sample0 + last_sample0) >> 1);
9079 dst[3] = (Uint16) sample3;
9080 dst[2] = (Uint16) sample2;
9081 dst[1] = (Uint16) sample1;
9082 dst[0] = (Uint16) sample0;
9083 last_sample3 = sample3;
9084 last_sample2 = sample2;
9085 last_sample1 = sample1;
9086 last_sample0 = sample0;
9087 dst -= 8;
9088 }
9089
9090 cvt->len_cvt = dstsize;
9091 if (cvt->filters[++cvt->filter_index]) {
9092 cvt->filters[cvt->filter_index] (cvt, format);
9093 }
9094 }
9095
9096 static void SDLCALL
9097 SDL_Downsample_U16LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9098 {
9099 #if DEBUG_CONVERT
9100 fprintf(stderr, "Downsample (x2) AUDIO_U16LSB, 4 channels.\n");
9101 #endif
9102
9103 const int dstsize = cvt->len_cvt / 2;
9104 Uint16 *dst = (Uint16 *) cvt->buf;
9105 const Uint16 *src = (Uint16 *) cvt->buf;
9106 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
9107 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9108 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9109 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9110 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9111 while (dst < target) {
9112 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9113 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9114 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9115 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9116 src += 8;
9117 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
9118 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
9119 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
9120 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
9121 last_sample0 = sample0;
9122 last_sample1 = sample1;
9123 last_sample2 = sample2;
9124 last_sample3 = sample3;
9125 dst += 4;
9126 }
9127
9128 cvt->len_cvt = dstsize;
9129 if (cvt->filters[++cvt->filter_index]) {
9130 cvt->filters[cvt->filter_index] (cvt, format);
9131 }
9132 }
9133
9134 static void SDLCALL
9135 SDL_Upsample_U16LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9136 {
9137 #if DEBUG_CONVERT
9138 fprintf(stderr, "Upsample (x4) AUDIO_U16LSB, 4 channels.\n");
9139 #endif
9140
9141 const int dstsize = cvt->len_cvt * 4;
9142 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4 * 4;
9143 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
9144 const Uint16 *target = ((const Uint16 *) cvt->buf);
9145 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9146 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9147 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9148 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9149 while (dst >= target) {
9150 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9151 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9152 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9153 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9154 src -= 4;
9155 dst[15] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
9156 dst[14] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
9157 dst[13] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
9158 dst[12] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
9159 dst[11] = (Uint16) ((sample3 + last_sample3) >> 1);
9160 dst[10] = (Uint16) ((sample2 + last_sample2) >> 1);
9161 dst[9] = (Uint16) ((sample1 + last_sample1) >> 1);
9162 dst[8] = (Uint16) ((sample0 + last_sample0) >> 1);
9163 dst[7] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
9164 dst[6] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
9165 dst[5] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
9166 dst[4] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
9167 dst[3] = (Uint16) sample3;
9168 dst[2] = (Uint16) sample2;
9169 dst[1] = (Uint16) sample1;
9170 dst[0] = (Uint16) sample0;
9171 last_sample3 = sample3;
9172 last_sample2 = sample2;
9173 last_sample1 = sample1;
9174 last_sample0 = sample0;
9175 dst -= 16;
9176 }
9177
9178 cvt->len_cvt = dstsize;
9179 if (cvt->filters[++cvt->filter_index]) {
9180 cvt->filters[cvt->filter_index] (cvt, format);
9181 }
9182 }
9183
9184 static void SDLCALL
9185 SDL_Downsample_U16LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9186 {
9187 #if DEBUG_CONVERT
9188 fprintf(stderr, "Downsample (x4) AUDIO_U16LSB, 4 channels.\n");
9189 #endif
9190
9191 const int dstsize = cvt->len_cvt / 4;
9192 Uint16 *dst = (Uint16 *) cvt->buf;
9193 const Uint16 *src = (Uint16 *) cvt->buf;
9194 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
9195 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9196 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9197 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9198 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9199 while (dst < target) {
9200 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9201 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9202 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9203 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9204 src += 16;
9205 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
9206 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
9207 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
9208 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
9209 last_sample0 = sample0;
9210 last_sample1 = sample1;
9211 last_sample2 = sample2;
9212 last_sample3 = sample3;
9213 dst += 4;
9214 }
9215
9216 cvt->len_cvt = dstsize;
9217 if (cvt->filters[++cvt->filter_index]) {
9218 cvt->filters[cvt->filter_index] (cvt, format);
9219 }
9220 }
9221
9222 static void SDLCALL
9223 SDL_Upsample_U16LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9224 {
9225 #if DEBUG_CONVERT
9226 fprintf(stderr, "Upsample (x2) AUDIO_U16LSB, 6 channels.\n");
9227 #endif
9228
9229 const int dstsize = cvt->len_cvt * 2;
9230 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6 * 2;
9231 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
9232 const Uint16 *target = ((const Uint16 *) cvt->buf);
9233 Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
9234 Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
9235 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9236 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9237 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9238 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9239 while (dst >= target) {
9240 const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
9241 const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
9242 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9243 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9244 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9245 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9246 src -= 6;
9247 dst[11] = (Uint16) ((sample5 + last_sample5) >> 1);
9248 dst[10] = (Uint16) ((sample4 + last_sample4) >> 1);
9249 dst[9] = (Uint16) ((sample3 + last_sample3) >> 1);
9250 dst[8] = (Uint16) ((sample2 + last_sample2) >> 1);
9251 dst[7] = (Uint16) ((sample1 + last_sample1) >> 1);
9252 dst[6] = (Uint16) ((sample0 + last_sample0) >> 1);
9253 dst[5] = (Uint16) sample5;
9254 dst[4] = (Uint16) sample4;
9255 dst[3] = (Uint16) sample3;
9256 dst[2] = (Uint16) sample2;
9257 dst[1] = (Uint16) sample1;
9258 dst[0] = (Uint16) sample0;
9259 last_sample5 = sample5;
9260 last_sample4 = sample4;
9261 last_sample3 = sample3;
9262 last_sample2 = sample2;
9263 last_sample1 = sample1;
9264 last_sample0 = sample0;
9265 dst -= 12;
9266 }
9267
9268 cvt->len_cvt = dstsize;
9269 if (cvt->filters[++cvt->filter_index]) {
9270 cvt->filters[cvt->filter_index] (cvt, format);
9271 }
9272 }
9273
9274 static void SDLCALL
9275 SDL_Downsample_U16LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9276 {
9277 #if DEBUG_CONVERT
9278 fprintf(stderr, "Downsample (x2) AUDIO_U16LSB, 6 channels.\n");
9279 #endif
9280
9281 const int dstsize = cvt->len_cvt / 2;
9282 Uint16 *dst = (Uint16 *) cvt->buf;
9283 const Uint16 *src = (Uint16 *) cvt->buf;
9284 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
9285 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9286 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9287 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9288 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9289 Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
9290 Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
9291 while (dst < target) {
9292 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9293 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9294 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9295 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9296 const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
9297 const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
9298 src += 12;
9299 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
9300 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
9301 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
9302 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
9303 dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
9304 dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
9305 last_sample0 = sample0;
9306 last_sample1 = sample1;
9307 last_sample2 = sample2;
9308 last_sample3 = sample3;
9309 last_sample4 = sample4;
9310 last_sample5 = sample5;
9311 dst += 6;
9312 }
9313
9314 cvt->len_cvt = dstsize;
9315 if (cvt->filters[++cvt->filter_index]) {
9316 cvt->filters[cvt->filter_index] (cvt, format);
9317 }
9318 }
9319
9320 static void SDLCALL
9321 SDL_Upsample_U16LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9322 {
9323 #if DEBUG_CONVERT
9324 fprintf(stderr, "Upsample (x4) AUDIO_U16LSB, 6 channels.\n");
9325 #endif
9326
9327 const int dstsize = cvt->len_cvt * 4;
9328 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6 * 4;
9329 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
9330 const Uint16 *target = ((const Uint16 *) cvt->buf);
9331 Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
9332 Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
9333 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9334 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9335 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9336 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9337 while (dst >= target) {
9338 const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
9339 const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
9340 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9341 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9342 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9343 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9344 src -= 6;
9345 dst[23] = (Uint16) ((sample5 + (3 * last_sample5)) >> 2);
9346 dst[22] = (Uint16) ((sample4 + (3 * last_sample4)) >> 2);
9347 dst[21] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
9348 dst[20] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
9349 dst[19] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
9350 dst[18] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
9351 dst[17] = (Uint16) ((sample5 + last_sample5) >> 1);
9352 dst[16] = (Uint16) ((sample4 + last_sample4) >> 1);
9353 dst[15] = (Uint16) ((sample3 + last_sample3) >> 1);
9354 dst[14] = (Uint16) ((sample2 + last_sample2) >> 1);
9355 dst[13] = (Uint16) ((sample1 + last_sample1) >> 1);
9356 dst[12] = (Uint16) ((sample0 + last_sample0) >> 1);
9357 dst[11] = (Uint16) (((3 * sample5) + last_sample5) >> 2);
9358 dst[10] = (Uint16) (((3 * sample4) + last_sample4) >> 2);
9359 dst[9] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
9360 dst[8] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
9361 dst[7] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
9362 dst[6] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
9363 dst[5] = (Uint16) sample5;
9364 dst[4] = (Uint16) sample4;
9365 dst[3] = (Uint16) sample3;
9366 dst[2] = (Uint16) sample2;
9367 dst[1] = (Uint16) sample1;
9368 dst[0] = (Uint16) sample0;
9369 last_sample5 = sample5;
9370 last_sample4 = sample4;
9371 last_sample3 = sample3;
9372 last_sample2 = sample2;
9373 last_sample1 = sample1;
9374 last_sample0 = sample0;
9375 dst -= 24;
9376 }
9377
9378 cvt->len_cvt = dstsize;
9379 if (cvt->filters[++cvt->filter_index]) {
9380 cvt->filters[cvt->filter_index] (cvt, format);
9381 }
9382 }
9383
9384 static void SDLCALL
9385 SDL_Downsample_U16LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9386 {
9387 #if DEBUG_CONVERT
9388 fprintf(stderr, "Downsample (x4) AUDIO_U16LSB, 6 channels.\n");
9389 #endif
9390
9391 const int dstsize = cvt->len_cvt / 4;
9392 Uint16 *dst = (Uint16 *) cvt->buf;
9393 const Uint16 *src = (Uint16 *) cvt->buf;
9394 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
9395 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9396 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9397 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9398 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9399 Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
9400 Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
9401 while (dst < target) {
9402 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9403 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9404 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9405 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9406 const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
9407 const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
9408 src += 24;
9409 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
9410 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
9411 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
9412 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
9413 dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
9414 dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
9415 last_sample0 = sample0;
9416 last_sample1 = sample1;
9417 last_sample2 = sample2;
9418 last_sample3 = sample3;
9419 last_sample4 = sample4;
9420 last_sample5 = sample5;
9421 dst += 6;
9422 }
9423
9424 cvt->len_cvt = dstsize;
9425 if (cvt->filters[++cvt->filter_index]) {
9426 cvt->filters[cvt->filter_index] (cvt, format);
9427 }
9428 }
9429
9430 static void SDLCALL
9431 SDL_Upsample_U16LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9432 {
9433 #if DEBUG_CONVERT
9434 fprintf(stderr, "Upsample (x2) AUDIO_U16LSB, 8 channels.\n");
9435 #endif
9436
9437 const int dstsize = cvt->len_cvt * 2;
9438 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8 * 2;
9439 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
9440 const Uint16 *target = ((const Uint16 *) cvt->buf);
9441 Sint32 last_sample7 = (Sint32) SDL_SwapLE16(src[7]);
9442 Sint32 last_sample6 = (Sint32) SDL_SwapLE16(src[6]);
9443 Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
9444 Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
9445 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9446 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9447 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9448 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9449 while (dst >= target) {
9450 const Sint32 sample7 = (Sint32) SDL_SwapLE16(src[7]);
9451 const Sint32 sample6 = (Sint32) SDL_SwapLE16(src[6]);
9452 const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
9453 const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
9454 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9455 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9456 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9457 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9458 src -= 8;
9459 dst[15] = (Uint16) ((sample7 + last_sample7) >> 1);
9460 dst[14] = (Uint16) ((sample6 + last_sample6) >> 1);
9461 dst[13] = (Uint16) ((sample5 + last_sample5) >> 1);
9462 dst[12] = (Uint16) ((sample4 + last_sample4) >> 1);
9463 dst[11] = (Uint16) ((sample3 + last_sample3) >> 1);
9464 dst[10] = (Uint16) ((sample2 + last_sample2) >> 1);
9465 dst[9] = (Uint16) ((sample1 + last_sample1) >> 1);
9466 dst[8] = (Uint16) ((sample0 + last_sample0) >> 1);
9467 dst[7] = (Uint16) sample7;
9468 dst[6] = (Uint16) sample6;
9469 dst[5] = (Uint16) sample5;
9470 dst[4] = (Uint16) sample4;
9471 dst[3] = (Uint16) sample3;
9472 dst[2] = (Uint16) sample2;
9473 dst[1] = (Uint16) sample1;
9474 dst[0] = (Uint16) sample0;
9475 last_sample7 = sample7;
9476 last_sample6 = sample6;
9477 last_sample5 = sample5;
9478 last_sample4 = sample4;
9479 last_sample3 = sample3;
9480 last_sample2 = sample2;
9481 last_sample1 = sample1;
9482 last_sample0 = sample0;
9483 dst -= 16;
9484 }
9485
9486 cvt->len_cvt = dstsize;
9487 if (cvt->filters[++cvt->filter_index]) {
9488 cvt->filters[cvt->filter_index] (cvt, format);
9489 }
9490 }
9491
9492 static void SDLCALL
9493 SDL_Downsample_U16LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9494 {
9495 #if DEBUG_CONVERT
9496 fprintf(stderr, "Downsample (x2) AUDIO_U16LSB, 8 channels.\n");
9497 #endif
9498
9499 const int dstsize = cvt->len_cvt / 2;
9500 Uint16 *dst = (Uint16 *) cvt->buf;
9501 const Uint16 *src = (Uint16 *) cvt->buf;
9502 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
9503 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9504 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9505 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9506 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9507 Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
9508 Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
9509 Sint32 last_sample6 = (Sint32) SDL_SwapLE16(src[6]);
9510 Sint32 last_sample7 = (Sint32) SDL_SwapLE16(src[7]);
9511 while (dst < target) {
9512 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9513 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9514 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9515 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9516 const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
9517 const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
9518 const Sint32 sample6 = (Sint32) SDL_SwapLE16(src[6]);
9519 const Sint32 sample7 = (Sint32) SDL_SwapLE16(src[7]);
9520 src += 16;
9521 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
9522 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
9523 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
9524 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
9525 dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
9526 dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
9527 dst[6] = (Uint16) ((sample6 + last_sample6) >> 1);
9528 dst[7] = (Uint16) ((sample7 + last_sample7) >> 1);
9529 last_sample0 = sample0;
9530 last_sample1 = sample1;
9531 last_sample2 = sample2;
9532 last_sample3 = sample3;
9533 last_sample4 = sample4;
9534 last_sample5 = sample5;
9535 last_sample6 = sample6;
9536 last_sample7 = sample7;
9537 dst += 8;
9538 }
9539
9540 cvt->len_cvt = dstsize;
9541 if (cvt->filters[++cvt->filter_index]) {
9542 cvt->filters[cvt->filter_index] (cvt, format);
9543 }
9544 }
9545
9546 static void SDLCALL
9547 SDL_Upsample_U16LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9548 {
9549 #if DEBUG_CONVERT
9550 fprintf(stderr, "Upsample (x4) AUDIO_U16LSB, 8 channels.\n");
9551 #endif
9552
9553 const int dstsize = cvt->len_cvt * 4;
9554 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8 * 4;
9555 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
9556 const Uint16 *target = ((const Uint16 *) cvt->buf);
9557 Sint32 last_sample7 = (Sint32) SDL_SwapLE16(src[7]);
9558 Sint32 last_sample6 = (Sint32) SDL_SwapLE16(src[6]);
9559 Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
9560 Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
9561 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9562 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9563 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9564 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9565 while (dst >= target) {
9566 const Sint32 sample7 = (Sint32) SDL_SwapLE16(src[7]);
9567 const Sint32 sample6 = (Sint32) SDL_SwapLE16(src[6]);
9568 const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
9569 const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
9570 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9571 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9572 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9573 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9574 src -= 8;
9575 dst[31] = (Uint16) ((sample7 + (3 * last_sample7)) >> 2);
9576 dst[30] = (Uint16) ((sample6 + (3 * last_sample6)) >> 2);
9577 dst[29] = (Uint16) ((sample5 + (3 * last_sample5)) >> 2);
9578 dst[28] = (Uint16) ((sample4 + (3 * last_sample4)) >> 2);
9579 dst[27] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
9580 dst[26] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
9581 dst[25] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
9582 dst[24] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
9583 dst[23] = (Uint16) ((sample7 + last_sample7) >> 1);
9584 dst[22] = (Uint16) ((sample6 + last_sample6) >> 1);
9585 dst[21] = (Uint16) ((sample5 + last_sample5) >> 1);
9586 dst[20] = (Uint16) ((sample4 + last_sample4) >> 1);
9587 dst[19] = (Uint16) ((sample3 + last_sample3) >> 1);
9588 dst[18] = (Uint16) ((sample2 + last_sample2) >> 1);
9589 dst[17] = (Uint16) ((sample1 + last_sample1) >> 1);
9590 dst[16] = (Uint16) ((sample0 + last_sample0) >> 1);
9591 dst[15] = (Uint16) (((3 * sample7) + last_sample7) >> 2);
9592 dst[14] = (Uint16) (((3 * sample6) + last_sample6) >> 2);
9593 dst[13] = (Uint16) (((3 * sample5) + last_sample5) >> 2);
9594 dst[12] = (Uint16) (((3 * sample4) + last_sample4) >> 2);
9595 dst[11] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
9596 dst[10] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
9597 dst[9] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
9598 dst[8] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
9599 dst[7] = (Uint16) sample7;
9600 dst[6] = (Uint16) sample6;
9601 dst[5] = (Uint16) sample5;
9602 dst[4] = (Uint16) sample4;
9603 dst[3] = (Uint16) sample3;
9604 dst[2] = (Uint16) sample2;
9605 dst[1] = (Uint16) sample1;
9606 dst[0] = (Uint16) sample0;
9607 last_sample7 = sample7;
9608 last_sample6 = sample6;
9609 last_sample5 = sample5;
9610 last_sample4 = sample4;
9611 last_sample3 = sample3;
9612 last_sample2 = sample2;
9613 last_sample1 = sample1;
9614 last_sample0 = sample0;
9615 dst -= 32;
9616 }
9617
9618 cvt->len_cvt = dstsize;
9619 if (cvt->filters[++cvt->filter_index]) {
9620 cvt->filters[cvt->filter_index] (cvt, format);
9621 }
9622 }
9623
9624 static void SDLCALL
9625 SDL_Downsample_U16LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9626 {
9627 #if DEBUG_CONVERT
9628 fprintf(stderr, "Downsample (x4) AUDIO_U16LSB, 8 channels.\n");
9629 #endif
9630
9631 const int dstsize = cvt->len_cvt / 4;
9632 Uint16 *dst = (Uint16 *) cvt->buf;
9633 const Uint16 *src = (Uint16 *) cvt->buf;
9634 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
9635 Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
9636 Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
9637 Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
9638 Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
9639 Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
9640 Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
9641 Sint32 last_sample6 = (Sint32) SDL_SwapLE16(src[6]);
9642 Sint32 last_sample7 = (Sint32) SDL_SwapLE16(src[7]);
9643 while (dst < target) {
9644 const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
9645 const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
9646 const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
9647 const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
9648 const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
9649 const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
9650 const Sint32 sample6 = (Sint32) SDL_SwapLE16(src[6]);
9651 const Sint32 sample7 = (Sint32) SDL_SwapLE16(src[7]);
9652 src += 32;
9653 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
9654 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
9655 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
9656 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
9657 dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
9658 dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
9659 dst[6] = (Uint16) ((sample6 + last_sample6) >> 1);
9660 dst[7] = (Uint16) ((sample7 + last_sample7) >> 1);
9661 last_sample0 = sample0;
9662 last_sample1 = sample1;
9663 last_sample2 = sample2;
9664 last_sample3 = sample3;
9665 last_sample4 = sample4;
9666 last_sample5 = sample5;
9667 last_sample6 = sample6;
9668 last_sample7 = sample7;
9669 dst += 8;
9670 }
9671
9672 cvt->len_cvt = dstsize;
9673 if (cvt->filters[++cvt->filter_index]) {
9674 cvt->filters[cvt->filter_index] (cvt, format);
9675 }
9676 }
9677
9678 static void SDLCALL
9679 SDL_Upsample_S16LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9680 {
9681 #if DEBUG_CONVERT
9682 fprintf(stderr, "Upsample (x2) AUDIO_S16LSB, 1 channels.\n");
9683 #endif
9684
9685 const int dstsize = cvt->len_cvt * 2;
9686 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1 * 2;
9687 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
9688 const Sint16 *target = ((const Sint16 *) cvt->buf);
9689 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9690 while (dst >= target) {
9691 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9692 src--;
9693 dst[1] = (Sint16) ((sample0 + last_sample0) >> 1);
9694 dst[0] = (Sint16) sample0;
9695 last_sample0 = sample0;
9696 dst -= 2;
9697 }
9698
9699 cvt->len_cvt = dstsize;
9700 if (cvt->filters[++cvt->filter_index]) {
9701 cvt->filters[cvt->filter_index] (cvt, format);
9702 }
9703 }
9704
9705 static void SDLCALL
9706 SDL_Downsample_S16LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9707 {
9708 #if DEBUG_CONVERT
9709 fprintf(stderr, "Downsample (x2) AUDIO_S16LSB, 1 channels.\n");
9710 #endif
9711
9712 const int dstsize = cvt->len_cvt / 2;
9713 Sint16 *dst = (Sint16 *) cvt->buf;
9714 const Sint16 *src = (Sint16 *) cvt->buf;
9715 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
9716 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9717 while (dst < target) {
9718 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9719 src += 2;
9720 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
9721 last_sample0 = sample0;
9722 dst++;
9723 }
9724
9725 cvt->len_cvt = dstsize;
9726 if (cvt->filters[++cvt->filter_index]) {
9727 cvt->filters[cvt->filter_index] (cvt, format);
9728 }
9729 }
9730
9731 static void SDLCALL
9732 SDL_Upsample_S16LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9733 {
9734 #if DEBUG_CONVERT
9735 fprintf(stderr, "Upsample (x4) AUDIO_S16LSB, 1 channels.\n");
9736 #endif
9737
9738 const int dstsize = cvt->len_cvt * 4;
9739 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1 * 4;
9740 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
9741 const Sint16 *target = ((const Sint16 *) cvt->buf);
9742 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9743 while (dst >= target) {
9744 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9745 src--;
9746 dst[3] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
9747 dst[2] = (Sint16) ((sample0 + last_sample0) >> 1);
9748 dst[1] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
9749 dst[0] = (Sint16) sample0;
9750 last_sample0 = sample0;
9751 dst -= 4;
9752 }
9753
9754 cvt->len_cvt = dstsize;
9755 if (cvt->filters[++cvt->filter_index]) {
9756 cvt->filters[cvt->filter_index] (cvt, format);
9757 }
9758 }
9759
9760 static void SDLCALL
9761 SDL_Downsample_S16LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9762 {
9763 #if DEBUG_CONVERT
9764 fprintf(stderr, "Downsample (x4) AUDIO_S16LSB, 1 channels.\n");
9765 #endif
9766
9767 const int dstsize = cvt->len_cvt / 4;
9768 Sint16 *dst = (Sint16 *) cvt->buf;
9769 const Sint16 *src = (Sint16 *) cvt->buf;
9770 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
9771 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9772 while (dst < target) {
9773 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9774 src += 4;
9775 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
9776 last_sample0 = sample0;
9777 dst++;
9778 }
9779
9780 cvt->len_cvt = dstsize;
9781 if (cvt->filters[++cvt->filter_index]) {
9782 cvt->filters[cvt->filter_index] (cvt, format);
9783 }
9784 }
9785
9786 static void SDLCALL
9787 SDL_Upsample_S16LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9788 {
9789 #if DEBUG_CONVERT
9790 fprintf(stderr, "Upsample (x2) AUDIO_S16LSB, 2 channels.\n");
9791 #endif
9792
9793 const int dstsize = cvt->len_cvt * 2;
9794 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2 * 2;
9795 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
9796 const Sint16 *target = ((const Sint16 *) cvt->buf);
9797 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9798 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9799 while (dst >= target) {
9800 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9801 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9802 src -= 2;
9803 dst[3] = (Sint16) ((sample1 + last_sample1) >> 1);
9804 dst[2] = (Sint16) ((sample0 + last_sample0) >> 1);
9805 dst[1] = (Sint16) sample1;
9806 dst[0] = (Sint16) sample0;
9807 last_sample1 = sample1;
9808 last_sample0 = sample0;
9809 dst -= 4;
9810 }
9811
9812 cvt->len_cvt = dstsize;
9813 if (cvt->filters[++cvt->filter_index]) {
9814 cvt->filters[cvt->filter_index] (cvt, format);
9815 }
9816 }
9817
9818 static void SDLCALL
9819 SDL_Downsample_S16LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9820 {
9821 #if DEBUG_CONVERT
9822 fprintf(stderr, "Downsample (x2) AUDIO_S16LSB, 2 channels.\n");
9823 #endif
9824
9825 const int dstsize = cvt->len_cvt / 2;
9826 Sint16 *dst = (Sint16 *) cvt->buf;
9827 const Sint16 *src = (Sint16 *) cvt->buf;
9828 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
9829 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9830 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9831 while (dst < target) {
9832 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9833 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9834 src += 4;
9835 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
9836 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
9837 last_sample0 = sample0;
9838 last_sample1 = sample1;
9839 dst += 2;
9840 }
9841
9842 cvt->len_cvt = dstsize;
9843 if (cvt->filters[++cvt->filter_index]) {
9844 cvt->filters[cvt->filter_index] (cvt, format);
9845 }
9846 }
9847
9848 static void SDLCALL
9849 SDL_Upsample_S16LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9850 {
9851 #if DEBUG_CONVERT
9852 fprintf(stderr, "Upsample (x4) AUDIO_S16LSB, 2 channels.\n");
9853 #endif
9854
9855 const int dstsize = cvt->len_cvt * 4;
9856 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2 * 4;
9857 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
9858 const Sint16 *target = ((const Sint16 *) cvt->buf);
9859 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9860 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9861 while (dst >= target) {
9862 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9863 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9864 src -= 2;
9865 dst[7] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
9866 dst[6] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
9867 dst[5] = (Sint16) ((sample1 + last_sample1) >> 1);
9868 dst[4] = (Sint16) ((sample0 + last_sample0) >> 1);
9869 dst[3] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
9870 dst[2] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
9871 dst[1] = (Sint16) sample1;
9872 dst[0] = (Sint16) sample0;
9873 last_sample1 = sample1;
9874 last_sample0 = sample0;
9875 dst -= 8;
9876 }
9877
9878 cvt->len_cvt = dstsize;
9879 if (cvt->filters[++cvt->filter_index]) {
9880 cvt->filters[cvt->filter_index] (cvt, format);
9881 }
9882 }
9883
9884 static void SDLCALL
9885 SDL_Downsample_S16LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9886 {
9887 #if DEBUG_CONVERT
9888 fprintf(stderr, "Downsample (x4) AUDIO_S16LSB, 2 channels.\n");
9889 #endif
9890
9891 const int dstsize = cvt->len_cvt / 4;
9892 Sint16 *dst = (Sint16 *) cvt->buf;
9893 const Sint16 *src = (Sint16 *) cvt->buf;
9894 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
9895 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9896 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9897 while (dst < target) {
9898 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9899 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9900 src += 8;
9901 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
9902 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
9903 last_sample0 = sample0;
9904 last_sample1 = sample1;
9905 dst += 2;
9906 }
9907
9908 cvt->len_cvt = dstsize;
9909 if (cvt->filters[++cvt->filter_index]) {
9910 cvt->filters[cvt->filter_index] (cvt, format);
9911 }
9912 }
9913
9914 static void SDLCALL
9915 SDL_Upsample_S16LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9916 {
9917 #if DEBUG_CONVERT
9918 fprintf(stderr, "Upsample (x2) AUDIO_S16LSB, 4 channels.\n");
9919 #endif
9920
9921 const int dstsize = cvt->len_cvt * 2;
9922 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4 * 2;
9923 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
9924 const Sint16 *target = ((const Sint16 *) cvt->buf);
9925 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
9926 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
9927 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9928 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9929 while (dst >= target) {
9930 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
9931 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
9932 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9933 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9934 src -= 4;
9935 dst[7] = (Sint16) ((sample3 + last_sample3) >> 1);
9936 dst[6] = (Sint16) ((sample2 + last_sample2) >> 1);
9937 dst[5] = (Sint16) ((sample1 + last_sample1) >> 1);
9938 dst[4] = (Sint16) ((sample0 + last_sample0) >> 1);
9939 dst[3] = (Sint16) sample3;
9940 dst[2] = (Sint16) sample2;
9941 dst[1] = (Sint16) sample1;
9942 dst[0] = (Sint16) sample0;
9943 last_sample3 = sample3;
9944 last_sample2 = sample2;
9945 last_sample1 = sample1;
9946 last_sample0 = sample0;
9947 dst -= 8;
9948 }
9949
9950 cvt->len_cvt = dstsize;
9951 if (cvt->filters[++cvt->filter_index]) {
9952 cvt->filters[cvt->filter_index] (cvt, format);
9953 }
9954 }
9955
9956 static void SDLCALL
9957 SDL_Downsample_S16LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9958 {
9959 #if DEBUG_CONVERT
9960 fprintf(stderr, "Downsample (x2) AUDIO_S16LSB, 4 channels.\n");
9961 #endif
9962
9963 const int dstsize = cvt->len_cvt / 2;
9964 Sint16 *dst = (Sint16 *) cvt->buf;
9965 const Sint16 *src = (Sint16 *) cvt->buf;
9966 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
9967 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9968 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9969 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
9970 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
9971 while (dst < target) {
9972 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
9973 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
9974 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
9975 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
9976 src += 8;
9977 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
9978 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
9979 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
9980 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
9981 last_sample0 = sample0;
9982 last_sample1 = sample1;
9983 last_sample2 = sample2;
9984 last_sample3 = sample3;
9985 dst += 4;
9986 }
9987
9988 cvt->len_cvt = dstsize;
9989 if (cvt->filters[++cvt->filter_index]) {
9990 cvt->filters[cvt->filter_index] (cvt, format);
9991 }
9992 }
9993
9994 static void SDLCALL
9995 SDL_Upsample_S16LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
9996 {
9997 #if DEBUG_CONVERT
9998 fprintf(stderr, "Upsample (x4) AUDIO_S16LSB, 4 channels.\n");
9999 #endif
10000
10001 const int dstsize = cvt->len_cvt * 4;
10002 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4 * 4;
10003 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
10004 const Sint16 *target = ((const Sint16 *) cvt->buf);
10005 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10006 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10007 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10008 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10009 while (dst >= target) {
10010 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10011 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10012 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10013 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10014 src -= 4;
10015 dst[15] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
10016 dst[14] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
10017 dst[13] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
10018 dst[12] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
10019 dst[11] = (Sint16) ((sample3 + last_sample3) >> 1);
10020 dst[10] = (Sint16) ((sample2 + last_sample2) >> 1);
10021 dst[9] = (Sint16) ((sample1 + last_sample1) >> 1);
10022 dst[8] = (Sint16) ((sample0 + last_sample0) >> 1);
10023 dst[7] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
10024 dst[6] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
10025 dst[5] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
10026 dst[4] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
10027 dst[3] = (Sint16) sample3;
10028 dst[2] = (Sint16) sample2;
10029 dst[1] = (Sint16) sample1;
10030 dst[0] = (Sint16) sample0;
10031 last_sample3 = sample3;
10032 last_sample2 = sample2;
10033 last_sample1 = sample1;
10034 last_sample0 = sample0;
10035 dst -= 16;
10036 }
10037
10038 cvt->len_cvt = dstsize;
10039 if (cvt->filters[++cvt->filter_index]) {
10040 cvt->filters[cvt->filter_index] (cvt, format);
10041 }
10042 }
10043
10044 static void SDLCALL
10045 SDL_Downsample_S16LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10046 {
10047 #if DEBUG_CONVERT
10048 fprintf(stderr, "Downsample (x4) AUDIO_S16LSB, 4 channels.\n");
10049 #endif
10050
10051 const int dstsize = cvt->len_cvt / 4;
10052 Sint16 *dst = (Sint16 *) cvt->buf;
10053 const Sint16 *src = (Sint16 *) cvt->buf;
10054 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
10055 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10056 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10057 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10058 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10059 while (dst < target) {
10060 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10061 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10062 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10063 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10064 src += 16;
10065 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
10066 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
10067 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
10068 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
10069 last_sample0 = sample0;
10070 last_sample1 = sample1;
10071 last_sample2 = sample2;
10072 last_sample3 = sample3;
10073 dst += 4;
10074 }
10075
10076 cvt->len_cvt = dstsize;
10077 if (cvt->filters[++cvt->filter_index]) {
10078 cvt->filters[cvt->filter_index] (cvt, format);
10079 }
10080 }
10081
10082 static void SDLCALL
10083 SDL_Upsample_S16LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10084 {
10085 #if DEBUG_CONVERT
10086 fprintf(stderr, "Upsample (x2) AUDIO_S16LSB, 6 channels.\n");
10087 #endif
10088
10089 const int dstsize = cvt->len_cvt * 2;
10090 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6 * 2;
10091 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
10092 const Sint16 *target = ((const Sint16 *) cvt->buf);
10093 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10094 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10095 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10096 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10097 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10098 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10099 while (dst >= target) {
10100 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10101 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10102 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10103 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10104 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10105 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10106 src -= 6;
10107 dst[11] = (Sint16) ((sample5 + last_sample5) >> 1);
10108 dst[10] = (Sint16) ((sample4 + last_sample4) >> 1);
10109 dst[9] = (Sint16) ((sample3 + last_sample3) >> 1);
10110 dst[8] = (Sint16) ((sample2 + last_sample2) >> 1);
10111 dst[7] = (Sint16) ((sample1 + last_sample1) >> 1);
10112 dst[6] = (Sint16) ((sample0 + last_sample0) >> 1);
10113 dst[5] = (Sint16) sample5;
10114 dst[4] = (Sint16) sample4;
10115 dst[3] = (Sint16) sample3;
10116 dst[2] = (Sint16) sample2;
10117 dst[1] = (Sint16) sample1;
10118 dst[0] = (Sint16) sample0;
10119 last_sample5 = sample5;
10120 last_sample4 = sample4;
10121 last_sample3 = sample3;
10122 last_sample2 = sample2;
10123 last_sample1 = sample1;
10124 last_sample0 = sample0;
10125 dst -= 12;
10126 }
10127
10128 cvt->len_cvt = dstsize;
10129 if (cvt->filters[++cvt->filter_index]) {
10130 cvt->filters[cvt->filter_index] (cvt, format);
10131 }
10132 }
10133
10134 static void SDLCALL
10135 SDL_Downsample_S16LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10136 {
10137 #if DEBUG_CONVERT
10138 fprintf(stderr, "Downsample (x2) AUDIO_S16LSB, 6 channels.\n");
10139 #endif
10140
10141 const int dstsize = cvt->len_cvt / 2;
10142 Sint16 *dst = (Sint16 *) cvt->buf;
10143 const Sint16 *src = (Sint16 *) cvt->buf;
10144 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
10145 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10146 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10147 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10148 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10149 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10150 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10151 while (dst < target) {
10152 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10153 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10154 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10155 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10156 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10157 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10158 src += 12;
10159 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
10160 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
10161 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
10162 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
10163 dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
10164 dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
10165 last_sample0 = sample0;
10166 last_sample1 = sample1;
10167 last_sample2 = sample2;
10168 last_sample3 = sample3;
10169 last_sample4 = sample4;
10170 last_sample5 = sample5;
10171 dst += 6;
10172 }
10173
10174 cvt->len_cvt = dstsize;
10175 if (cvt->filters[++cvt->filter_index]) {
10176 cvt->filters[cvt->filter_index] (cvt, format);
10177 }
10178 }
10179
10180 static void SDLCALL
10181 SDL_Upsample_S16LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10182 {
10183 #if DEBUG_CONVERT
10184 fprintf(stderr, "Upsample (x4) AUDIO_S16LSB, 6 channels.\n");
10185 #endif
10186
10187 const int dstsize = cvt->len_cvt * 4;
10188 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6 * 4;
10189 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
10190 const Sint16 *target = ((const Sint16 *) cvt->buf);
10191 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10192 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10193 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10194 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10195 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10196 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10197 while (dst >= target) {
10198 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10199 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10200 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10201 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10202 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10203 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10204 src -= 6;
10205 dst[23] = (Sint16) ((sample5 + (3 * last_sample5)) >> 2);
10206 dst[22] = (Sint16) ((sample4 + (3 * last_sample4)) >> 2);
10207 dst[21] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
10208 dst[20] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
10209 dst[19] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
10210 dst[18] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
10211 dst[17] = (Sint16) ((sample5 + last_sample5) >> 1);
10212 dst[16] = (Sint16) ((sample4 + last_sample4) >> 1);
10213 dst[15] = (Sint16) ((sample3 + last_sample3) >> 1);
10214 dst[14] = (Sint16) ((sample2 + last_sample2) >> 1);
10215 dst[13] = (Sint16) ((sample1 + last_sample1) >> 1);
10216 dst[12] = (Sint16) ((sample0 + last_sample0) >> 1);
10217 dst[11] = (Sint16) (((3 * sample5) + last_sample5) >> 2);
10218 dst[10] = (Sint16) (((3 * sample4) + last_sample4) >> 2);
10219 dst[9] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
10220 dst[8] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
10221 dst[7] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
10222 dst[6] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
10223 dst[5] = (Sint16) sample5;
10224 dst[4] = (Sint16) sample4;
10225 dst[3] = (Sint16) sample3;
10226 dst[2] = (Sint16) sample2;
10227 dst[1] = (Sint16) sample1;
10228 dst[0] = (Sint16) sample0;
10229 last_sample5 = sample5;
10230 last_sample4 = sample4;
10231 last_sample3 = sample3;
10232 last_sample2 = sample2;
10233 last_sample1 = sample1;
10234 last_sample0 = sample0;
10235 dst -= 24;
10236 }
10237
10238 cvt->len_cvt = dstsize;
10239 if (cvt->filters[++cvt->filter_index]) {
10240 cvt->filters[cvt->filter_index] (cvt, format);
10241 }
10242 }
10243
10244 static void SDLCALL
10245 SDL_Downsample_S16LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10246 {
10247 #if DEBUG_CONVERT
10248 fprintf(stderr, "Downsample (x4) AUDIO_S16LSB, 6 channels.\n");
10249 #endif
10250
10251 const int dstsize = cvt->len_cvt / 4;
10252 Sint16 *dst = (Sint16 *) cvt->buf;
10253 const Sint16 *src = (Sint16 *) cvt->buf;
10254 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
10255 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10256 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10257 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10258 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10259 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10260 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10261 while (dst < target) {
10262 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10263 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10264 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10265 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10266 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10267 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10268 src += 24;
10269 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
10270 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
10271 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
10272 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
10273 dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
10274 dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
10275 last_sample0 = sample0;
10276 last_sample1 = sample1;
10277 last_sample2 = sample2;
10278 last_sample3 = sample3;
10279 last_sample4 = sample4;
10280 last_sample5 = sample5;
10281 dst += 6;
10282 }
10283
10284 cvt->len_cvt = dstsize;
10285 if (cvt->filters[++cvt->filter_index]) {
10286 cvt->filters[cvt->filter_index] (cvt, format);
10287 }
10288 }
10289
10290 static void SDLCALL
10291 SDL_Upsample_S16LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10292 {
10293 #if DEBUG_CONVERT
10294 fprintf(stderr, "Upsample (x2) AUDIO_S16LSB, 8 channels.\n");
10295 #endif
10296
10297 const int dstsize = cvt->len_cvt * 2;
10298 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8 * 2;
10299 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
10300 const Sint16 *target = ((const Sint16 *) cvt->buf);
10301 Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
10302 Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
10303 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10304 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10305 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10306 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10307 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10308 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10309 while (dst >= target) {
10310 const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
10311 const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
10312 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10313 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10314 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10315 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10316 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10317 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10318 src -= 8;
10319 dst[15] = (Sint16) ((sample7 + last_sample7) >> 1);
10320 dst[14] = (Sint16) ((sample6 + last_sample6) >> 1);
10321 dst[13] = (Sint16) ((sample5 + last_sample5) >> 1);
10322 dst[12] = (Sint16) ((sample4 + last_sample4) >> 1);
10323 dst[11] = (Sint16) ((sample3 + last_sample3) >> 1);
10324 dst[10] = (Sint16) ((sample2 + last_sample2) >> 1);
10325 dst[9] = (Sint16) ((sample1 + last_sample1) >> 1);
10326 dst[8] = (Sint16) ((sample0 + last_sample0) >> 1);
10327 dst[7] = (Sint16) sample7;
10328 dst[6] = (Sint16) sample6;
10329 dst[5] = (Sint16) sample5;
10330 dst[4] = (Sint16) sample4;
10331 dst[3] = (Sint16) sample3;
10332 dst[2] = (Sint16) sample2;
10333 dst[1] = (Sint16) sample1;
10334 dst[0] = (Sint16) sample0;
10335 last_sample7 = sample7;
10336 last_sample6 = sample6;
10337 last_sample5 = sample5;
10338 last_sample4 = sample4;
10339 last_sample3 = sample3;
10340 last_sample2 = sample2;
10341 last_sample1 = sample1;
10342 last_sample0 = sample0;
10343 dst -= 16;
10344 }
10345
10346 cvt->len_cvt = dstsize;
10347 if (cvt->filters[++cvt->filter_index]) {
10348 cvt->filters[cvt->filter_index] (cvt, format);
10349 }
10350 }
10351
10352 static void SDLCALL
10353 SDL_Downsample_S16LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10354 {
10355 #if DEBUG_CONVERT
10356 fprintf(stderr, "Downsample (x2) AUDIO_S16LSB, 8 channels.\n");
10357 #endif
10358
10359 const int dstsize = cvt->len_cvt / 2;
10360 Sint16 *dst = (Sint16 *) cvt->buf;
10361 const Sint16 *src = (Sint16 *) cvt->buf;
10362 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
10363 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10364 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10365 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10366 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10367 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10368 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10369 Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
10370 Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
10371 while (dst < target) {
10372 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10373 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10374 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10375 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10376 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10377 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10378 const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
10379 const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
10380 src += 16;
10381 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
10382 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
10383 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
10384 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
10385 dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
10386 dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
10387 dst[6] = (Sint16) ((sample6 + last_sample6) >> 1);
10388 dst[7] = (Sint16) ((sample7 + last_sample7) >> 1);
10389 last_sample0 = sample0;
10390 last_sample1 = sample1;
10391 last_sample2 = sample2;
10392 last_sample3 = sample3;
10393 last_sample4 = sample4;
10394 last_sample5 = sample5;
10395 last_sample6 = sample6;
10396 last_sample7 = sample7;
10397 dst += 8;
10398 }
10399
10400 cvt->len_cvt = dstsize;
10401 if (cvt->filters[++cvt->filter_index]) {
10402 cvt->filters[cvt->filter_index] (cvt, format);
10403 }
10404 }
10405
10406 static void SDLCALL
10407 SDL_Upsample_S16LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10408 {
10409 #if DEBUG_CONVERT
10410 fprintf(stderr, "Upsample (x4) AUDIO_S16LSB, 8 channels.\n");
10411 #endif
10412
10413 const int dstsize = cvt->len_cvt * 4;
10414 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8 * 4;
10415 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
10416 const Sint16 *target = ((const Sint16 *) cvt->buf);
10417 Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
10418 Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
10419 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10420 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10421 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10422 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10423 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10424 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10425 while (dst >= target) {
10426 const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
10427 const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
10428 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10429 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10430 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10431 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10432 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10433 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10434 src -= 8;
10435 dst[31] = (Sint16) ((sample7 + (3 * last_sample7)) >> 2);
10436 dst[30] = (Sint16) ((sample6 + (3 * last_sample6)) >> 2);
10437 dst[29] = (Sint16) ((sample5 + (3 * last_sample5)) >> 2);
10438 dst[28] = (Sint16) ((sample4 + (3 * last_sample4)) >> 2);
10439 dst[27] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
10440 dst[26] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
10441 dst[25] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
10442 dst[24] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
10443 dst[23] = (Sint16) ((sample7 + last_sample7) >> 1);
10444 dst[22] = (Sint16) ((sample6 + last_sample6) >> 1);
10445 dst[21] = (Sint16) ((sample5 + last_sample5) >> 1);
10446 dst[20] = (Sint16) ((sample4 + last_sample4) >> 1);
10447 dst[19] = (Sint16) ((sample3 + last_sample3) >> 1);
10448 dst[18] = (Sint16) ((sample2 + last_sample2) >> 1);
10449 dst[17] = (Sint16) ((sample1 + last_sample1) >> 1);
10450 dst[16] = (Sint16) ((sample0 + last_sample0) >> 1);
10451 dst[15] = (Sint16) (((3 * sample7) + last_sample7) >> 2);
10452 dst[14] = (Sint16) (((3 * sample6) + last_sample6) >> 2);
10453 dst[13] = (Sint16) (((3 * sample5) + last_sample5) >> 2);
10454 dst[12] = (Sint16) (((3 * sample4) + last_sample4) >> 2);
10455 dst[11] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
10456 dst[10] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
10457 dst[9] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
10458 dst[8] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
10459 dst[7] = (Sint16) sample7;
10460 dst[6] = (Sint16) sample6;
10461 dst[5] = (Sint16) sample5;
10462 dst[4] = (Sint16) sample4;
10463 dst[3] = (Sint16) sample3;
10464 dst[2] = (Sint16) sample2;
10465 dst[1] = (Sint16) sample1;
10466 dst[0] = (Sint16) sample0;
10467 last_sample7 = sample7;
10468 last_sample6 = sample6;
10469 last_sample5 = sample5;
10470 last_sample4 = sample4;
10471 last_sample3 = sample3;
10472 last_sample2 = sample2;
10473 last_sample1 = sample1;
10474 last_sample0 = sample0;
10475 dst -= 32;
10476 }
10477
10478 cvt->len_cvt = dstsize;
10479 if (cvt->filters[++cvt->filter_index]) {
10480 cvt->filters[cvt->filter_index] (cvt, format);
10481 }
10482 }
10483
10484 static void SDLCALL
10485 SDL_Downsample_S16LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10486 {
10487 #if DEBUG_CONVERT
10488 fprintf(stderr, "Downsample (x4) AUDIO_S16LSB, 8 channels.\n");
10489 #endif
10490
10491 const int dstsize = cvt->len_cvt / 4;
10492 Sint16 *dst = (Sint16 *) cvt->buf;
10493 const Sint16 *src = (Sint16 *) cvt->buf;
10494 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
10495 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10496 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10497 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10498 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10499 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10500 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10501 Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
10502 Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
10503 while (dst < target) {
10504 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
10505 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
10506 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
10507 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
10508 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
10509 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
10510 const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
10511 const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
10512 src += 32;
10513 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
10514 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
10515 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
10516 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
10517 dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
10518 dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
10519 dst[6] = (Sint16) ((sample6 + last_sample6) >> 1);
10520 dst[7] = (Sint16) ((sample7 + last_sample7) >> 1);
10521 last_sample0 = sample0;
10522 last_sample1 = sample1;
10523 last_sample2 = sample2;
10524 last_sample3 = sample3;
10525 last_sample4 = sample4;
10526 last_sample5 = sample5;
10527 last_sample6 = sample6;
10528 last_sample7 = sample7;
10529 dst += 8;
10530 }
10531
10532 cvt->len_cvt = dstsize;
10533 if (cvt->filters[++cvt->filter_index]) {
10534 cvt->filters[cvt->filter_index] (cvt, format);
10535 }
10536 }
10537
10538 static void SDLCALL
10539 SDL_Upsample_U16MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10540 {
10541 #if DEBUG_CONVERT
10542 fprintf(stderr, "Upsample (x2) AUDIO_U16MSB, 1 channels.\n");
10543 #endif
10544
10545 const int dstsize = cvt->len_cvt * 2;
10546 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1 * 2;
10547 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
10548 const Uint16 *target = ((const Uint16 *) cvt->buf);
10549 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10550 while (dst >= target) {
10551 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10552 src--;
10553 dst[1] = (Uint16) ((sample0 + last_sample0) >> 1);
10554 dst[0] = (Uint16) sample0;
10555 last_sample0 = sample0;
10556 dst -= 2;
10557 }
10558
10559 cvt->len_cvt = dstsize;
10560 if (cvt->filters[++cvt->filter_index]) {
10561 cvt->filters[cvt->filter_index] (cvt, format);
10562 }
10563 }
10564
10565 static void SDLCALL
10566 SDL_Downsample_U16MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10567 {
10568 #if DEBUG_CONVERT
10569 fprintf(stderr, "Downsample (x2) AUDIO_U16MSB, 1 channels.\n");
10570 #endif
10571
10572 const int dstsize = cvt->len_cvt / 2;
10573 Uint16 *dst = (Uint16 *) cvt->buf;
10574 const Uint16 *src = (Uint16 *) cvt->buf;
10575 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
10576 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10577 while (dst < target) {
10578 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10579 src += 2;
10580 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
10581 last_sample0 = sample0;
10582 dst++;
10583 }
10584
10585 cvt->len_cvt = dstsize;
10586 if (cvt->filters[++cvt->filter_index]) {
10587 cvt->filters[cvt->filter_index] (cvt, format);
10588 }
10589 }
10590
10591 static void SDLCALL
10592 SDL_Upsample_U16MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10593 {
10594 #if DEBUG_CONVERT
10595 fprintf(stderr, "Upsample (x4) AUDIO_U16MSB, 1 channels.\n");
10596 #endif
10597
10598 const int dstsize = cvt->len_cvt * 4;
10599 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1 * 4;
10600 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
10601 const Uint16 *target = ((const Uint16 *) cvt->buf);
10602 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10603 while (dst >= target) {
10604 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10605 src--;
10606 dst[3] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
10607 dst[2] = (Uint16) ((sample0 + last_sample0) >> 1);
10608 dst[1] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
10609 dst[0] = (Uint16) sample0;
10610 last_sample0 = sample0;
10611 dst -= 4;
10612 }
10613
10614 cvt->len_cvt = dstsize;
10615 if (cvt->filters[++cvt->filter_index]) {
10616 cvt->filters[cvt->filter_index] (cvt, format);
10617 }
10618 }
10619
10620 static void SDLCALL
10621 SDL_Downsample_U16MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10622 {
10623 #if DEBUG_CONVERT
10624 fprintf(stderr, "Downsample (x4) AUDIO_U16MSB, 1 channels.\n");
10625 #endif
10626
10627 const int dstsize = cvt->len_cvt / 4;
10628 Uint16 *dst = (Uint16 *) cvt->buf;
10629 const Uint16 *src = (Uint16 *) cvt->buf;
10630 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
10631 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10632 while (dst < target) {
10633 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10634 src += 4;
10635 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
10636 last_sample0 = sample0;
10637 dst++;
10638 }
10639
10640 cvt->len_cvt = dstsize;
10641 if (cvt->filters[++cvt->filter_index]) {
10642 cvt->filters[cvt->filter_index] (cvt, format);
10643 }
10644 }
10645
10646 static void SDLCALL
10647 SDL_Upsample_U16MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10648 {
10649 #if DEBUG_CONVERT
10650 fprintf(stderr, "Upsample (x2) AUDIO_U16MSB, 2 channels.\n");
10651 #endif
10652
10653 const int dstsize = cvt->len_cvt * 2;
10654 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2 * 2;
10655 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
10656 const Uint16 *target = ((const Uint16 *) cvt->buf);
10657 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
10658 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10659 while (dst >= target) {
10660 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
10661 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10662 src -= 2;
10663 dst[3] = (Uint16) ((sample1 + last_sample1) >> 1);
10664 dst[2] = (Uint16) ((sample0 + last_sample0) >> 1);
10665 dst[1] = (Uint16) sample1;
10666 dst[0] = (Uint16) sample0;
10667 last_sample1 = sample1;
10668 last_sample0 = sample0;
10669 dst -= 4;
10670 }
10671
10672 cvt->len_cvt = dstsize;
10673 if (cvt->filters[++cvt->filter_index]) {
10674 cvt->filters[cvt->filter_index] (cvt, format);
10675 }
10676 }
10677
10678 static void SDLCALL
10679 SDL_Downsample_U16MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10680 {
10681 #if DEBUG_CONVERT
10682 fprintf(stderr, "Downsample (x2) AUDIO_U16MSB, 2 channels.\n");
10683 #endif
10684
10685 const int dstsize = cvt->len_cvt / 2;
10686 Uint16 *dst = (Uint16 *) cvt->buf;
10687 const Uint16 *src = (Uint16 *) cvt->buf;
10688 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
10689 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10690 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
10691 while (dst < target) {
10692 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10693 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
10694 src += 4;
10695 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
10696 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
10697 last_sample0 = sample0;
10698 last_sample1 = sample1;
10699 dst += 2;
10700 }
10701
10702 cvt->len_cvt = dstsize;
10703 if (cvt->filters[++cvt->filter_index]) {
10704 cvt->filters[cvt->filter_index] (cvt, format);
10705 }
10706 }
10707
10708 static void SDLCALL
10709 SDL_Upsample_U16MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10710 {
10711 #if DEBUG_CONVERT
10712 fprintf(stderr, "Upsample (x4) AUDIO_U16MSB, 2 channels.\n");
10713 #endif
10714
10715 const int dstsize = cvt->len_cvt * 4;
10716 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2 * 4;
10717 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
10718 const Uint16 *target = ((const Uint16 *) cvt->buf);
10719 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
10720 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10721 while (dst >= target) {
10722 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
10723 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10724 src -= 2;
10725 dst[7] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
10726 dst[6] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
10727 dst[5] = (Uint16) ((sample1 + last_sample1) >> 1);
10728 dst[4] = (Uint16) ((sample0 + last_sample0) >> 1);
10729 dst[3] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
10730 dst[2] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
10731 dst[1] = (Uint16) sample1;
10732 dst[0] = (Uint16) sample0;
10733 last_sample1 = sample1;
10734 last_sample0 = sample0;
10735 dst -= 8;
10736 }
10737
10738 cvt->len_cvt = dstsize;
10739 if (cvt->filters[++cvt->filter_index]) {
10740 cvt->filters[cvt->filter_index] (cvt, format);
10741 }
10742 }
10743
10744 static void SDLCALL
10745 SDL_Downsample_U16MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10746 {
10747 #if DEBUG_CONVERT
10748 fprintf(stderr, "Downsample (x4) AUDIO_U16MSB, 2 channels.\n");
10749 #endif
10750
10751 const int dstsize = cvt->len_cvt / 4;
10752 Uint16 *dst = (Uint16 *) cvt->buf;
10753 const Uint16 *src = (Uint16 *) cvt->buf;
10754 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
10755 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10756 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
10757 while (dst < target) {
10758 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10759 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
10760 src += 8;
10761 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
10762 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
10763 last_sample0 = sample0;
10764 last_sample1 = sample1;
10765 dst += 2;
10766 }
10767
10768 cvt->len_cvt = dstsize;
10769 if (cvt->filters[++cvt->filter_index]) {
10770 cvt->filters[cvt->filter_index] (cvt, format);
10771 }
10772 }
10773
10774 static void SDLCALL
10775 SDL_Upsample_U16MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10776 {
10777 #if DEBUG_CONVERT
10778 fprintf(stderr, "Upsample (x2) AUDIO_U16MSB, 4 channels.\n");
10779 #endif
10780
10781 const int dstsize = cvt->len_cvt * 2;
10782 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4 * 2;
10783 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
10784 const Uint16 *target = ((const Uint16 *) cvt->buf);
10785 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
10786 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
10787 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
10788 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10789 while (dst >= target) {
10790 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
10791 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
10792 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
10793 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10794 src -= 4;
10795 dst[7] = (Uint16) ((sample3 + last_sample3) >> 1);
10796 dst[6] = (Uint16) ((sample2 + last_sample2) >> 1);
10797 dst[5] = (Uint16) ((sample1 + last_sample1) >> 1);
10798 dst[4] = (Uint16) ((sample0 + last_sample0) >> 1);
10799 dst[3] = (Uint16) sample3;
10800 dst[2] = (Uint16) sample2;
10801 dst[1] = (Uint16) sample1;
10802 dst[0] = (Uint16) sample0;
10803 last_sample3 = sample3;
10804 last_sample2 = sample2;
10805 last_sample1 = sample1;
10806 last_sample0 = sample0;
10807 dst -= 8;
10808 }
10809
10810 cvt->len_cvt = dstsize;
10811 if (cvt->filters[++cvt->filter_index]) {
10812 cvt->filters[cvt->filter_index] (cvt, format);
10813 }
10814 }
10815
10816 static void SDLCALL
10817 SDL_Downsample_U16MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10818 {
10819 #if DEBUG_CONVERT
10820 fprintf(stderr, "Downsample (x2) AUDIO_U16MSB, 4 channels.\n");
10821 #endif
10822
10823 const int dstsize = cvt->len_cvt / 2;
10824 Uint16 *dst = (Uint16 *) cvt->buf;
10825 const Uint16 *src = (Uint16 *) cvt->buf;
10826 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
10827 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10828 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
10829 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
10830 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
10831 while (dst < target) {
10832 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10833 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
10834 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
10835 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
10836 src += 8;
10837 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
10838 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
10839 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
10840 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
10841 last_sample0 = sample0;
10842 last_sample1 = sample1;
10843 last_sample2 = sample2;
10844 last_sample3 = sample3;
10845 dst += 4;
10846 }
10847
10848 cvt->len_cvt = dstsize;
10849 if (cvt->filters[++cvt->filter_index]) {
10850 cvt->filters[cvt->filter_index] (cvt, format);
10851 }
10852 }
10853
10854 static void SDLCALL
10855 SDL_Upsample_U16MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10856 {
10857 #if DEBUG_CONVERT
10858 fprintf(stderr, "Upsample (x4) AUDIO_U16MSB, 4 channels.\n");
10859 #endif
10860
10861 const int dstsize = cvt->len_cvt * 4;
10862 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4 * 4;
10863 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
10864 const Uint16 *target = ((const Uint16 *) cvt->buf);
10865 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
10866 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
10867 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
10868 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10869 while (dst >= target) {
10870 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
10871 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
10872 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
10873 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10874 src -= 4;
10875 dst[15] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
10876 dst[14] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
10877 dst[13] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
10878 dst[12] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
10879 dst[11] = (Uint16) ((sample3 + last_sample3) >> 1);
10880 dst[10] = (Uint16) ((sample2 + last_sample2) >> 1);
10881 dst[9] = (Uint16) ((sample1 + last_sample1) >> 1);
10882 dst[8] = (Uint16) ((sample0 + last_sample0) >> 1);
10883 dst[7] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
10884 dst[6] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
10885 dst[5] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
10886 dst[4] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
10887 dst[3] = (Uint16) sample3;
10888 dst[2] = (Uint16) sample2;
10889 dst[1] = (Uint16) sample1;
10890 dst[0] = (Uint16) sample0;
10891 last_sample3 = sample3;
10892 last_sample2 = sample2;
10893 last_sample1 = sample1;
10894 last_sample0 = sample0;
10895 dst -= 16;
10896 }
10897
10898 cvt->len_cvt = dstsize;
10899 if (cvt->filters[++cvt->filter_index]) {
10900 cvt->filters[cvt->filter_index] (cvt, format);
10901 }
10902 }
10903
10904 static void SDLCALL
10905 SDL_Downsample_U16MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10906 {
10907 #if DEBUG_CONVERT
10908 fprintf(stderr, "Downsample (x4) AUDIO_U16MSB, 4 channels.\n");
10909 #endif
10910
10911 const int dstsize = cvt->len_cvt / 4;
10912 Uint16 *dst = (Uint16 *) cvt->buf;
10913 const Uint16 *src = (Uint16 *) cvt->buf;
10914 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
10915 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10916 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
10917 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
10918 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
10919 while (dst < target) {
10920 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10921 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
10922 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
10923 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
10924 src += 16;
10925 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
10926 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
10927 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
10928 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
10929 last_sample0 = sample0;
10930 last_sample1 = sample1;
10931 last_sample2 = sample2;
10932 last_sample3 = sample3;
10933 dst += 4;
10934 }
10935
10936 cvt->len_cvt = dstsize;
10937 if (cvt->filters[++cvt->filter_index]) {
10938 cvt->filters[cvt->filter_index] (cvt, format);
10939 }
10940 }
10941
10942 static void SDLCALL
10943 SDL_Upsample_U16MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10944 {
10945 #if DEBUG_CONVERT
10946 fprintf(stderr, "Upsample (x2) AUDIO_U16MSB, 6 channels.\n");
10947 #endif
10948
10949 const int dstsize = cvt->len_cvt * 2;
10950 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6 * 2;
10951 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
10952 const Uint16 *target = ((const Uint16 *) cvt->buf);
10953 Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
10954 Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
10955 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
10956 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
10957 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
10958 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
10959 while (dst >= target) {
10960 const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
10961 const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
10962 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
10963 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
10964 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
10965 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
10966 src -= 6;
10967 dst[11] = (Uint16) ((sample5 + last_sample5) >> 1);
10968 dst[10] = (Uint16) ((sample4 + last_sample4) >> 1);
10969 dst[9] = (Uint16) ((sample3 + last_sample3) >> 1);
10970 dst[8] = (Uint16) ((sample2 + last_sample2) >> 1);
10971 dst[7] = (Uint16) ((sample1 + last_sample1) >> 1);
10972 dst[6] = (Uint16) ((sample0 + last_sample0) >> 1);
10973 dst[5] = (Uint16) sample5;
10974 dst[4] = (Uint16) sample4;
10975 dst[3] = (Uint16) sample3;
10976 dst[2] = (Uint16) sample2;
10977 dst[1] = (Uint16) sample1;
10978 dst[0] = (Uint16) sample0;
10979 last_sample5 = sample5;
10980 last_sample4 = sample4;
10981 last_sample3 = sample3;
10982 last_sample2 = sample2;
10983 last_sample1 = sample1;
10984 last_sample0 = sample0;
10985 dst -= 12;
10986 }
10987
10988 cvt->len_cvt = dstsize;
10989 if (cvt->filters[++cvt->filter_index]) {
10990 cvt->filters[cvt->filter_index] (cvt, format);
10991 }
10992 }
10993
10994 static void SDLCALL
10995 SDL_Downsample_U16MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
10996 {
10997 #if DEBUG_CONVERT
10998 fprintf(stderr, "Downsample (x2) AUDIO_U16MSB, 6 channels.\n");
10999 #endif
11000
11001 const int dstsize = cvt->len_cvt / 2;
11002 Uint16 *dst = (Uint16 *) cvt->buf;
11003 const Uint16 *src = (Uint16 *) cvt->buf;
11004 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
11005 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
11006 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
11007 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
11008 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
11009 Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
11010 Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
11011 while (dst < target) {
11012 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
11013 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
11014 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
11015 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
11016 const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
11017 const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
11018 src += 12;
11019 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
11020 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
11021 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
11022 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
11023 dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
11024 dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
11025 last_sample0 = sample0;
11026 last_sample1 = sample1;
11027 last_sample2 = sample2;
11028 last_sample3 = sample3;
11029 last_sample4 = sample4;
11030 last_sample5 = sample5;
11031 dst += 6;
11032 }
11033
11034 cvt->len_cvt = dstsize;
11035 if (cvt->filters[++cvt->filter_index]) {
11036 cvt->filters[cvt->filter_index] (cvt, format);
11037 }
11038 }
11039
11040 static void SDLCALL
11041 SDL_Upsample_U16MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11042 {
11043 #if DEBUG_CONVERT
11044 fprintf(stderr, "Upsample (x4) AUDIO_U16MSB, 6 channels.\n");
11045 #endif
11046
11047 const int dstsize = cvt->len_cvt * 4;
11048 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6 * 4;
11049 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
11050 const Uint16 *target = ((const Uint16 *) cvt->buf);
11051 Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
11052 Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
11053 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
11054 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
11055 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
11056 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
11057 while (dst >= target) {
11058 const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
11059 const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
11060 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
11061 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
11062 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
11063 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
11064 src -= 6;
11065 dst[23] = (Uint16) ((sample5 + (3 * last_sample5)) >> 2);
11066 dst[22] = (Uint16) ((sample4 + (3 * last_sample4)) >> 2);
11067 dst[21] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
11068 dst[20] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
11069 dst[19] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
11070 dst[18] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
11071 dst[17] = (Uint16) ((sample5 + last_sample5) >> 1);
11072 dst[16] = (Uint16) ((sample4 + last_sample4) >> 1);
11073 dst[15] = (Uint16) ((sample3 + last_sample3) >> 1);
11074 dst[14] = (Uint16) ((sample2 + last_sample2) >> 1);
11075 dst[13] = (Uint16) ((sample1 + last_sample1) >> 1);
11076 dst[12] = (Uint16) ((sample0 + last_sample0) >> 1);
11077 dst[11] = (Uint16) (((3 * sample5) + last_sample5) >> 2);
11078 dst[10] = (Uint16) (((3 * sample4) + last_sample4) >> 2);
11079 dst[9] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
11080 dst[8] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
11081 dst[7] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
11082 dst[6] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
11083 dst[5] = (Uint16) sample5;
11084 dst[4] = (Uint16) sample4;
11085 dst[3] = (Uint16) sample3;
11086 dst[2] = (Uint16) sample2;
11087 dst[1] = (Uint16) sample1;
11088 dst[0] = (Uint16) sample0;
11089 last_sample5 = sample5;
11090 last_sample4 = sample4;
11091 last_sample3 = sample3;
11092 last_sample2 = sample2;
11093 last_sample1 = sample1;
11094 last_sample0 = sample0;
11095 dst -= 24;
11096 }
11097
11098 cvt->len_cvt = dstsize;
11099 if (cvt->filters[++cvt->filter_index]) {
11100 cvt->filters[cvt->filter_index] (cvt, format);
11101 }
11102 }
11103
11104 static void SDLCALL
11105 SDL_Downsample_U16MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11106 {
11107 #if DEBUG_CONVERT
11108 fprintf(stderr, "Downsample (x4) AUDIO_U16MSB, 6 channels.\n");
11109 #endif
11110
11111 const int dstsize = cvt->len_cvt / 4;
11112 Uint16 *dst = (Uint16 *) cvt->buf;
11113 const Uint16 *src = (Uint16 *) cvt->buf;
11114 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
11115 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
11116 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
11117 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
11118 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
11119 Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
11120 Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
11121 while (dst < target) {
11122 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
11123 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
11124 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
11125 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
11126 const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
11127 const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
11128 src += 24;
11129 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
11130 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
11131 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
11132 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
11133 dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
11134 dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
11135 last_sample0 = sample0;
11136 last_sample1 = sample1;
11137 last_sample2 = sample2;
11138 last_sample3 = sample3;
11139 last_sample4 = sample4;
11140 last_sample5 = sample5;
11141 dst += 6;
11142 }
11143
11144 cvt->len_cvt = dstsize;
11145 if (cvt->filters[++cvt->filter_index]) {
11146 cvt->filters[cvt->filter_index] (cvt, format);
11147 }
11148 }
11149
11150 static void SDLCALL
11151 SDL_Upsample_U16MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11152 {
11153 #if DEBUG_CONVERT
11154 fprintf(stderr, "Upsample (x2) AUDIO_U16MSB, 8 channels.\n");
11155 #endif
11156
11157 const int dstsize = cvt->len_cvt * 2;
11158 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8 * 2;
11159 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
11160 const Uint16 *target = ((const Uint16 *) cvt->buf);
11161 Sint32 last_sample7 = (Sint32) SDL_SwapBE16(src[7]);
11162 Sint32 last_sample6 = (Sint32) SDL_SwapBE16(src[6]);
11163 Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
11164 Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
11165 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
11166 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
11167 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
11168 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
11169 while (dst >= target) {
11170 const Sint32 sample7 = (Sint32) SDL_SwapBE16(src[7]);
11171 const Sint32 sample6 = (Sint32) SDL_SwapBE16(src[6]);
11172 const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
11173 const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
11174 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
11175 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
11176 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
11177 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
11178 src -= 8;
11179 dst[15] = (Uint16) ((sample7 + last_sample7) >> 1);
11180 dst[14] = (Uint16) ((sample6 + last_sample6) >> 1);
11181 dst[13] = (Uint16) ((sample5 + last_sample5) >> 1);
11182 dst[12] = (Uint16) ((sample4 + last_sample4) >> 1);
11183 dst[11] = (Uint16) ((sample3 + last_sample3) >> 1);
11184 dst[10] = (Uint16) ((sample2 + last_sample2) >> 1);
11185 dst[9] = (Uint16) ((sample1 + last_sample1) >> 1);
11186 dst[8] = (Uint16) ((sample0 + last_sample0) >> 1);
11187 dst[7] = (Uint16) sample7;
11188 dst[6] = (Uint16) sample6;
11189 dst[5] = (Uint16) sample5;
11190 dst[4] = (Uint16) sample4;
11191 dst[3] = (Uint16) sample3;
11192 dst[2] = (Uint16) sample2;
11193 dst[1] = (Uint16) sample1;
11194 dst[0] = (Uint16) sample0;
11195 last_sample7 = sample7;
11196 last_sample6 = sample6;
11197 last_sample5 = sample5;
11198 last_sample4 = sample4;
11199 last_sample3 = sample3;
11200 last_sample2 = sample2;
11201 last_sample1 = sample1;
11202 last_sample0 = sample0;
11203 dst -= 16;
11204 }
11205
11206 cvt->len_cvt = dstsize;
11207 if (cvt->filters[++cvt->filter_index]) {
11208 cvt->filters[cvt->filter_index] (cvt, format);
11209 }
11210 }
11211
11212 static void SDLCALL
11213 SDL_Downsample_U16MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11214 {
11215 #if DEBUG_CONVERT
11216 fprintf(stderr, "Downsample (x2) AUDIO_U16MSB, 8 channels.\n");
11217 #endif
11218
11219 const int dstsize = cvt->len_cvt / 2;
11220 Uint16 *dst = (Uint16 *) cvt->buf;
11221 const Uint16 *src = (Uint16 *) cvt->buf;
11222 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
11223 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
11224 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
11225 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
11226 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
11227 Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
11228 Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
11229 Sint32 last_sample6 = (Sint32) SDL_SwapBE16(src[6]);
11230 Sint32 last_sample7 = (Sint32) SDL_SwapBE16(src[7]);
11231 while (dst < target) {
11232 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
11233 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
11234 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
11235 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
11236 const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
11237 const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
11238 const Sint32 sample6 = (Sint32) SDL_SwapBE16(src[6]);
11239 const Sint32 sample7 = (Sint32) SDL_SwapBE16(src[7]);
11240 src += 16;
11241 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
11242 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
11243 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
11244 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
11245 dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
11246 dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
11247 dst[6] = (Uint16) ((sample6 + last_sample6) >> 1);
11248 dst[7] = (Uint16) ((sample7 + last_sample7) >> 1);
11249 last_sample0 = sample0;
11250 last_sample1 = sample1;
11251 last_sample2 = sample2;
11252 last_sample3 = sample3;
11253 last_sample4 = sample4;
11254 last_sample5 = sample5;
11255 last_sample6 = sample6;
11256 last_sample7 = sample7;
11257 dst += 8;
11258 }
11259
11260 cvt->len_cvt = dstsize;
11261 if (cvt->filters[++cvt->filter_index]) {
11262 cvt->filters[cvt->filter_index] (cvt, format);
11263 }
11264 }
11265
11266 static void SDLCALL
11267 SDL_Upsample_U16MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11268 {
11269 #if DEBUG_CONVERT
11270 fprintf(stderr, "Upsample (x4) AUDIO_U16MSB, 8 channels.\n");
11271 #endif
11272
11273 const int dstsize = cvt->len_cvt * 4;
11274 Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8 * 4;
11275 const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
11276 const Uint16 *target = ((const Uint16 *) cvt->buf);
11277 Sint32 last_sample7 = (Sint32) SDL_SwapBE16(src[7]);
11278 Sint32 last_sample6 = (Sint32) SDL_SwapBE16(src[6]);
11279 Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
11280 Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
11281 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
11282 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
11283 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
11284 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
11285 while (dst >= target) {
11286 const Sint32 sample7 = (Sint32) SDL_SwapBE16(src[7]);
11287 const Sint32 sample6 = (Sint32) SDL_SwapBE16(src[6]);
11288 const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
11289 const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
11290 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
11291 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
11292 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
11293 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
11294 src -= 8;
11295 dst[31] = (Uint16) ((sample7 + (3 * last_sample7)) >> 2);
11296 dst[30] = (Uint16) ((sample6 + (3 * last_sample6)) >> 2);
11297 dst[29] = (Uint16) ((sample5 + (3 * last_sample5)) >> 2);
11298 dst[28] = (Uint16) ((sample4 + (3 * last_sample4)) >> 2);
11299 dst[27] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
11300 dst[26] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
11301 dst[25] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
11302 dst[24] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
11303 dst[23] = (Uint16) ((sample7 + last_sample7) >> 1);
11304 dst[22] = (Uint16) ((sample6 + last_sample6) >> 1);
11305 dst[21] = (Uint16) ((sample5 + last_sample5) >> 1);
11306 dst[20] = (Uint16) ((sample4 + last_sample4) >> 1);
11307 dst[19] = (Uint16) ((sample3 + last_sample3) >> 1);
11308 dst[18] = (Uint16) ((sample2 + last_sample2) >> 1);
11309 dst[17] = (Uint16) ((sample1 + last_sample1) >> 1);
11310 dst[16] = (Uint16) ((sample0 + last_sample0) >> 1);
11311 dst[15] = (Uint16) (((3 * sample7) + last_sample7) >> 2);
11312 dst[14] = (Uint16) (((3 * sample6) + last_sample6) >> 2);
11313 dst[13] = (Uint16) (((3 * sample5) + last_sample5) >> 2);
11314 dst[12] = (Uint16) (((3 * sample4) + last_sample4) >> 2);
11315 dst[11] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
11316 dst[10] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
11317 dst[9] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
11318 dst[8] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
11319 dst[7] = (Uint16) sample7;
11320 dst[6] = (Uint16) sample6;
11321 dst[5] = (Uint16) sample5;
11322 dst[4] = (Uint16) sample4;
11323 dst[3] = (Uint16) sample3;
11324 dst[2] = (Uint16) sample2;
11325 dst[1] = (Uint16) sample1;
11326 dst[0] = (Uint16) sample0;
11327 last_sample7 = sample7;
11328 last_sample6 = sample6;
11329 last_sample5 = sample5;
11330 last_sample4 = sample4;
11331 last_sample3 = sample3;
11332 last_sample2 = sample2;
11333 last_sample1 = sample1;
11334 last_sample0 = sample0;
11335 dst -= 32;
11336 }
11337
11338 cvt->len_cvt = dstsize;
11339 if (cvt->filters[++cvt->filter_index]) {
11340 cvt->filters[cvt->filter_index] (cvt, format);
11341 }
11342 }
11343
11344 static void SDLCALL
11345 SDL_Downsample_U16MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11346 {
11347 #if DEBUG_CONVERT
11348 fprintf(stderr, "Downsample (x4) AUDIO_U16MSB, 8 channels.\n");
11349 #endif
11350
11351 const int dstsize = cvt->len_cvt / 4;
11352 Uint16 *dst = (Uint16 *) cvt->buf;
11353 const Uint16 *src = (Uint16 *) cvt->buf;
11354 const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
11355 Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
11356 Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
11357 Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
11358 Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
11359 Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
11360 Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
11361 Sint32 last_sample6 = (Sint32) SDL_SwapBE16(src[6]);
11362 Sint32 last_sample7 = (Sint32) SDL_SwapBE16(src[7]);
11363 while (dst < target) {
11364 const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
11365 const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
11366 const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
11367 const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
11368 const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
11369 const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
11370 const Sint32 sample6 = (Sint32) SDL_SwapBE16(src[6]);
11371 const Sint32 sample7 = (Sint32) SDL_SwapBE16(src[7]);
11372 src += 32;
11373 dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
11374 dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
11375 dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
11376 dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
11377 dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
11378 dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
11379 dst[6] = (Uint16) ((sample6 + last_sample6) >> 1);
11380 dst[7] = (Uint16) ((sample7 + last_sample7) >> 1);
11381 last_sample0 = sample0;
11382 last_sample1 = sample1;
11383 last_sample2 = sample2;
11384 last_sample3 = sample3;
11385 last_sample4 = sample4;
11386 last_sample5 = sample5;
11387 last_sample6 = sample6;
11388 last_sample7 = sample7;
11389 dst += 8;
11390 }
11391
11392 cvt->len_cvt = dstsize;
11393 if (cvt->filters[++cvt->filter_index]) {
11394 cvt->filters[cvt->filter_index] (cvt, format);
11395 }
11396 }
11397
11398 static void SDLCALL
11399 SDL_Upsample_S16MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11400 {
11401 #if DEBUG_CONVERT
11402 fprintf(stderr, "Upsample (x2) AUDIO_S16MSB, 1 channels.\n");
11403 #endif
11404
11405 const int dstsize = cvt->len_cvt * 2;
11406 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1 * 2;
11407 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
11408 const Sint16 *target = ((const Sint16 *) cvt->buf);
11409 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11410 while (dst >= target) {
11411 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11412 src--;
11413 dst[1] = (Sint16) ((sample0 + last_sample0) >> 1);
11414 dst[0] = (Sint16) sample0;
11415 last_sample0 = sample0;
11416 dst -= 2;
11417 }
11418
11419 cvt->len_cvt = dstsize;
11420 if (cvt->filters[++cvt->filter_index]) {
11421 cvt->filters[cvt->filter_index] (cvt, format);
11422 }
11423 }
11424
11425 static void SDLCALL
11426 SDL_Downsample_S16MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11427 {
11428 #if DEBUG_CONVERT
11429 fprintf(stderr, "Downsample (x2) AUDIO_S16MSB, 1 channels.\n");
11430 #endif
11431
11432 const int dstsize = cvt->len_cvt / 2;
11433 Sint16 *dst = (Sint16 *) cvt->buf;
11434 const Sint16 *src = (Sint16 *) cvt->buf;
11435 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
11436 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11437 while (dst < target) {
11438 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11439 src += 2;
11440 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
11441 last_sample0 = sample0;
11442 dst++;
11443 }
11444
11445 cvt->len_cvt = dstsize;
11446 if (cvt->filters[++cvt->filter_index]) {
11447 cvt->filters[cvt->filter_index] (cvt, format);
11448 }
11449 }
11450
11451 static void SDLCALL
11452 SDL_Upsample_S16MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11453 {
11454 #if DEBUG_CONVERT
11455 fprintf(stderr, "Upsample (x4) AUDIO_S16MSB, 1 channels.\n");
11456 #endif
11457
11458 const int dstsize = cvt->len_cvt * 4;
11459 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1 * 4;
11460 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
11461 const Sint16 *target = ((const Sint16 *) cvt->buf);
11462 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11463 while (dst >= target) {
11464 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11465 src--;
11466 dst[3] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
11467 dst[2] = (Sint16) ((sample0 + last_sample0) >> 1);
11468 dst[1] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
11469 dst[0] = (Sint16) sample0;
11470 last_sample0 = sample0;
11471 dst -= 4;
11472 }
11473
11474 cvt->len_cvt = dstsize;
11475 if (cvt->filters[++cvt->filter_index]) {
11476 cvt->filters[cvt->filter_index] (cvt, format);
11477 }
11478 }
11479
11480 static void SDLCALL
11481 SDL_Downsample_S16MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11482 {
11483 #if DEBUG_CONVERT
11484 fprintf(stderr, "Downsample (x4) AUDIO_S16MSB, 1 channels.\n");
11485 #endif
11486
11487 const int dstsize = cvt->len_cvt / 4;
11488 Sint16 *dst = (Sint16 *) cvt->buf;
11489 const Sint16 *src = (Sint16 *) cvt->buf;
11490 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
11491 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11492 while (dst < target) {
11493 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11494 src += 4;
11495 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
11496 last_sample0 = sample0;
11497 dst++;
11498 }
11499
11500 cvt->len_cvt = dstsize;
11501 if (cvt->filters[++cvt->filter_index]) {
11502 cvt->filters[cvt->filter_index] (cvt, format);
11503 }
11504 }
11505
11506 static void SDLCALL
11507 SDL_Upsample_S16MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11508 {
11509 #if DEBUG_CONVERT
11510 fprintf(stderr, "Upsample (x2) AUDIO_S16MSB, 2 channels.\n");
11511 #endif
11512
11513 const int dstsize = cvt->len_cvt * 2;
11514 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2 * 2;
11515 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
11516 const Sint16 *target = ((const Sint16 *) cvt->buf);
11517 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11518 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11519 while (dst >= target) {
11520 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11521 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11522 src -= 2;
11523 dst[3] = (Sint16) ((sample1 + last_sample1) >> 1);
11524 dst[2] = (Sint16) ((sample0 + last_sample0) >> 1);
11525 dst[1] = (Sint16) sample1;
11526 dst[0] = (Sint16) sample0;
11527 last_sample1 = sample1;
11528 last_sample0 = sample0;
11529 dst -= 4;
11530 }
11531
11532 cvt->len_cvt = dstsize;
11533 if (cvt->filters[++cvt->filter_index]) {
11534 cvt->filters[cvt->filter_index] (cvt, format);
11535 }
11536 }
11537
11538 static void SDLCALL
11539 SDL_Downsample_S16MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11540 {
11541 #if DEBUG_CONVERT
11542 fprintf(stderr, "Downsample (x2) AUDIO_S16MSB, 2 channels.\n");
11543 #endif
11544
11545 const int dstsize = cvt->len_cvt / 2;
11546 Sint16 *dst = (Sint16 *) cvt->buf;
11547 const Sint16 *src = (Sint16 *) cvt->buf;
11548 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
11549 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11550 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11551 while (dst < target) {
11552 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11553 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11554 src += 4;
11555 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
11556 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
11557 last_sample0 = sample0;
11558 last_sample1 = sample1;
11559 dst += 2;
11560 }
11561
11562 cvt->len_cvt = dstsize;
11563 if (cvt->filters[++cvt->filter_index]) {
11564 cvt->filters[cvt->filter_index] (cvt, format);
11565 }
11566 }
11567
11568 static void SDLCALL
11569 SDL_Upsample_S16MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11570 {
11571 #if DEBUG_CONVERT
11572 fprintf(stderr, "Upsample (x4) AUDIO_S16MSB, 2 channels.\n");
11573 #endif
11574
11575 const int dstsize = cvt->len_cvt * 4;
11576 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2 * 4;
11577 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
11578 const Sint16 *target = ((const Sint16 *) cvt->buf);
11579 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11580 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11581 while (dst >= target) {
11582 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11583 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11584 src -= 2;
11585 dst[7] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
11586 dst[6] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
11587 dst[5] = (Sint16) ((sample1 + last_sample1) >> 1);
11588 dst[4] = (Sint16) ((sample0 + last_sample0) >> 1);
11589 dst[3] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
11590 dst[2] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
11591 dst[1] = (Sint16) sample1;
11592 dst[0] = (Sint16) sample0;
11593 last_sample1 = sample1;
11594 last_sample0 = sample0;
11595 dst -= 8;
11596 }
11597
11598 cvt->len_cvt = dstsize;
11599 if (cvt->filters[++cvt->filter_index]) {
11600 cvt->filters[cvt->filter_index] (cvt, format);
11601 }
11602 }
11603
11604 static void SDLCALL
11605 SDL_Downsample_S16MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11606 {
11607 #if DEBUG_CONVERT
11608 fprintf(stderr, "Downsample (x4) AUDIO_S16MSB, 2 channels.\n");
11609 #endif
11610
11611 const int dstsize = cvt->len_cvt / 4;
11612 Sint16 *dst = (Sint16 *) cvt->buf;
11613 const Sint16 *src = (Sint16 *) cvt->buf;
11614 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
11615 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11616 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11617 while (dst < target) {
11618 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11619 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11620 src += 8;
11621 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
11622 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
11623 last_sample0 = sample0;
11624 last_sample1 = sample1;
11625 dst += 2;
11626 }
11627
11628 cvt->len_cvt = dstsize;
11629 if (cvt->filters[++cvt->filter_index]) {
11630 cvt->filters[cvt->filter_index] (cvt, format);
11631 }
11632 }
11633
11634 static void SDLCALL
11635 SDL_Upsample_S16MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11636 {
11637 #if DEBUG_CONVERT
11638 fprintf(stderr, "Upsample (x2) AUDIO_S16MSB, 4 channels.\n");
11639 #endif
11640
11641 const int dstsize = cvt->len_cvt * 2;
11642 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4 * 2;
11643 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
11644 const Sint16 *target = ((const Sint16 *) cvt->buf);
11645 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11646 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11647 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11648 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11649 while (dst >= target) {
11650 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11651 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11652 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11653 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11654 src -= 4;
11655 dst[7] = (Sint16) ((sample3 + last_sample3) >> 1);
11656 dst[6] = (Sint16) ((sample2 + last_sample2) >> 1);
11657 dst[5] = (Sint16) ((sample1 + last_sample1) >> 1);
11658 dst[4] = (Sint16) ((sample0 + last_sample0) >> 1);
11659 dst[3] = (Sint16) sample3;
11660 dst[2] = (Sint16) sample2;
11661 dst[1] = (Sint16) sample1;
11662 dst[0] = (Sint16) sample0;
11663 last_sample3 = sample3;
11664 last_sample2 = sample2;
11665 last_sample1 = sample1;
11666 last_sample0 = sample0;
11667 dst -= 8;
11668 }
11669
11670 cvt->len_cvt = dstsize;
11671 if (cvt->filters[++cvt->filter_index]) {
11672 cvt->filters[cvt->filter_index] (cvt, format);
11673 }
11674 }
11675
11676 static void SDLCALL
11677 SDL_Downsample_S16MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11678 {
11679 #if DEBUG_CONVERT
11680 fprintf(stderr, "Downsample (x2) AUDIO_S16MSB, 4 channels.\n");
11681 #endif
11682
11683 const int dstsize = cvt->len_cvt / 2;
11684 Sint16 *dst = (Sint16 *) cvt->buf;
11685 const Sint16 *src = (Sint16 *) cvt->buf;
11686 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
11687 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11688 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11689 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11690 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11691 while (dst < target) {
11692 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11693 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11694 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11695 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11696 src += 8;
11697 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
11698 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
11699 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
11700 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
11701 last_sample0 = sample0;
11702 last_sample1 = sample1;
11703 last_sample2 = sample2;
11704 last_sample3 = sample3;
11705 dst += 4;
11706 }
11707
11708 cvt->len_cvt = dstsize;
11709 if (cvt->filters[++cvt->filter_index]) {
11710 cvt->filters[cvt->filter_index] (cvt, format);
11711 }
11712 }
11713
11714 static void SDLCALL
11715 SDL_Upsample_S16MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11716 {
11717 #if DEBUG_CONVERT
11718 fprintf(stderr, "Upsample (x4) AUDIO_S16MSB, 4 channels.\n");
11719 #endif
11720
11721 const int dstsize = cvt->len_cvt * 4;
11722 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4 * 4;
11723 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
11724 const Sint16 *target = ((const Sint16 *) cvt->buf);
11725 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11726 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11727 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11728 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11729 while (dst >= target) {
11730 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11731 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11732 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11733 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11734 src -= 4;
11735 dst[15] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
11736 dst[14] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
11737 dst[13] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
11738 dst[12] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
11739 dst[11] = (Sint16) ((sample3 + last_sample3) >> 1);
11740 dst[10] = (Sint16) ((sample2 + last_sample2) >> 1);
11741 dst[9] = (Sint16) ((sample1 + last_sample1) >> 1);
11742 dst[8] = (Sint16) ((sample0 + last_sample0) >> 1);
11743 dst[7] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
11744 dst[6] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
11745 dst[5] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
11746 dst[4] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
11747 dst[3] = (Sint16) sample3;
11748 dst[2] = (Sint16) sample2;
11749 dst[1] = (Sint16) sample1;
11750 dst[0] = (Sint16) sample0;
11751 last_sample3 = sample3;
11752 last_sample2 = sample2;
11753 last_sample1 = sample1;
11754 last_sample0 = sample0;
11755 dst -= 16;
11756 }
11757
11758 cvt->len_cvt = dstsize;
11759 if (cvt->filters[++cvt->filter_index]) {
11760 cvt->filters[cvt->filter_index] (cvt, format);
11761 }
11762 }
11763
11764 static void SDLCALL
11765 SDL_Downsample_S16MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11766 {
11767 #if DEBUG_CONVERT
11768 fprintf(stderr, "Downsample (x4) AUDIO_S16MSB, 4 channels.\n");
11769 #endif
11770
11771 const int dstsize = cvt->len_cvt / 4;
11772 Sint16 *dst = (Sint16 *) cvt->buf;
11773 const Sint16 *src = (Sint16 *) cvt->buf;
11774 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
11775 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11776 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11777 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11778 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11779 while (dst < target) {
11780 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11781 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11782 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11783 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11784 src += 16;
11785 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
11786 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
11787 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
11788 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
11789 last_sample0 = sample0;
11790 last_sample1 = sample1;
11791 last_sample2 = sample2;
11792 last_sample3 = sample3;
11793 dst += 4;
11794 }
11795
11796 cvt->len_cvt = dstsize;
11797 if (cvt->filters[++cvt->filter_index]) {
11798 cvt->filters[cvt->filter_index] (cvt, format);
11799 }
11800 }
11801
11802 static void SDLCALL
11803 SDL_Upsample_S16MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11804 {
11805 #if DEBUG_CONVERT
11806 fprintf(stderr, "Upsample (x2) AUDIO_S16MSB, 6 channels.\n");
11807 #endif
11808
11809 const int dstsize = cvt->len_cvt * 2;
11810 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6 * 2;
11811 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
11812 const Sint16 *target = ((const Sint16 *) cvt->buf);
11813 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
11814 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
11815 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11816 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11817 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11818 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11819 while (dst >= target) {
11820 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
11821 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
11822 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11823 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11824 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11825 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11826 src -= 6;
11827 dst[11] = (Sint16) ((sample5 + last_sample5) >> 1);
11828 dst[10] = (Sint16) ((sample4 + last_sample4) >> 1);
11829 dst[9] = (Sint16) ((sample3 + last_sample3) >> 1);
11830 dst[8] = (Sint16) ((sample2 + last_sample2) >> 1);
11831 dst[7] = (Sint16) ((sample1 + last_sample1) >> 1);
11832 dst[6] = (Sint16) ((sample0 + last_sample0) >> 1);
11833 dst[5] = (Sint16) sample5;
11834 dst[4] = (Sint16) sample4;
11835 dst[3] = (Sint16) sample3;
11836 dst[2] = (Sint16) sample2;
11837 dst[1] = (Sint16) sample1;
11838 dst[0] = (Sint16) sample0;
11839 last_sample5 = sample5;
11840 last_sample4 = sample4;
11841 last_sample3 = sample3;
11842 last_sample2 = sample2;
11843 last_sample1 = sample1;
11844 last_sample0 = sample0;
11845 dst -= 12;
11846 }
11847
11848 cvt->len_cvt = dstsize;
11849 if (cvt->filters[++cvt->filter_index]) {
11850 cvt->filters[cvt->filter_index] (cvt, format);
11851 }
11852 }
11853
11854 static void SDLCALL
11855 SDL_Downsample_S16MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11856 {
11857 #if DEBUG_CONVERT
11858 fprintf(stderr, "Downsample (x2) AUDIO_S16MSB, 6 channels.\n");
11859 #endif
11860
11861 const int dstsize = cvt->len_cvt / 2;
11862 Sint16 *dst = (Sint16 *) cvt->buf;
11863 const Sint16 *src = (Sint16 *) cvt->buf;
11864 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
11865 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11866 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11867 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11868 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11869 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
11870 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
11871 while (dst < target) {
11872 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11873 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11874 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11875 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11876 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
11877 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
11878 src += 12;
11879 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
11880 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
11881 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
11882 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
11883 dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
11884 dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
11885 last_sample0 = sample0;
11886 last_sample1 = sample1;
11887 last_sample2 = sample2;
11888 last_sample3 = sample3;
11889 last_sample4 = sample4;
11890 last_sample5 = sample5;
11891 dst += 6;
11892 }
11893
11894 cvt->len_cvt = dstsize;
11895 if (cvt->filters[++cvt->filter_index]) {
11896 cvt->filters[cvt->filter_index] (cvt, format);
11897 }
11898 }
11899
11900 static void SDLCALL
11901 SDL_Upsample_S16MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11902 {
11903 #if DEBUG_CONVERT
11904 fprintf(stderr, "Upsample (x4) AUDIO_S16MSB, 6 channels.\n");
11905 #endif
11906
11907 const int dstsize = cvt->len_cvt * 4;
11908 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6 * 4;
11909 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
11910 const Sint16 *target = ((const Sint16 *) cvt->buf);
11911 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
11912 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
11913 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11914 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11915 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11916 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11917 while (dst >= target) {
11918 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
11919 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
11920 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11921 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11922 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11923 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11924 src -= 6;
11925 dst[23] = (Sint16) ((sample5 + (3 * last_sample5)) >> 2);
11926 dst[22] = (Sint16) ((sample4 + (3 * last_sample4)) >> 2);
11927 dst[21] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
11928 dst[20] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
11929 dst[19] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
11930 dst[18] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
11931 dst[17] = (Sint16) ((sample5 + last_sample5) >> 1);
11932 dst[16] = (Sint16) ((sample4 + last_sample4) >> 1);
11933 dst[15] = (Sint16) ((sample3 + last_sample3) >> 1);
11934 dst[14] = (Sint16) ((sample2 + last_sample2) >> 1);
11935 dst[13] = (Sint16) ((sample1 + last_sample1) >> 1);
11936 dst[12] = (Sint16) ((sample0 + last_sample0) >> 1);
11937 dst[11] = (Sint16) (((3 * sample5) + last_sample5) >> 2);
11938 dst[10] = (Sint16) (((3 * sample4) + last_sample4) >> 2);
11939 dst[9] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
11940 dst[8] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
11941 dst[7] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
11942 dst[6] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
11943 dst[5] = (Sint16) sample5;
11944 dst[4] = (Sint16) sample4;
11945 dst[3] = (Sint16) sample3;
11946 dst[2] = (Sint16) sample2;
11947 dst[1] = (Sint16) sample1;
11948 dst[0] = (Sint16) sample0;
11949 last_sample5 = sample5;
11950 last_sample4 = sample4;
11951 last_sample3 = sample3;
11952 last_sample2 = sample2;
11953 last_sample1 = sample1;
11954 last_sample0 = sample0;
11955 dst -= 24;
11956 }
11957
11958 cvt->len_cvt = dstsize;
11959 if (cvt->filters[++cvt->filter_index]) {
11960 cvt->filters[cvt->filter_index] (cvt, format);
11961 }
11962 }
11963
11964 static void SDLCALL
11965 SDL_Downsample_S16MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
11966 {
11967 #if DEBUG_CONVERT
11968 fprintf(stderr, "Downsample (x4) AUDIO_S16MSB, 6 channels.\n");
11969 #endif
11970
11971 const int dstsize = cvt->len_cvt / 4;
11972 Sint16 *dst = (Sint16 *) cvt->buf;
11973 const Sint16 *src = (Sint16 *) cvt->buf;
11974 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
11975 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11976 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11977 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11978 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11979 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
11980 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
11981 while (dst < target) {
11982 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
11983 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
11984 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
11985 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
11986 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
11987 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
11988 src += 24;
11989 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
11990 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
11991 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
11992 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
11993 dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
11994 dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
11995 last_sample0 = sample0;
11996 last_sample1 = sample1;
11997 last_sample2 = sample2;
11998 last_sample3 = sample3;
11999 last_sample4 = sample4;
12000 last_sample5 = sample5;
12001 dst += 6;
12002 }
12003
12004 cvt->len_cvt = dstsize;
12005 if (cvt->filters[++cvt->filter_index]) {
12006 cvt->filters[cvt->filter_index] (cvt, format);
12007 }
12008 }
12009
12010 static void SDLCALL
12011 SDL_Upsample_S16MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12012 {
12013 #if DEBUG_CONVERT
12014 fprintf(stderr, "Upsample (x2) AUDIO_S16MSB, 8 channels.\n");
12015 #endif
12016
12017 const int dstsize = cvt->len_cvt * 2;
12018 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8 * 2;
12019 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
12020 const Sint16 *target = ((const Sint16 *) cvt->buf);
12021 Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
12022 Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
12023 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
12024 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
12025 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
12026 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
12027 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
12028 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
12029 while (dst >= target) {
12030 const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
12031 const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
12032 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
12033 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
12034 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
12035 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
12036 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
12037 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
12038 src -= 8;
12039 dst[15] = (Sint16) ((sample7 + last_sample7) >> 1);
12040 dst[14] = (Sint16) ((sample6 + last_sample6) >> 1);
12041 dst[13] = (Sint16) ((sample5 + last_sample5) >> 1);
12042 dst[12] = (Sint16) ((sample4 + last_sample4) >> 1);
12043 dst[11] = (Sint16) ((sample3 + last_sample3) >> 1);
12044 dst[10] = (Sint16) ((sample2 + last_sample2) >> 1);
12045 dst[9] = (Sint16) ((sample1 + last_sample1) >> 1);
12046 dst[8] = (Sint16) ((sample0 + last_sample0) >> 1);
12047 dst[7] = (Sint16) sample7;
12048 dst[6] = (Sint16) sample6;
12049 dst[5] = (Sint16) sample5;
12050 dst[4] = (Sint16) sample4;
12051 dst[3] = (Sint16) sample3;
12052 dst[2] = (Sint16) sample2;
12053 dst[1] = (Sint16) sample1;
12054 dst[0] = (Sint16) sample0;
12055 last_sample7 = sample7;
12056 last_sample6 = sample6;
12057 last_sample5 = sample5;
12058 last_sample4 = sample4;
12059 last_sample3 = sample3;
12060 last_sample2 = sample2;
12061 last_sample1 = sample1;
12062 last_sample0 = sample0;
12063 dst -= 16;
12064 }
12065
12066 cvt->len_cvt = dstsize;
12067 if (cvt->filters[++cvt->filter_index]) {
12068 cvt->filters[cvt->filter_index] (cvt, format);
12069 }
12070 }
12071
12072 static void SDLCALL
12073 SDL_Downsample_S16MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12074 {
12075 #if DEBUG_CONVERT
12076 fprintf(stderr, "Downsample (x2) AUDIO_S16MSB, 8 channels.\n");
12077 #endif
12078
12079 const int dstsize = cvt->len_cvt / 2;
12080 Sint16 *dst = (Sint16 *) cvt->buf;
12081 const Sint16 *src = (Sint16 *) cvt->buf;
12082 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
12083 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
12084 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
12085 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
12086 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
12087 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
12088 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
12089 Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
12090 Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
12091 while (dst < target) {
12092 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
12093 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
12094 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
12095 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
12096 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
12097 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
12098 const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
12099 const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
12100 src += 16;
12101 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
12102 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
12103 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
12104 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
12105 dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
12106 dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
12107 dst[6] = (Sint16) ((sample6 + last_sample6) >> 1);
12108 dst[7] = (Sint16) ((sample7 + last_sample7) >> 1);
12109 last_sample0 = sample0;
12110 last_sample1 = sample1;
12111 last_sample2 = sample2;
12112 last_sample3 = sample3;
12113 last_sample4 = sample4;
12114 last_sample5 = sample5;
12115 last_sample6 = sample6;
12116 last_sample7 = sample7;
12117 dst += 8;
12118 }
12119
12120 cvt->len_cvt = dstsize;
12121 if (cvt->filters[++cvt->filter_index]) {
12122 cvt->filters[cvt->filter_index] (cvt, format);
12123 }
12124 }
12125
12126 static void SDLCALL
12127 SDL_Upsample_S16MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12128 {
12129 #if DEBUG_CONVERT
12130 fprintf(stderr, "Upsample (x4) AUDIO_S16MSB, 8 channels.\n");
12131 #endif
12132
12133 const int dstsize = cvt->len_cvt * 4;
12134 Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8 * 4;
12135 const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
12136 const Sint16 *target = ((const Sint16 *) cvt->buf);
12137 Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
12138 Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
12139 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
12140 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
12141 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
12142 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
12143 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
12144 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
12145 while (dst >= target) {
12146 const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
12147 const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
12148 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
12149 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
12150 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
12151 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
12152 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
12153 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
12154 src -= 8;
12155 dst[31] = (Sint16) ((sample7 + (3 * last_sample7)) >> 2);
12156 dst[30] = (Sint16) ((sample6 + (3 * last_sample6)) >> 2);
12157 dst[29] = (Sint16) ((sample5 + (3 * last_sample5)) >> 2);
12158 dst[28] = (Sint16) ((sample4 + (3 * last_sample4)) >> 2);
12159 dst[27] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
12160 dst[26] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
12161 dst[25] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
12162 dst[24] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
12163 dst[23] = (Sint16) ((sample7 + last_sample7) >> 1);
12164 dst[22] = (Sint16) ((sample6 + last_sample6) >> 1);
12165 dst[21] = (Sint16) ((sample5 + last_sample5) >> 1);
12166 dst[20] = (Sint16) ((sample4 + last_sample4) >> 1);
12167 dst[19] = (Sint16) ((sample3 + last_sample3) >> 1);
12168 dst[18] = (Sint16) ((sample2 + last_sample2) >> 1);
12169 dst[17] = (Sint16) ((sample1 + last_sample1) >> 1);
12170 dst[16] = (Sint16) ((sample0 + last_sample0) >> 1);
12171 dst[15] = (Sint16) (((3 * sample7) + last_sample7) >> 2);
12172 dst[14] = (Sint16) (((3 * sample6) + last_sample6) >> 2);
12173 dst[13] = (Sint16) (((3 * sample5) + last_sample5) >> 2);
12174 dst[12] = (Sint16) (((3 * sample4) + last_sample4) >> 2);
12175 dst[11] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
12176 dst[10] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
12177 dst[9] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
12178 dst[8] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
12179 dst[7] = (Sint16) sample7;
12180 dst[6] = (Sint16) sample6;
12181 dst[5] = (Sint16) sample5;
12182 dst[4] = (Sint16) sample4;
12183 dst[3] = (Sint16) sample3;
12184 dst[2] = (Sint16) sample2;
12185 dst[1] = (Sint16) sample1;
12186 dst[0] = (Sint16) sample0;
12187 last_sample7 = sample7;
12188 last_sample6 = sample6;
12189 last_sample5 = sample5;
12190 last_sample4 = sample4;
12191 last_sample3 = sample3;
12192 last_sample2 = sample2;
12193 last_sample1 = sample1;
12194 last_sample0 = sample0;
12195 dst -= 32;
12196 }
12197
12198 cvt->len_cvt = dstsize;
12199 if (cvt->filters[++cvt->filter_index]) {
12200 cvt->filters[cvt->filter_index] (cvt, format);
12201 }
12202 }
12203
12204 static void SDLCALL
12205 SDL_Downsample_S16MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12206 {
12207 #if DEBUG_CONVERT
12208 fprintf(stderr, "Downsample (x4) AUDIO_S16MSB, 8 channels.\n");
12209 #endif
12210
12211 const int dstsize = cvt->len_cvt / 4;
12212 Sint16 *dst = (Sint16 *) cvt->buf;
12213 const Sint16 *src = (Sint16 *) cvt->buf;
12214 const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
12215 Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
12216 Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
12217 Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
12218 Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
12219 Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
12220 Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
12221 Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
12222 Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
12223 while (dst < target) {
12224 const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
12225 const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
12226 const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
12227 const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
12228 const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
12229 const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
12230 const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
12231 const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
12232 src += 32;
12233 dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
12234 dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
12235 dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
12236 dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
12237 dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
12238 dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
12239 dst[6] = (Sint16) ((sample6 + last_sample6) >> 1);
12240 dst[7] = (Sint16) ((sample7 + last_sample7) >> 1);
12241 last_sample0 = sample0;
12242 last_sample1 = sample1;
12243 last_sample2 = sample2;
12244 last_sample3 = sample3;
12245 last_sample4 = sample4;
12246 last_sample5 = sample5;
12247 last_sample6 = sample6;
12248 last_sample7 = sample7;
12249 dst += 8;
12250 }
12251
12252 cvt->len_cvt = dstsize;
12253 if (cvt->filters[++cvt->filter_index]) {
12254 cvt->filters[cvt->filter_index] (cvt, format);
12255 }
12256 }
12257
12258 static void SDLCALL
12259 SDL_Upsample_S32LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12260 {
12261 #if DEBUG_CONVERT
12262 fprintf(stderr, "Upsample (x2) AUDIO_S32LSB, 1 channels.\n");
12263 #endif
12264
12265 const int dstsize = cvt->len_cvt * 2;
12266 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1 * 2;
12267 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
12268 const Sint32 *target = ((const Sint32 *) cvt->buf);
12269 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12270 while (dst >= target) {
12271 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12272 src--;
12273 dst[1] = (Sint32) ((sample0 + last_sample0) >> 1);
12274 dst[0] = (Sint32) sample0;
12275 last_sample0 = sample0;
12276 dst -= 2;
12277 }
12278
12279 cvt->len_cvt = dstsize;
12280 if (cvt->filters[++cvt->filter_index]) {
12281 cvt->filters[cvt->filter_index] (cvt, format);
12282 }
12283 }
12284
12285 static void SDLCALL
12286 SDL_Downsample_S32LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12287 {
12288 #if DEBUG_CONVERT
12289 fprintf(stderr, "Downsample (x2) AUDIO_S32LSB, 1 channels.\n");
12290 #endif
12291
12292 const int dstsize = cvt->len_cvt / 2;
12293 Sint32 *dst = (Sint32 *) cvt->buf;
12294 const Sint32 *src = (Sint32 *) cvt->buf;
12295 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
12296 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12297 while (dst < target) {
12298 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12299 src += 2;
12300 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
12301 last_sample0 = sample0;
12302 dst++;
12303 }
12304
12305 cvt->len_cvt = dstsize;
12306 if (cvt->filters[++cvt->filter_index]) {
12307 cvt->filters[cvt->filter_index] (cvt, format);
12308 }
12309 }
12310
12311 static void SDLCALL
12312 SDL_Upsample_S32LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12313 {
12314 #if DEBUG_CONVERT
12315 fprintf(stderr, "Upsample (x4) AUDIO_S32LSB, 1 channels.\n");
12316 #endif
12317
12318 const int dstsize = cvt->len_cvt * 4;
12319 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1 * 4;
12320 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
12321 const Sint32 *target = ((const Sint32 *) cvt->buf);
12322 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12323 while (dst >= target) {
12324 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12325 src--;
12326 dst[3] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
12327 dst[2] = (Sint32) ((sample0 + last_sample0) >> 1);
12328 dst[1] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
12329 dst[0] = (Sint32) sample0;
12330 last_sample0 = sample0;
12331 dst -= 4;
12332 }
12333
12334 cvt->len_cvt = dstsize;
12335 if (cvt->filters[++cvt->filter_index]) {
12336 cvt->filters[cvt->filter_index] (cvt, format);
12337 }
12338 }
12339
12340 static void SDLCALL
12341 SDL_Downsample_S32LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12342 {
12343 #if DEBUG_CONVERT
12344 fprintf(stderr, "Downsample (x4) AUDIO_S32LSB, 1 channels.\n");
12345 #endif
12346
12347 const int dstsize = cvt->len_cvt / 4;
12348 Sint32 *dst = (Sint32 *) cvt->buf;
12349 const Sint32 *src = (Sint32 *) cvt->buf;
12350 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
12351 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12352 while (dst < target) {
12353 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12354 src += 4;
12355 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
12356 last_sample0 = sample0;
12357 dst++;
12358 }
12359
12360 cvt->len_cvt = dstsize;
12361 if (cvt->filters[++cvt->filter_index]) {
12362 cvt->filters[cvt->filter_index] (cvt, format);
12363 }
12364 }
12365
12366 static void SDLCALL
12367 SDL_Upsample_S32LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12368 {
12369 #if DEBUG_CONVERT
12370 fprintf(stderr, "Upsample (x2) AUDIO_S32LSB, 2 channels.\n");
12371 #endif
12372
12373 const int dstsize = cvt->len_cvt * 2;
12374 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2 * 2;
12375 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
12376 const Sint32 *target = ((const Sint32 *) cvt->buf);
12377 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12378 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12379 while (dst >= target) {
12380 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12381 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12382 src -= 2;
12383 dst[3] = (Sint32) ((sample1 + last_sample1) >> 1);
12384 dst[2] = (Sint32) ((sample0 + last_sample0) >> 1);
12385 dst[1] = (Sint32) sample1;
12386 dst[0] = (Sint32) sample0;
12387 last_sample1 = sample1;
12388 last_sample0 = sample0;
12389 dst -= 4;
12390 }
12391
12392 cvt->len_cvt = dstsize;
12393 if (cvt->filters[++cvt->filter_index]) {
12394 cvt->filters[cvt->filter_index] (cvt, format);
12395 }
12396 }
12397
12398 static void SDLCALL
12399 SDL_Downsample_S32LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12400 {
12401 #if DEBUG_CONVERT
12402 fprintf(stderr, "Downsample (x2) AUDIO_S32LSB, 2 channels.\n");
12403 #endif
12404
12405 const int dstsize = cvt->len_cvt / 2;
12406 Sint32 *dst = (Sint32 *) cvt->buf;
12407 const Sint32 *src = (Sint32 *) cvt->buf;
12408 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
12409 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12410 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12411 while (dst < target) {
12412 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12413 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12414 src += 4;
12415 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
12416 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
12417 last_sample0 = sample0;
12418 last_sample1 = sample1;
12419 dst += 2;
12420 }
12421
12422 cvt->len_cvt = dstsize;
12423 if (cvt->filters[++cvt->filter_index]) {
12424 cvt->filters[cvt->filter_index] (cvt, format);
12425 }
12426 }
12427
12428 static void SDLCALL
12429 SDL_Upsample_S32LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12430 {
12431 #if DEBUG_CONVERT
12432 fprintf(stderr, "Upsample (x4) AUDIO_S32LSB, 2 channels.\n");
12433 #endif
12434
12435 const int dstsize = cvt->len_cvt * 4;
12436 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2 * 4;
12437 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
12438 const Sint32 *target = ((const Sint32 *) cvt->buf);
12439 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12440 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12441 while (dst >= target) {
12442 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12443 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12444 src -= 2;
12445 dst[7] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
12446 dst[6] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
12447 dst[5] = (Sint32) ((sample1 + last_sample1) >> 1);
12448 dst[4] = (Sint32) ((sample0 + last_sample0) >> 1);
12449 dst[3] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
12450 dst[2] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
12451 dst[1] = (Sint32) sample1;
12452 dst[0] = (Sint32) sample0;
12453 last_sample1 = sample1;
12454 last_sample0 = sample0;
12455 dst -= 8;
12456 }
12457
12458 cvt->len_cvt = dstsize;
12459 if (cvt->filters[++cvt->filter_index]) {
12460 cvt->filters[cvt->filter_index] (cvt, format);
12461 }
12462 }
12463
12464 static void SDLCALL
12465 SDL_Downsample_S32LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12466 {
12467 #if DEBUG_CONVERT
12468 fprintf(stderr, "Downsample (x4) AUDIO_S32LSB, 2 channels.\n");
12469 #endif
12470
12471 const int dstsize = cvt->len_cvt / 4;
12472 Sint32 *dst = (Sint32 *) cvt->buf;
12473 const Sint32 *src = (Sint32 *) cvt->buf;
12474 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
12475 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12476 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12477 while (dst < target) {
12478 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12479 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12480 src += 8;
12481 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
12482 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
12483 last_sample0 = sample0;
12484 last_sample1 = sample1;
12485 dst += 2;
12486 }
12487
12488 cvt->len_cvt = dstsize;
12489 if (cvt->filters[++cvt->filter_index]) {
12490 cvt->filters[cvt->filter_index] (cvt, format);
12491 }
12492 }
12493
12494 static void SDLCALL
12495 SDL_Upsample_S32LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12496 {
12497 #if DEBUG_CONVERT
12498 fprintf(stderr, "Upsample (x2) AUDIO_S32LSB, 4 channels.\n");
12499 #endif
12500
12501 const int dstsize = cvt->len_cvt * 2;
12502 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4 * 2;
12503 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
12504 const Sint32 *target = ((const Sint32 *) cvt->buf);
12505 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12506 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12507 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12508 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12509 while (dst >= target) {
12510 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12511 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12512 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12513 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12514 src -= 4;
12515 dst[7] = (Sint32) ((sample3 + last_sample3) >> 1);
12516 dst[6] = (Sint32) ((sample2 + last_sample2) >> 1);
12517 dst[5] = (Sint32) ((sample1 + last_sample1) >> 1);
12518 dst[4] = (Sint32) ((sample0 + last_sample0) >> 1);
12519 dst[3] = (Sint32) sample3;
12520 dst[2] = (Sint32) sample2;
12521 dst[1] = (Sint32) sample1;
12522 dst[0] = (Sint32) sample0;
12523 last_sample3 = sample3;
12524 last_sample2 = sample2;
12525 last_sample1 = sample1;
12526 last_sample0 = sample0;
12527 dst -= 8;
12528 }
12529
12530 cvt->len_cvt = dstsize;
12531 if (cvt->filters[++cvt->filter_index]) {
12532 cvt->filters[cvt->filter_index] (cvt, format);
12533 }
12534 }
12535
12536 static void SDLCALL
12537 SDL_Downsample_S32LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12538 {
12539 #if DEBUG_CONVERT
12540 fprintf(stderr, "Downsample (x2) AUDIO_S32LSB, 4 channels.\n");
12541 #endif
12542
12543 const int dstsize = cvt->len_cvt / 2;
12544 Sint32 *dst = (Sint32 *) cvt->buf;
12545 const Sint32 *src = (Sint32 *) cvt->buf;
12546 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
12547 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12548 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12549 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12550 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12551 while (dst < target) {
12552 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12553 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12554 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12555 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12556 src += 8;
12557 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
12558 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
12559 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
12560 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
12561 last_sample0 = sample0;
12562 last_sample1 = sample1;
12563 last_sample2 = sample2;
12564 last_sample3 = sample3;
12565 dst += 4;
12566 }
12567
12568 cvt->len_cvt = dstsize;
12569 if (cvt->filters[++cvt->filter_index]) {
12570 cvt->filters[cvt->filter_index] (cvt, format);
12571 }
12572 }
12573
12574 static void SDLCALL
12575 SDL_Upsample_S32LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12576 {
12577 #if DEBUG_CONVERT
12578 fprintf(stderr, "Upsample (x4) AUDIO_S32LSB, 4 channels.\n");
12579 #endif
12580
12581 const int dstsize = cvt->len_cvt * 4;
12582 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4 * 4;
12583 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
12584 const Sint32 *target = ((const Sint32 *) cvt->buf);
12585 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12586 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12587 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12588 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12589 while (dst >= target) {
12590 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12591 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12592 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12593 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12594 src -= 4;
12595 dst[15] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
12596 dst[14] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
12597 dst[13] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
12598 dst[12] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
12599 dst[11] = (Sint32) ((sample3 + last_sample3) >> 1);
12600 dst[10] = (Sint32) ((sample2 + last_sample2) >> 1);
12601 dst[9] = (Sint32) ((sample1 + last_sample1) >> 1);
12602 dst[8] = (Sint32) ((sample0 + last_sample0) >> 1);
12603 dst[7] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
12604 dst[6] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
12605 dst[5] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
12606 dst[4] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
12607 dst[3] = (Sint32) sample3;
12608 dst[2] = (Sint32) sample2;
12609 dst[1] = (Sint32) sample1;
12610 dst[0] = (Sint32) sample0;
12611 last_sample3 = sample3;
12612 last_sample2 = sample2;
12613 last_sample1 = sample1;
12614 last_sample0 = sample0;
12615 dst -= 16;
12616 }
12617
12618 cvt->len_cvt = dstsize;
12619 if (cvt->filters[++cvt->filter_index]) {
12620 cvt->filters[cvt->filter_index] (cvt, format);
12621 }
12622 }
12623
12624 static void SDLCALL
12625 SDL_Downsample_S32LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12626 {
12627 #if DEBUG_CONVERT
12628 fprintf(stderr, "Downsample (x4) AUDIO_S32LSB, 4 channels.\n");
12629 #endif
12630
12631 const int dstsize = cvt->len_cvt / 4;
12632 Sint32 *dst = (Sint32 *) cvt->buf;
12633 const Sint32 *src = (Sint32 *) cvt->buf;
12634 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
12635 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12636 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12637 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12638 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12639 while (dst < target) {
12640 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12641 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12642 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12643 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12644 src += 16;
12645 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
12646 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
12647 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
12648 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
12649 last_sample0 = sample0;
12650 last_sample1 = sample1;
12651 last_sample2 = sample2;
12652 last_sample3 = sample3;
12653 dst += 4;
12654 }
12655
12656 cvt->len_cvt = dstsize;
12657 if (cvt->filters[++cvt->filter_index]) {
12658 cvt->filters[cvt->filter_index] (cvt, format);
12659 }
12660 }
12661
12662 static void SDLCALL
12663 SDL_Upsample_S32LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12664 {
12665 #if DEBUG_CONVERT
12666 fprintf(stderr, "Upsample (x2) AUDIO_S32LSB, 6 channels.\n");
12667 #endif
12668
12669 const int dstsize = cvt->len_cvt * 2;
12670 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6 * 2;
12671 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
12672 const Sint32 *target = ((const Sint32 *) cvt->buf);
12673 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12674 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12675 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12676 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12677 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12678 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12679 while (dst >= target) {
12680 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12681 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12682 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12683 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12684 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12685 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12686 src -= 6;
12687 dst[11] = (Sint32) ((sample5 + last_sample5) >> 1);
12688 dst[10] = (Sint32) ((sample4 + last_sample4) >> 1);
12689 dst[9] = (Sint32) ((sample3 + last_sample3) >> 1);
12690 dst[8] = (Sint32) ((sample2 + last_sample2) >> 1);
12691 dst[7] = (Sint32) ((sample1 + last_sample1) >> 1);
12692 dst[6] = (Sint32) ((sample0 + last_sample0) >> 1);
12693 dst[5] = (Sint32) sample5;
12694 dst[4] = (Sint32) sample4;
12695 dst[3] = (Sint32) sample3;
12696 dst[2] = (Sint32) sample2;
12697 dst[1] = (Sint32) sample1;
12698 dst[0] = (Sint32) sample0;
12699 last_sample5 = sample5;
12700 last_sample4 = sample4;
12701 last_sample3 = sample3;
12702 last_sample2 = sample2;
12703 last_sample1 = sample1;
12704 last_sample0 = sample0;
12705 dst -= 12;
12706 }
12707
12708 cvt->len_cvt = dstsize;
12709 if (cvt->filters[++cvt->filter_index]) {
12710 cvt->filters[cvt->filter_index] (cvt, format);
12711 }
12712 }
12713
12714 static void SDLCALL
12715 SDL_Downsample_S32LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12716 {
12717 #if DEBUG_CONVERT
12718 fprintf(stderr, "Downsample (x2) AUDIO_S32LSB, 6 channels.\n");
12719 #endif
12720
12721 const int dstsize = cvt->len_cvt / 2;
12722 Sint32 *dst = (Sint32 *) cvt->buf;
12723 const Sint32 *src = (Sint32 *) cvt->buf;
12724 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
12725 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12726 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12727 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12728 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12729 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12730 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12731 while (dst < target) {
12732 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12733 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12734 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12735 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12736 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12737 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12738 src += 12;
12739 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
12740 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
12741 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
12742 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
12743 dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
12744 dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
12745 last_sample0 = sample0;
12746 last_sample1 = sample1;
12747 last_sample2 = sample2;
12748 last_sample3 = sample3;
12749 last_sample4 = sample4;
12750 last_sample5 = sample5;
12751 dst += 6;
12752 }
12753
12754 cvt->len_cvt = dstsize;
12755 if (cvt->filters[++cvt->filter_index]) {
12756 cvt->filters[cvt->filter_index] (cvt, format);
12757 }
12758 }
12759
12760 static void SDLCALL
12761 SDL_Upsample_S32LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12762 {
12763 #if DEBUG_CONVERT
12764 fprintf(stderr, "Upsample (x4) AUDIO_S32LSB, 6 channels.\n");
12765 #endif
12766
12767 const int dstsize = cvt->len_cvt * 4;
12768 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6 * 4;
12769 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
12770 const Sint32 *target = ((const Sint32 *) cvt->buf);
12771 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12772 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12773 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12774 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12775 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12776 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12777 while (dst >= target) {
12778 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12779 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12780 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12781 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12782 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12783 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12784 src -= 6;
12785 dst[23] = (Sint32) ((sample5 + (3 * last_sample5)) >> 2);
12786 dst[22] = (Sint32) ((sample4 + (3 * last_sample4)) >> 2);
12787 dst[21] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
12788 dst[20] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
12789 dst[19] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
12790 dst[18] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
12791 dst[17] = (Sint32) ((sample5 + last_sample5) >> 1);
12792 dst[16] = (Sint32) ((sample4 + last_sample4) >> 1);
12793 dst[15] = (Sint32) ((sample3 + last_sample3) >> 1);
12794 dst[14] = (Sint32) ((sample2 + last_sample2) >> 1);
12795 dst[13] = (Sint32) ((sample1 + last_sample1) >> 1);
12796 dst[12] = (Sint32) ((sample0 + last_sample0) >> 1);
12797 dst[11] = (Sint32) (((3 * sample5) + last_sample5) >> 2);
12798 dst[10] = (Sint32) (((3 * sample4) + last_sample4) >> 2);
12799 dst[9] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
12800 dst[8] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
12801 dst[7] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
12802 dst[6] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
12803 dst[5] = (Sint32) sample5;
12804 dst[4] = (Sint32) sample4;
12805 dst[3] = (Sint32) sample3;
12806 dst[2] = (Sint32) sample2;
12807 dst[1] = (Sint32) sample1;
12808 dst[0] = (Sint32) sample0;
12809 last_sample5 = sample5;
12810 last_sample4 = sample4;
12811 last_sample3 = sample3;
12812 last_sample2 = sample2;
12813 last_sample1 = sample1;
12814 last_sample0 = sample0;
12815 dst -= 24;
12816 }
12817
12818 cvt->len_cvt = dstsize;
12819 if (cvt->filters[++cvt->filter_index]) {
12820 cvt->filters[cvt->filter_index] (cvt, format);
12821 }
12822 }
12823
12824 static void SDLCALL
12825 SDL_Downsample_S32LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12826 {
12827 #if DEBUG_CONVERT
12828 fprintf(stderr, "Downsample (x4) AUDIO_S32LSB, 6 channels.\n");
12829 #endif
12830
12831 const int dstsize = cvt->len_cvt / 4;
12832 Sint32 *dst = (Sint32 *) cvt->buf;
12833 const Sint32 *src = (Sint32 *) cvt->buf;
12834 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
12835 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12836 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12837 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12838 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12839 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12840 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12841 while (dst < target) {
12842 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12843 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12844 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12845 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12846 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12847 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12848 src += 24;
12849 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
12850 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
12851 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
12852 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
12853 dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
12854 dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
12855 last_sample0 = sample0;
12856 last_sample1 = sample1;
12857 last_sample2 = sample2;
12858 last_sample3 = sample3;
12859 last_sample4 = sample4;
12860 last_sample5 = sample5;
12861 dst += 6;
12862 }
12863
12864 cvt->len_cvt = dstsize;
12865 if (cvt->filters[++cvt->filter_index]) {
12866 cvt->filters[cvt->filter_index] (cvt, format);
12867 }
12868 }
12869
12870 static void SDLCALL
12871 SDL_Upsample_S32LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12872 {
12873 #if DEBUG_CONVERT
12874 fprintf(stderr, "Upsample (x2) AUDIO_S32LSB, 8 channels.\n");
12875 #endif
12876
12877 const int dstsize = cvt->len_cvt * 2;
12878 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8 * 2;
12879 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
12880 const Sint32 *target = ((const Sint32 *) cvt->buf);
12881 Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
12882 Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
12883 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12884 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12885 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12886 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12887 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12888 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12889 while (dst >= target) {
12890 const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
12891 const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
12892 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12893 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12894 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12895 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12896 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12897 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12898 src -= 8;
12899 dst[15] = (Sint32) ((sample7 + last_sample7) >> 1);
12900 dst[14] = (Sint32) ((sample6 + last_sample6) >> 1);
12901 dst[13] = (Sint32) ((sample5 + last_sample5) >> 1);
12902 dst[12] = (Sint32) ((sample4 + last_sample4) >> 1);
12903 dst[11] = (Sint32) ((sample3 + last_sample3) >> 1);
12904 dst[10] = (Sint32) ((sample2 + last_sample2) >> 1);
12905 dst[9] = (Sint32) ((sample1 + last_sample1) >> 1);
12906 dst[8] = (Sint32) ((sample0 + last_sample0) >> 1);
12907 dst[7] = (Sint32) sample7;
12908 dst[6] = (Sint32) sample6;
12909 dst[5] = (Sint32) sample5;
12910 dst[4] = (Sint32) sample4;
12911 dst[3] = (Sint32) sample3;
12912 dst[2] = (Sint32) sample2;
12913 dst[1] = (Sint32) sample1;
12914 dst[0] = (Sint32) sample0;
12915 last_sample7 = sample7;
12916 last_sample6 = sample6;
12917 last_sample5 = sample5;
12918 last_sample4 = sample4;
12919 last_sample3 = sample3;
12920 last_sample2 = sample2;
12921 last_sample1 = sample1;
12922 last_sample0 = sample0;
12923 dst -= 16;
12924 }
12925
12926 cvt->len_cvt = dstsize;
12927 if (cvt->filters[++cvt->filter_index]) {
12928 cvt->filters[cvt->filter_index] (cvt, format);
12929 }
12930 }
12931
12932 static void SDLCALL
12933 SDL_Downsample_S32LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12934 {
12935 #if DEBUG_CONVERT
12936 fprintf(stderr, "Downsample (x2) AUDIO_S32LSB, 8 channels.\n");
12937 #endif
12938
12939 const int dstsize = cvt->len_cvt / 2;
12940 Sint32 *dst = (Sint32 *) cvt->buf;
12941 const Sint32 *src = (Sint32 *) cvt->buf;
12942 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
12943 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12944 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12945 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12946 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12947 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12948 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12949 Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
12950 Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
12951 while (dst < target) {
12952 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
12953 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
12954 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
12955 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
12956 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
12957 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
12958 const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
12959 const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
12960 src += 16;
12961 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
12962 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
12963 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
12964 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
12965 dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
12966 dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
12967 dst[6] = (Sint32) ((sample6 + last_sample6) >> 1);
12968 dst[7] = (Sint32) ((sample7 + last_sample7) >> 1);
12969 last_sample0 = sample0;
12970 last_sample1 = sample1;
12971 last_sample2 = sample2;
12972 last_sample3 = sample3;
12973 last_sample4 = sample4;
12974 last_sample5 = sample5;
12975 last_sample6 = sample6;
12976 last_sample7 = sample7;
12977 dst += 8;
12978 }
12979
12980 cvt->len_cvt = dstsize;
12981 if (cvt->filters[++cvt->filter_index]) {
12982 cvt->filters[cvt->filter_index] (cvt, format);
12983 }
12984 }
12985
12986 static void SDLCALL
12987 SDL_Upsample_S32LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
12988 {
12989 #if DEBUG_CONVERT
12990 fprintf(stderr, "Upsample (x4) AUDIO_S32LSB, 8 channels.\n");
12991 #endif
12992
12993 const int dstsize = cvt->len_cvt * 4;
12994 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8 * 4;
12995 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
12996 const Sint32 *target = ((const Sint32 *) cvt->buf);
12997 Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
12998 Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
12999 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
13000 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
13001 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
13002 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
13003 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
13004 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
13005 while (dst >= target) {
13006 const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
13007 const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
13008 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
13009 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
13010 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
13011 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
13012 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
13013 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
13014 src -= 8;
13015 dst[31] = (Sint32) ((sample7 + (3 * last_sample7)) >> 2);
13016 dst[30] = (Sint32) ((sample6 + (3 * last_sample6)) >> 2);
13017 dst[29] = (Sint32) ((sample5 + (3 * last_sample5)) >> 2);
13018 dst[28] = (Sint32) ((sample4 + (3 * last_sample4)) >> 2);
13019 dst[27] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
13020 dst[26] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
13021 dst[25] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
13022 dst[24] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
13023 dst[23] = (Sint32) ((sample7 + last_sample7) >> 1);
13024 dst[22] = (Sint32) ((sample6 + last_sample6) >> 1);
13025 dst[21] = (Sint32) ((sample5 + last_sample5) >> 1);
13026 dst[20] = (Sint32) ((sample4 + last_sample4) >> 1);
13027 dst[19] = (Sint32) ((sample3 + last_sample3) >> 1);
13028 dst[18] = (Sint32) ((sample2 + last_sample2) >> 1);
13029 dst[17] = (Sint32) ((sample1 + last_sample1) >> 1);
13030 dst[16] = (Sint32) ((sample0 + last_sample0) >> 1);
13031 dst[15] = (Sint32) (((3 * sample7) + last_sample7) >> 2);
13032 dst[14] = (Sint32) (((3 * sample6) + last_sample6) >> 2);
13033 dst[13] = (Sint32) (((3 * sample5) + last_sample5) >> 2);
13034 dst[12] = (Sint32) (((3 * sample4) + last_sample4) >> 2);
13035 dst[11] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
13036 dst[10] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
13037 dst[9] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
13038 dst[8] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
13039 dst[7] = (Sint32) sample7;
13040 dst[6] = (Sint32) sample6;
13041 dst[5] = (Sint32) sample5;
13042 dst[4] = (Sint32) sample4;
13043 dst[3] = (Sint32) sample3;
13044 dst[2] = (Sint32) sample2;
13045 dst[1] = (Sint32) sample1;
13046 dst[0] = (Sint32) sample0;
13047 last_sample7 = sample7;
13048 last_sample6 = sample6;
13049 last_sample5 = sample5;
13050 last_sample4 = sample4;
13051 last_sample3 = sample3;
13052 last_sample2 = sample2;
13053 last_sample1 = sample1;
13054 last_sample0 = sample0;
13055 dst -= 32;
13056 }
13057
13058 cvt->len_cvt = dstsize;
13059 if (cvt->filters[++cvt->filter_index]) {
13060 cvt->filters[cvt->filter_index] (cvt, format);
13061 }
13062 }
13063
13064 static void SDLCALL
13065 SDL_Downsample_S32LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13066 {
13067 #if DEBUG_CONVERT
13068 fprintf(stderr, "Downsample (x4) AUDIO_S32LSB, 8 channels.\n");
13069 #endif
13070
13071 const int dstsize = cvt->len_cvt / 4;
13072 Sint32 *dst = (Sint32 *) cvt->buf;
13073 const Sint32 *src = (Sint32 *) cvt->buf;
13074 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
13075 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
13076 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
13077 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
13078 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
13079 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
13080 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
13081 Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
13082 Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
13083 while (dst < target) {
13084 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
13085 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
13086 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
13087 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
13088 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
13089 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
13090 const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
13091 const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
13092 src += 32;
13093 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
13094 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
13095 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
13096 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
13097 dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
13098 dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
13099 dst[6] = (Sint32) ((sample6 + last_sample6) >> 1);
13100 dst[7] = (Sint32) ((sample7 + last_sample7) >> 1);
13101 last_sample0 = sample0;
13102 last_sample1 = sample1;
13103 last_sample2 = sample2;
13104 last_sample3 = sample3;
13105 last_sample4 = sample4;
13106 last_sample5 = sample5;
13107 last_sample6 = sample6;
13108 last_sample7 = sample7;
13109 dst += 8;
13110 }
13111
13112 cvt->len_cvt = dstsize;
13113 if (cvt->filters[++cvt->filter_index]) {
13114 cvt->filters[cvt->filter_index] (cvt, format);
13115 }
13116 }
13117
13118 static void SDLCALL
13119 SDL_Upsample_S32MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13120 {
13121 #if DEBUG_CONVERT
13122 fprintf(stderr, "Upsample (x2) AUDIO_S32MSB, 1 channels.\n");
13123 #endif
13124
13125 const int dstsize = cvt->len_cvt * 2;
13126 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1 * 2;
13127 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
13128 const Sint32 *target = ((const Sint32 *) cvt->buf);
13129 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13130 while (dst >= target) {
13131 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13132 src--;
13133 dst[1] = (Sint32) ((sample0 + last_sample0) >> 1);
13134 dst[0] = (Sint32) sample0;
13135 last_sample0 = sample0;
13136 dst -= 2;
13137 }
13138
13139 cvt->len_cvt = dstsize;
13140 if (cvt->filters[++cvt->filter_index]) {
13141 cvt->filters[cvt->filter_index] (cvt, format);
13142 }
13143 }
13144
13145 static void SDLCALL
13146 SDL_Downsample_S32MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13147 {
13148 #if DEBUG_CONVERT
13149 fprintf(stderr, "Downsample (x2) AUDIO_S32MSB, 1 channels.\n");
13150 #endif
13151
13152 const int dstsize = cvt->len_cvt / 2;
13153 Sint32 *dst = (Sint32 *) cvt->buf;
13154 const Sint32 *src = (Sint32 *) cvt->buf;
13155 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
13156 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13157 while (dst < target) {
13158 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13159 src += 2;
13160 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
13161 last_sample0 = sample0;
13162 dst++;
13163 }
13164
13165 cvt->len_cvt = dstsize;
13166 if (cvt->filters[++cvt->filter_index]) {
13167 cvt->filters[cvt->filter_index] (cvt, format);
13168 }
13169 }
13170
13171 static void SDLCALL
13172 SDL_Upsample_S32MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13173 {
13174 #if DEBUG_CONVERT
13175 fprintf(stderr, "Upsample (x4) AUDIO_S32MSB, 1 channels.\n");
13176 #endif
13177
13178 const int dstsize = cvt->len_cvt * 4;
13179 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1 * 4;
13180 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
13181 const Sint32 *target = ((const Sint32 *) cvt->buf);
13182 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13183 while (dst >= target) {
13184 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13185 src--;
13186 dst[3] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
13187 dst[2] = (Sint32) ((sample0 + last_sample0) >> 1);
13188 dst[1] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
13189 dst[0] = (Sint32) sample0;
13190 last_sample0 = sample0;
13191 dst -= 4;
13192 }
13193
13194 cvt->len_cvt = dstsize;
13195 if (cvt->filters[++cvt->filter_index]) {
13196 cvt->filters[cvt->filter_index] (cvt, format);
13197 }
13198 }
13199
13200 static void SDLCALL
13201 SDL_Downsample_S32MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13202 {
13203 #if DEBUG_CONVERT
13204 fprintf(stderr, "Downsample (x4) AUDIO_S32MSB, 1 channels.\n");
13205 #endif
13206
13207 const int dstsize = cvt->len_cvt / 4;
13208 Sint32 *dst = (Sint32 *) cvt->buf;
13209 const Sint32 *src = (Sint32 *) cvt->buf;
13210 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
13211 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13212 while (dst < target) {
13213 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13214 src += 4;
13215 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
13216 last_sample0 = sample0;
13217 dst++;
13218 }
13219
13220 cvt->len_cvt = dstsize;
13221 if (cvt->filters[++cvt->filter_index]) {
13222 cvt->filters[cvt->filter_index] (cvt, format);
13223 }
13224 }
13225
13226 static void SDLCALL
13227 SDL_Upsample_S32MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13228 {
13229 #if DEBUG_CONVERT
13230 fprintf(stderr, "Upsample (x2) AUDIO_S32MSB, 2 channels.\n");
13231 #endif
13232
13233 const int dstsize = cvt->len_cvt * 2;
13234 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2 * 2;
13235 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
13236 const Sint32 *target = ((const Sint32 *) cvt->buf);
13237 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13238 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13239 while (dst >= target) {
13240 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13241 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13242 src -= 2;
13243 dst[3] = (Sint32) ((sample1 + last_sample1) >> 1);
13244 dst[2] = (Sint32) ((sample0 + last_sample0) >> 1);
13245 dst[1] = (Sint32) sample1;
13246 dst[0] = (Sint32) sample0;
13247 last_sample1 = sample1;
13248 last_sample0 = sample0;
13249 dst -= 4;
13250 }
13251
13252 cvt->len_cvt = dstsize;
13253 if (cvt->filters[++cvt->filter_index]) {
13254 cvt->filters[cvt->filter_index] (cvt, format);
13255 }
13256 }
13257
13258 static void SDLCALL
13259 SDL_Downsample_S32MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13260 {
13261 #if DEBUG_CONVERT
13262 fprintf(stderr, "Downsample (x2) AUDIO_S32MSB, 2 channels.\n");
13263 #endif
13264
13265 const int dstsize = cvt->len_cvt / 2;
13266 Sint32 *dst = (Sint32 *) cvt->buf;
13267 const Sint32 *src = (Sint32 *) cvt->buf;
13268 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
13269 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13270 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13271 while (dst < target) {
13272 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13273 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13274 src += 4;
13275 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
13276 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
13277 last_sample0 = sample0;
13278 last_sample1 = sample1;
13279 dst += 2;
13280 }
13281
13282 cvt->len_cvt = dstsize;
13283 if (cvt->filters[++cvt->filter_index]) {
13284 cvt->filters[cvt->filter_index] (cvt, format);
13285 }
13286 }
13287
13288 static void SDLCALL
13289 SDL_Upsample_S32MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13290 {
13291 #if DEBUG_CONVERT
13292 fprintf(stderr, "Upsample (x4) AUDIO_S32MSB, 2 channels.\n");
13293 #endif
13294
13295 const int dstsize = cvt->len_cvt * 4;
13296 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2 * 4;
13297 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
13298 const Sint32 *target = ((const Sint32 *) cvt->buf);
13299 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13300 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13301 while (dst >= target) {
13302 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13303 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13304 src -= 2;
13305 dst[7] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
13306 dst[6] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
13307 dst[5] = (Sint32) ((sample1 + last_sample1) >> 1);
13308 dst[4] = (Sint32) ((sample0 + last_sample0) >> 1);
13309 dst[3] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
13310 dst[2] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
13311 dst[1] = (Sint32) sample1;
13312 dst[0] = (Sint32) sample0;
13313 last_sample1 = sample1;
13314 last_sample0 = sample0;
13315 dst -= 8;
13316 }
13317
13318 cvt->len_cvt = dstsize;
13319 if (cvt->filters[++cvt->filter_index]) {
13320 cvt->filters[cvt->filter_index] (cvt, format);
13321 }
13322 }
13323
13324 static void SDLCALL
13325 SDL_Downsample_S32MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13326 {
13327 #if DEBUG_CONVERT
13328 fprintf(stderr, "Downsample (x4) AUDIO_S32MSB, 2 channels.\n");
13329 #endif
13330
13331 const int dstsize = cvt->len_cvt / 4;
13332 Sint32 *dst = (Sint32 *) cvt->buf;
13333 const Sint32 *src = (Sint32 *) cvt->buf;
13334 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
13335 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13336 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13337 while (dst < target) {
13338 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13339 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13340 src += 8;
13341 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
13342 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
13343 last_sample0 = sample0;
13344 last_sample1 = sample1;
13345 dst += 2;
13346 }
13347
13348 cvt->len_cvt = dstsize;
13349 if (cvt->filters[++cvt->filter_index]) {
13350 cvt->filters[cvt->filter_index] (cvt, format);
13351 }
13352 }
13353
13354 static void SDLCALL
13355 SDL_Upsample_S32MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13356 {
13357 #if DEBUG_CONVERT
13358 fprintf(stderr, "Upsample (x2) AUDIO_S32MSB, 4 channels.\n");
13359 #endif
13360
13361 const int dstsize = cvt->len_cvt * 2;
13362 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4 * 2;
13363 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
13364 const Sint32 *target = ((const Sint32 *) cvt->buf);
13365 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13366 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13367 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13368 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13369 while (dst >= target) {
13370 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13371 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13372 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13373 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13374 src -= 4;
13375 dst[7] = (Sint32) ((sample3 + last_sample3) >> 1);
13376 dst[6] = (Sint32) ((sample2 + last_sample2) >> 1);
13377 dst[5] = (Sint32) ((sample1 + last_sample1) >> 1);
13378 dst[4] = (Sint32) ((sample0 + last_sample0) >> 1);
13379 dst[3] = (Sint32) sample3;
13380 dst[2] = (Sint32) sample2;
13381 dst[1] = (Sint32) sample1;
13382 dst[0] = (Sint32) sample0;
13383 last_sample3 = sample3;
13384 last_sample2 = sample2;
13385 last_sample1 = sample1;
13386 last_sample0 = sample0;
13387 dst -= 8;
13388 }
13389
13390 cvt->len_cvt = dstsize;
13391 if (cvt->filters[++cvt->filter_index]) {
13392 cvt->filters[cvt->filter_index] (cvt, format);
13393 }
13394 }
13395
13396 static void SDLCALL
13397 SDL_Downsample_S32MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13398 {
13399 #if DEBUG_CONVERT
13400 fprintf(stderr, "Downsample (x2) AUDIO_S32MSB, 4 channels.\n");
13401 #endif
13402
13403 const int dstsize = cvt->len_cvt / 2;
13404 Sint32 *dst = (Sint32 *) cvt->buf;
13405 const Sint32 *src = (Sint32 *) cvt->buf;
13406 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
13407 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13408 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13409 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13410 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13411 while (dst < target) {
13412 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13413 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13414 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13415 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13416 src += 8;
13417 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
13418 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
13419 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
13420 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
13421 last_sample0 = sample0;
13422 last_sample1 = sample1;
13423 last_sample2 = sample2;
13424 last_sample3 = sample3;
13425 dst += 4;
13426 }
13427
13428 cvt->len_cvt = dstsize;
13429 if (cvt->filters[++cvt->filter_index]) {
13430 cvt->filters[cvt->filter_index] (cvt, format);
13431 }
13432 }
13433
13434 static void SDLCALL
13435 SDL_Upsample_S32MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13436 {
13437 #if DEBUG_CONVERT
13438 fprintf(stderr, "Upsample (x4) AUDIO_S32MSB, 4 channels.\n");
13439 #endif
13440
13441 const int dstsize = cvt->len_cvt * 4;
13442 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4 * 4;
13443 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
13444 const Sint32 *target = ((const Sint32 *) cvt->buf);
13445 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13446 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13447 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13448 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13449 while (dst >= target) {
13450 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13451 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13452 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13453 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13454 src -= 4;
13455 dst[15] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
13456 dst[14] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
13457 dst[13] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
13458 dst[12] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
13459 dst[11] = (Sint32) ((sample3 + last_sample3) >> 1);
13460 dst[10] = (Sint32) ((sample2 + last_sample2) >> 1);
13461 dst[9] = (Sint32) ((sample1 + last_sample1) >> 1);
13462 dst[8] = (Sint32) ((sample0 + last_sample0) >> 1);
13463 dst[7] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
13464 dst[6] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
13465 dst[5] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
13466 dst[4] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
13467 dst[3] = (Sint32) sample3;
13468 dst[2] = (Sint32) sample2;
13469 dst[1] = (Sint32) sample1;
13470 dst[0] = (Sint32) sample0;
13471 last_sample3 = sample3;
13472 last_sample2 = sample2;
13473 last_sample1 = sample1;
13474 last_sample0 = sample0;
13475 dst -= 16;
13476 }
13477
13478 cvt->len_cvt = dstsize;
13479 if (cvt->filters[++cvt->filter_index]) {
13480 cvt->filters[cvt->filter_index] (cvt, format);
13481 }
13482 }
13483
13484 static void SDLCALL
13485 SDL_Downsample_S32MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13486 {
13487 #if DEBUG_CONVERT
13488 fprintf(stderr, "Downsample (x4) AUDIO_S32MSB, 4 channels.\n");
13489 #endif
13490
13491 const int dstsize = cvt->len_cvt / 4;
13492 Sint32 *dst = (Sint32 *) cvt->buf;
13493 const Sint32 *src = (Sint32 *) cvt->buf;
13494 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
13495 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13496 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13497 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13498 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13499 while (dst < target) {
13500 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13501 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13502 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13503 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13504 src += 16;
13505 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
13506 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
13507 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
13508 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
13509 last_sample0 = sample0;
13510 last_sample1 = sample1;
13511 last_sample2 = sample2;
13512 last_sample3 = sample3;
13513 dst += 4;
13514 }
13515
13516 cvt->len_cvt = dstsize;
13517 if (cvt->filters[++cvt->filter_index]) {
13518 cvt->filters[cvt->filter_index] (cvt, format);
13519 }
13520 }
13521
13522 static void SDLCALL
13523 SDL_Upsample_S32MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13524 {
13525 #if DEBUG_CONVERT
13526 fprintf(stderr, "Upsample (x2) AUDIO_S32MSB, 6 channels.\n");
13527 #endif
13528
13529 const int dstsize = cvt->len_cvt * 2;
13530 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6 * 2;
13531 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
13532 const Sint32 *target = ((const Sint32 *) cvt->buf);
13533 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13534 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13535 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13536 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13537 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13538 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13539 while (dst >= target) {
13540 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13541 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13542 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13543 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13544 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13545 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13546 src -= 6;
13547 dst[11] = (Sint32) ((sample5 + last_sample5) >> 1);
13548 dst[10] = (Sint32) ((sample4 + last_sample4) >> 1);
13549 dst[9] = (Sint32) ((sample3 + last_sample3) >> 1);
13550 dst[8] = (Sint32) ((sample2 + last_sample2) >> 1);
13551 dst[7] = (Sint32) ((sample1 + last_sample1) >> 1);
13552 dst[6] = (Sint32) ((sample0 + last_sample0) >> 1);
13553 dst[5] = (Sint32) sample5;
13554 dst[4] = (Sint32) sample4;
13555 dst[3] = (Sint32) sample3;
13556 dst[2] = (Sint32) sample2;
13557 dst[1] = (Sint32) sample1;
13558 dst[0] = (Sint32) sample0;
13559 last_sample5 = sample5;
13560 last_sample4 = sample4;
13561 last_sample3 = sample3;
13562 last_sample2 = sample2;
13563 last_sample1 = sample1;
13564 last_sample0 = sample0;
13565 dst -= 12;
13566 }
13567
13568 cvt->len_cvt = dstsize;
13569 if (cvt->filters[++cvt->filter_index]) {
13570 cvt->filters[cvt->filter_index] (cvt, format);
13571 }
13572 }
13573
13574 static void SDLCALL
13575 SDL_Downsample_S32MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13576 {
13577 #if DEBUG_CONVERT
13578 fprintf(stderr, "Downsample (x2) AUDIO_S32MSB, 6 channels.\n");
13579 #endif
13580
13581 const int dstsize = cvt->len_cvt / 2;
13582 Sint32 *dst = (Sint32 *) cvt->buf;
13583 const Sint32 *src = (Sint32 *) cvt->buf;
13584 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
13585 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13586 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13587 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13588 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13589 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13590 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13591 while (dst < target) {
13592 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13593 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13594 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13595 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13596 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13597 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13598 src += 12;
13599 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
13600 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
13601 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
13602 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
13603 dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
13604 dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
13605 last_sample0 = sample0;
13606 last_sample1 = sample1;
13607 last_sample2 = sample2;
13608 last_sample3 = sample3;
13609 last_sample4 = sample4;
13610 last_sample5 = sample5;
13611 dst += 6;
13612 }
13613
13614 cvt->len_cvt = dstsize;
13615 if (cvt->filters[++cvt->filter_index]) {
13616 cvt->filters[cvt->filter_index] (cvt, format);
13617 }
13618 }
13619
13620 static void SDLCALL
13621 SDL_Upsample_S32MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13622 {
13623 #if DEBUG_CONVERT
13624 fprintf(stderr, "Upsample (x4) AUDIO_S32MSB, 6 channels.\n");
13625 #endif
13626
13627 const int dstsize = cvt->len_cvt * 4;
13628 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6 * 4;
13629 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
13630 const Sint32 *target = ((const Sint32 *) cvt->buf);
13631 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13632 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13633 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13634 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13635 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13636 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13637 while (dst >= target) {
13638 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13639 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13640 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13641 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13642 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13643 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13644 src -= 6;
13645 dst[23] = (Sint32) ((sample5 + (3 * last_sample5)) >> 2);
13646 dst[22] = (Sint32) ((sample4 + (3 * last_sample4)) >> 2);
13647 dst[21] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
13648 dst[20] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
13649 dst[19] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
13650 dst[18] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
13651 dst[17] = (Sint32) ((sample5 + last_sample5) >> 1);
13652 dst[16] = (Sint32) ((sample4 + last_sample4) >> 1);
13653 dst[15] = (Sint32) ((sample3 + last_sample3) >> 1);
13654 dst[14] = (Sint32) ((sample2 + last_sample2) >> 1);
13655 dst[13] = (Sint32) ((sample1 + last_sample1) >> 1);
13656 dst[12] = (Sint32) ((sample0 + last_sample0) >> 1);
13657 dst[11] = (Sint32) (((3 * sample5) + last_sample5) >> 2);
13658 dst[10] = (Sint32) (((3 * sample4) + last_sample4) >> 2);
13659 dst[9] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
13660 dst[8] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
13661 dst[7] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
13662 dst[6] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
13663 dst[5] = (Sint32) sample5;
13664 dst[4] = (Sint32) sample4;
13665 dst[3] = (Sint32) sample3;
13666 dst[2] = (Sint32) sample2;
13667 dst[1] = (Sint32) sample1;
13668 dst[0] = (Sint32) sample0;
13669 last_sample5 = sample5;
13670 last_sample4 = sample4;
13671 last_sample3 = sample3;
13672 last_sample2 = sample2;
13673 last_sample1 = sample1;
13674 last_sample0 = sample0;
13675 dst -= 24;
13676 }
13677
13678 cvt->len_cvt = dstsize;
13679 if (cvt->filters[++cvt->filter_index]) {
13680 cvt->filters[cvt->filter_index] (cvt, format);
13681 }
13682 }
13683
13684 static void SDLCALL
13685 SDL_Downsample_S32MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13686 {
13687 #if DEBUG_CONVERT
13688 fprintf(stderr, "Downsample (x4) AUDIO_S32MSB, 6 channels.\n");
13689 #endif
13690
13691 const int dstsize = cvt->len_cvt / 4;
13692 Sint32 *dst = (Sint32 *) cvt->buf;
13693 const Sint32 *src = (Sint32 *) cvt->buf;
13694 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
13695 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13696 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13697 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13698 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13699 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13700 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13701 while (dst < target) {
13702 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13703 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13704 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13705 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13706 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13707 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13708 src += 24;
13709 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
13710 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
13711 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
13712 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
13713 dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
13714 dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
13715 last_sample0 = sample0;
13716 last_sample1 = sample1;
13717 last_sample2 = sample2;
13718 last_sample3 = sample3;
13719 last_sample4 = sample4;
13720 last_sample5 = sample5;
13721 dst += 6;
13722 }
13723
13724 cvt->len_cvt = dstsize;
13725 if (cvt->filters[++cvt->filter_index]) {
13726 cvt->filters[cvt->filter_index] (cvt, format);
13727 }
13728 }
13729
13730 static void SDLCALL
13731 SDL_Upsample_S32MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13732 {
13733 #if DEBUG_CONVERT
13734 fprintf(stderr, "Upsample (x2) AUDIO_S32MSB, 8 channels.\n");
13735 #endif
13736
13737 const int dstsize = cvt->len_cvt * 2;
13738 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8 * 2;
13739 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
13740 const Sint32 *target = ((const Sint32 *) cvt->buf);
13741 Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
13742 Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
13743 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13744 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13745 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13746 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13747 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13748 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13749 while (dst >= target) {
13750 const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
13751 const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
13752 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13753 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13754 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13755 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13756 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13757 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13758 src -= 8;
13759 dst[15] = (Sint32) ((sample7 + last_sample7) >> 1);
13760 dst[14] = (Sint32) ((sample6 + last_sample6) >> 1);
13761 dst[13] = (Sint32) ((sample5 + last_sample5) >> 1);
13762 dst[12] = (Sint32) ((sample4 + last_sample4) >> 1);
13763 dst[11] = (Sint32) ((sample3 + last_sample3) >> 1);
13764 dst[10] = (Sint32) ((sample2 + last_sample2) >> 1);
13765 dst[9] = (Sint32) ((sample1 + last_sample1) >> 1);
13766 dst[8] = (Sint32) ((sample0 + last_sample0) >> 1);
13767 dst[7] = (Sint32) sample7;
13768 dst[6] = (Sint32) sample6;
13769 dst[5] = (Sint32) sample5;
13770 dst[4] = (Sint32) sample4;
13771 dst[3] = (Sint32) sample3;
13772 dst[2] = (Sint32) sample2;
13773 dst[1] = (Sint32) sample1;
13774 dst[0] = (Sint32) sample0;
13775 last_sample7 = sample7;
13776 last_sample6 = sample6;
13777 last_sample5 = sample5;
13778 last_sample4 = sample4;
13779 last_sample3 = sample3;
13780 last_sample2 = sample2;
13781 last_sample1 = sample1;
13782 last_sample0 = sample0;
13783 dst -= 16;
13784 }
13785
13786 cvt->len_cvt = dstsize;
13787 if (cvt->filters[++cvt->filter_index]) {
13788 cvt->filters[cvt->filter_index] (cvt, format);
13789 }
13790 }
13791
13792 static void SDLCALL
13793 SDL_Downsample_S32MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13794 {
13795 #if DEBUG_CONVERT
13796 fprintf(stderr, "Downsample (x2) AUDIO_S32MSB, 8 channels.\n");
13797 #endif
13798
13799 const int dstsize = cvt->len_cvt / 2;
13800 Sint32 *dst = (Sint32 *) cvt->buf;
13801 const Sint32 *src = (Sint32 *) cvt->buf;
13802 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
13803 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13804 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13805 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13806 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13807 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13808 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13809 Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
13810 Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
13811 while (dst < target) {
13812 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13813 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13814 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13815 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13816 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13817 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13818 const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
13819 const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
13820 src += 16;
13821 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
13822 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
13823 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
13824 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
13825 dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
13826 dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
13827 dst[6] = (Sint32) ((sample6 + last_sample6) >> 1);
13828 dst[7] = (Sint32) ((sample7 + last_sample7) >> 1);
13829 last_sample0 = sample0;
13830 last_sample1 = sample1;
13831 last_sample2 = sample2;
13832 last_sample3 = sample3;
13833 last_sample4 = sample4;
13834 last_sample5 = sample5;
13835 last_sample6 = sample6;
13836 last_sample7 = sample7;
13837 dst += 8;
13838 }
13839
13840 cvt->len_cvt = dstsize;
13841 if (cvt->filters[++cvt->filter_index]) {
13842 cvt->filters[cvt->filter_index] (cvt, format);
13843 }
13844 }
13845
13846 static void SDLCALL
13847 SDL_Upsample_S32MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13848 {
13849 #if DEBUG_CONVERT
13850 fprintf(stderr, "Upsample (x4) AUDIO_S32MSB, 8 channels.\n");
13851 #endif
13852
13853 const int dstsize = cvt->len_cvt * 4;
13854 Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8 * 4;
13855 const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
13856 const Sint32 *target = ((const Sint32 *) cvt->buf);
13857 Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
13858 Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
13859 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13860 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13861 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13862 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13863 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13864 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13865 while (dst >= target) {
13866 const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
13867 const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
13868 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13869 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13870 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13871 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13872 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13873 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13874 src -= 8;
13875 dst[31] = (Sint32) ((sample7 + (3 * last_sample7)) >> 2);
13876 dst[30] = (Sint32) ((sample6 + (3 * last_sample6)) >> 2);
13877 dst[29] = (Sint32) ((sample5 + (3 * last_sample5)) >> 2);
13878 dst[28] = (Sint32) ((sample4 + (3 * last_sample4)) >> 2);
13879 dst[27] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
13880 dst[26] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
13881 dst[25] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
13882 dst[24] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
13883 dst[23] = (Sint32) ((sample7 + last_sample7) >> 1);
13884 dst[22] = (Sint32) ((sample6 + last_sample6) >> 1);
13885 dst[21] = (Sint32) ((sample5 + last_sample5) >> 1);
13886 dst[20] = (Sint32) ((sample4 + last_sample4) >> 1);
13887 dst[19] = (Sint32) ((sample3 + last_sample3) >> 1);
13888 dst[18] = (Sint32) ((sample2 + last_sample2) >> 1);
13889 dst[17] = (Sint32) ((sample1 + last_sample1) >> 1);
13890 dst[16] = (Sint32) ((sample0 + last_sample0) >> 1);
13891 dst[15] = (Sint32) (((3 * sample7) + last_sample7) >> 2);
13892 dst[14] = (Sint32) (((3 * sample6) + last_sample6) >> 2);
13893 dst[13] = (Sint32) (((3 * sample5) + last_sample5) >> 2);
13894 dst[12] = (Sint32) (((3 * sample4) + last_sample4) >> 2);
13895 dst[11] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
13896 dst[10] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
13897 dst[9] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
13898 dst[8] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
13899 dst[7] = (Sint32) sample7;
13900 dst[6] = (Sint32) sample6;
13901 dst[5] = (Sint32) sample5;
13902 dst[4] = (Sint32) sample4;
13903 dst[3] = (Sint32) sample3;
13904 dst[2] = (Sint32) sample2;
13905 dst[1] = (Sint32) sample1;
13906 dst[0] = (Sint32) sample0;
13907 last_sample7 = sample7;
13908 last_sample6 = sample6;
13909 last_sample5 = sample5;
13910 last_sample4 = sample4;
13911 last_sample3 = sample3;
13912 last_sample2 = sample2;
13913 last_sample1 = sample1;
13914 last_sample0 = sample0;
13915 dst -= 32;
13916 }
13917
13918 cvt->len_cvt = dstsize;
13919 if (cvt->filters[++cvt->filter_index]) {
13920 cvt->filters[cvt->filter_index] (cvt, format);
13921 }
13922 }
13923
13924 static void SDLCALL
13925 SDL_Downsample_S32MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13926 {
13927 #if DEBUG_CONVERT
13928 fprintf(stderr, "Downsample (x4) AUDIO_S32MSB, 8 channels.\n");
13929 #endif
13930
13931 const int dstsize = cvt->len_cvt / 4;
13932 Sint32 *dst = (Sint32 *) cvt->buf;
13933 const Sint32 *src = (Sint32 *) cvt->buf;
13934 const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
13935 Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13936 Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13937 Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13938 Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13939 Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13940 Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13941 Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
13942 Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
13943 while (dst < target) {
13944 const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
13945 const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
13946 const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
13947 const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
13948 const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
13949 const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
13950 const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
13951 const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
13952 src += 32;
13953 dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
13954 dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
13955 dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
13956 dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
13957 dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
13958 dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
13959 dst[6] = (Sint32) ((sample6 + last_sample6) >> 1);
13960 dst[7] = (Sint32) ((sample7 + last_sample7) >> 1);
13961 last_sample0 = sample0;
13962 last_sample1 = sample1;
13963 last_sample2 = sample2;
13964 last_sample3 = sample3;
13965 last_sample4 = sample4;
13966 last_sample5 = sample5;
13967 last_sample6 = sample6;
13968 last_sample7 = sample7;
13969 dst += 8;
13970 }
13971
13972 cvt->len_cvt = dstsize;
13973 if (cvt->filters[++cvt->filter_index]) {
13974 cvt->filters[cvt->filter_index] (cvt, format);
13975 }
13976 }
13977
13978 static void SDLCALL
13979 SDL_Upsample_F32LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
13980 {
13981 #if DEBUG_CONVERT
13982 fprintf(stderr, "Upsample (x2) AUDIO_F32LSB, 1 channels.\n");
13983 #endif
13984
13985 const int dstsize = cvt->len_cvt * 2;
13986 float *dst = ((float *) (cvt->buf + dstsize)) - 1 * 2;
13987 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
13988 const float *target = ((const float *) cvt->buf);
13989 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
13990 while (dst >= target) {
13991 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
13992 src--;
13993 dst[1] = (float) ((sample0 + last_sample0) * 0.5);
13994 dst[0] = (float) sample0;
13995 last_sample0 = sample0;
13996 dst -= 2;
13997 }
13998
13999 cvt->len_cvt = dstsize;
14000 if (cvt->filters[++cvt->filter_index]) {
14001 cvt->filters[cvt->filter_index] (cvt, format);
14002 }
14003 }
14004
14005 static void SDLCALL
14006 SDL_Downsample_F32LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14007 {
14008 #if DEBUG_CONVERT
14009 fprintf(stderr, "Downsample (x2) AUDIO_F32LSB, 1 channels.\n");
14010 #endif
14011
14012 const int dstsize = cvt->len_cvt / 2;
14013 float *dst = (float *) cvt->buf;
14014 const float *src = (float *) cvt->buf;
14015 const float *target = (const float *) (cvt->buf + dstsize);
14016 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14017 while (dst < target) {
14018 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14019 src += 2;
14020 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14021 last_sample0 = sample0;
14022 dst++;
14023 }
14024
14025 cvt->len_cvt = dstsize;
14026 if (cvt->filters[++cvt->filter_index]) {
14027 cvt->filters[cvt->filter_index] (cvt, format);
14028 }
14029 }
14030
14031 static void SDLCALL
14032 SDL_Upsample_F32LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14033 {
14034 #if DEBUG_CONVERT
14035 fprintf(stderr, "Upsample (x4) AUDIO_F32LSB, 1 channels.\n");
14036 #endif
14037
14038 const int dstsize = cvt->len_cvt * 4;
14039 float *dst = ((float *) (cvt->buf + dstsize)) - 1 * 4;
14040 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
14041 const float *target = ((const float *) cvt->buf);
14042 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14043 while (dst >= target) {
14044 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14045 src--;
14046 dst[3] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
14047 dst[2] = (float) ((sample0 + last_sample0) * 0.5);
14048 dst[1] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
14049 dst[0] = (float) sample0;
14050 last_sample0 = sample0;
14051 dst -= 4;
14052 }
14053
14054 cvt->len_cvt = dstsize;
14055 if (cvt->filters[++cvt->filter_index]) {
14056 cvt->filters[cvt->filter_index] (cvt, format);
14057 }
14058 }
14059
14060 static void SDLCALL
14061 SDL_Downsample_F32LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14062 {
14063 #if DEBUG_CONVERT
14064 fprintf(stderr, "Downsample (x4) AUDIO_F32LSB, 1 channels.\n");
14065 #endif
14066
14067 const int dstsize = cvt->len_cvt / 4;
14068 float *dst = (float *) cvt->buf;
14069 const float *src = (float *) cvt->buf;
14070 const float *target = (const float *) (cvt->buf + dstsize);
14071 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14072 while (dst < target) {
14073 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14074 src += 4;
14075 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14076 last_sample0 = sample0;
14077 dst++;
14078 }
14079
14080 cvt->len_cvt = dstsize;
14081 if (cvt->filters[++cvt->filter_index]) {
14082 cvt->filters[cvt->filter_index] (cvt, format);
14083 }
14084 }
14085
14086 static void SDLCALL
14087 SDL_Upsample_F32LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14088 {
14089 #if DEBUG_CONVERT
14090 fprintf(stderr, "Upsample (x2) AUDIO_F32LSB, 2 channels.\n");
14091 #endif
14092
14093 const int dstsize = cvt->len_cvt * 2;
14094 float *dst = ((float *) (cvt->buf + dstsize)) - 2 * 2;
14095 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
14096 const float *target = ((const float *) cvt->buf);
14097 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14098 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14099 while (dst >= target) {
14100 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14101 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14102 src -= 2;
14103 dst[3] = (float) ((sample1 + last_sample1) * 0.5);
14104 dst[2] = (float) ((sample0 + last_sample0) * 0.5);
14105 dst[1] = (float) sample1;
14106 dst[0] = (float) sample0;
14107 last_sample1 = sample1;
14108 last_sample0 = sample0;
14109 dst -= 4;
14110 }
14111
14112 cvt->len_cvt = dstsize;
14113 if (cvt->filters[++cvt->filter_index]) {
14114 cvt->filters[cvt->filter_index] (cvt, format);
14115 }
14116 }
14117
14118 static void SDLCALL
14119 SDL_Downsample_F32LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14120 {
14121 #if DEBUG_CONVERT
14122 fprintf(stderr, "Downsample (x2) AUDIO_F32LSB, 2 channels.\n");
14123 #endif
14124
14125 const int dstsize = cvt->len_cvt / 2;
14126 float *dst = (float *) cvt->buf;
14127 const float *src = (float *) cvt->buf;
14128 const float *target = (const float *) (cvt->buf + dstsize);
14129 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14130 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14131 while (dst < target) {
14132 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14133 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14134 src += 4;
14135 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14136 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
14137 last_sample0 = sample0;
14138 last_sample1 = sample1;
14139 dst += 2;
14140 }
14141
14142 cvt->len_cvt = dstsize;
14143 if (cvt->filters[++cvt->filter_index]) {
14144 cvt->filters[cvt->filter_index] (cvt, format);
14145 }
14146 }
14147
14148 static void SDLCALL
14149 SDL_Upsample_F32LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14150 {
14151 #if DEBUG_CONVERT
14152 fprintf(stderr, "Upsample (x4) AUDIO_F32LSB, 2 channels.\n");
14153 #endif
14154
14155 const int dstsize = cvt->len_cvt * 4;
14156 float *dst = ((float *) (cvt->buf + dstsize)) - 2 * 4;
14157 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
14158 const float *target = ((const float *) cvt->buf);
14159 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14160 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14161 while (dst >= target) {
14162 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14163 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14164 src -= 2;
14165 dst[7] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
14166 dst[6] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
14167 dst[5] = (float) ((sample1 + last_sample1) * 0.5);
14168 dst[4] = (float) ((sample0 + last_sample0) * 0.5);
14169 dst[3] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
14170 dst[2] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
14171 dst[1] = (float) sample1;
14172 dst[0] = (float) sample0;
14173 last_sample1 = sample1;
14174 last_sample0 = sample0;
14175 dst -= 8;
14176 }
14177
14178 cvt->len_cvt = dstsize;
14179 if (cvt->filters[++cvt->filter_index]) {
14180 cvt->filters[cvt->filter_index] (cvt, format);
14181 }
14182 }
14183
14184 static void SDLCALL
14185 SDL_Downsample_F32LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14186 {
14187 #if DEBUG_CONVERT
14188 fprintf(stderr, "Downsample (x4) AUDIO_F32LSB, 2 channels.\n");
14189 #endif
14190
14191 const int dstsize = cvt->len_cvt / 4;
14192 float *dst = (float *) cvt->buf;
14193 const float *src = (float *) cvt->buf;
14194 const float *target = (const float *) (cvt->buf + dstsize);
14195 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14196 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14197 while (dst < target) {
14198 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14199 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14200 src += 8;
14201 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14202 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
14203 last_sample0 = sample0;
14204 last_sample1 = sample1;
14205 dst += 2;
14206 }
14207
14208 cvt->len_cvt = dstsize;
14209 if (cvt->filters[++cvt->filter_index]) {
14210 cvt->filters[cvt->filter_index] (cvt, format);
14211 }
14212 }
14213
14214 static void SDLCALL
14215 SDL_Upsample_F32LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14216 {
14217 #if DEBUG_CONVERT
14218 fprintf(stderr, "Upsample (x2) AUDIO_F32LSB, 4 channels.\n");
14219 #endif
14220
14221 const int dstsize = cvt->len_cvt * 2;
14222 float *dst = ((float *) (cvt->buf + dstsize)) - 4 * 2;
14223 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
14224 const float *target = ((const float *) cvt->buf);
14225 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14226 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14227 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14228 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14229 while (dst >= target) {
14230 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14231 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14232 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14233 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14234 src -= 4;
14235 dst[7] = (float) ((sample3 + last_sample3) * 0.5);
14236 dst[6] = (float) ((sample2 + last_sample2) * 0.5);
14237 dst[5] = (float) ((sample1 + last_sample1) * 0.5);
14238 dst[4] = (float) ((sample0 + last_sample0) * 0.5);
14239 dst[3] = (float) sample3;
14240 dst[2] = (float) sample2;
14241 dst[1] = (float) sample1;
14242 dst[0] = (float) sample0;
14243 last_sample3 = sample3;
14244 last_sample2 = sample2;
14245 last_sample1 = sample1;
14246 last_sample0 = sample0;
14247 dst -= 8;
14248 }
14249
14250 cvt->len_cvt = dstsize;
14251 if (cvt->filters[++cvt->filter_index]) {
14252 cvt->filters[cvt->filter_index] (cvt, format);
14253 }
14254 }
14255
14256 static void SDLCALL
14257 SDL_Downsample_F32LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14258 {
14259 #if DEBUG_CONVERT
14260 fprintf(stderr, "Downsample (x2) AUDIO_F32LSB, 4 channels.\n");
14261 #endif
14262
14263 const int dstsize = cvt->len_cvt / 2;
14264 float *dst = (float *) cvt->buf;
14265 const float *src = (float *) cvt->buf;
14266 const float *target = (const float *) (cvt->buf + dstsize);
14267 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14268 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14269 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14270 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14271 while (dst < target) {
14272 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14273 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14274 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14275 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14276 src += 8;
14277 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14278 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
14279 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
14280 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
14281 last_sample0 = sample0;
14282 last_sample1 = sample1;
14283 last_sample2 = sample2;
14284 last_sample3 = sample3;
14285 dst += 4;
14286 }
14287
14288 cvt->len_cvt = dstsize;
14289 if (cvt->filters[++cvt->filter_index]) {
14290 cvt->filters[cvt->filter_index] (cvt, format);
14291 }
14292 }
14293
14294 static void SDLCALL
14295 SDL_Upsample_F32LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14296 {
14297 #if DEBUG_CONVERT
14298 fprintf(stderr, "Upsample (x4) AUDIO_F32LSB, 4 channels.\n");
14299 #endif
14300
14301 const int dstsize = cvt->len_cvt * 4;
14302 float *dst = ((float *) (cvt->buf + dstsize)) - 4 * 4;
14303 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
14304 const float *target = ((const float *) cvt->buf);
14305 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14306 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14307 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14308 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14309 while (dst >= target) {
14310 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14311 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14312 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14313 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14314 src -= 4;
14315 dst[15] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
14316 dst[14] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
14317 dst[13] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
14318 dst[12] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
14319 dst[11] = (float) ((sample3 + last_sample3) * 0.5);
14320 dst[10] = (float) ((sample2 + last_sample2) * 0.5);
14321 dst[9] = (float) ((sample1 + last_sample1) * 0.5);
14322 dst[8] = (float) ((sample0 + last_sample0) * 0.5);
14323 dst[7] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
14324 dst[6] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
14325 dst[5] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
14326 dst[4] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
14327 dst[3] = (float) sample3;
14328 dst[2] = (float) sample2;
14329 dst[1] = (float) sample1;
14330 dst[0] = (float) sample0;
14331 last_sample3 = sample3;
14332 last_sample2 = sample2;
14333 last_sample1 = sample1;
14334 last_sample0 = sample0;
14335 dst -= 16;
14336 }
14337
14338 cvt->len_cvt = dstsize;
14339 if (cvt->filters[++cvt->filter_index]) {
14340 cvt->filters[cvt->filter_index] (cvt, format);
14341 }
14342 }
14343
14344 static void SDLCALL
14345 SDL_Downsample_F32LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14346 {
14347 #if DEBUG_CONVERT
14348 fprintf(stderr, "Downsample (x4) AUDIO_F32LSB, 4 channels.\n");
14349 #endif
14350
14351 const int dstsize = cvt->len_cvt / 4;
14352 float *dst = (float *) cvt->buf;
14353 const float *src = (float *) cvt->buf;
14354 const float *target = (const float *) (cvt->buf + dstsize);
14355 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14356 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14357 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14358 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14359 while (dst < target) {
14360 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14361 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14362 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14363 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14364 src += 16;
14365 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14366 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
14367 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
14368 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
14369 last_sample0 = sample0;
14370 last_sample1 = sample1;
14371 last_sample2 = sample2;
14372 last_sample3 = sample3;
14373 dst += 4;
14374 }
14375
14376 cvt->len_cvt = dstsize;
14377 if (cvt->filters[++cvt->filter_index]) {
14378 cvt->filters[cvt->filter_index] (cvt, format);
14379 }
14380 }
14381
14382 static void SDLCALL
14383 SDL_Upsample_F32LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14384 {
14385 #if DEBUG_CONVERT
14386 fprintf(stderr, "Upsample (x2) AUDIO_F32LSB, 6 channels.\n");
14387 #endif
14388
14389 const int dstsize = cvt->len_cvt * 2;
14390 float *dst = ((float *) (cvt->buf + dstsize)) - 6 * 2;
14391 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
14392 const float *target = ((const float *) cvt->buf);
14393 double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
14394 double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
14395 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14396 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14397 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14398 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14399 while (dst >= target) {
14400 const double sample5 = (double) SDL_SwapFloatLE(src[5]);
14401 const double sample4 = (double) SDL_SwapFloatLE(src[4]);
14402 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14403 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14404 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14405 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14406 src -= 6;
14407 dst[11] = (float) ((sample5 + last_sample5) * 0.5);
14408 dst[10] = (float) ((sample4 + last_sample4) * 0.5);
14409 dst[9] = (float) ((sample3 + last_sample3) * 0.5);
14410 dst[8] = (float) ((sample2 + last_sample2) * 0.5);
14411 dst[7] = (float) ((sample1 + last_sample1) * 0.5);
14412 dst[6] = (float) ((sample0 + last_sample0) * 0.5);
14413 dst[5] = (float) sample5;
14414 dst[4] = (float) sample4;
14415 dst[3] = (float) sample3;
14416 dst[2] = (float) sample2;
14417 dst[1] = (float) sample1;
14418 dst[0] = (float) sample0;
14419 last_sample5 = sample5;
14420 last_sample4 = sample4;
14421 last_sample3 = sample3;
14422 last_sample2 = sample2;
14423 last_sample1 = sample1;
14424 last_sample0 = sample0;
14425 dst -= 12;
14426 }
14427
14428 cvt->len_cvt = dstsize;
14429 if (cvt->filters[++cvt->filter_index]) {
14430 cvt->filters[cvt->filter_index] (cvt, format);
14431 }
14432 }
14433
14434 static void SDLCALL
14435 SDL_Downsample_F32LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14436 {
14437 #if DEBUG_CONVERT
14438 fprintf(stderr, "Downsample (x2) AUDIO_F32LSB, 6 channels.\n");
14439 #endif
14440
14441 const int dstsize = cvt->len_cvt / 2;
14442 float *dst = (float *) cvt->buf;
14443 const float *src = (float *) cvt->buf;
14444 const float *target = (const float *) (cvt->buf + dstsize);
14445 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14446 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14447 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14448 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14449 double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
14450 double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
14451 while (dst < target) {
14452 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14453 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14454 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14455 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14456 const double sample4 = (double) SDL_SwapFloatLE(src[4]);
14457 const double sample5 = (double) SDL_SwapFloatLE(src[5]);
14458 src += 12;
14459 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14460 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
14461 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
14462 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
14463 dst[4] = (float) ((sample4 + last_sample4) * 0.5);
14464 dst[5] = (float) ((sample5 + last_sample5) * 0.5);
14465 last_sample0 = sample0;
14466 last_sample1 = sample1;
14467 last_sample2 = sample2;
14468 last_sample3 = sample3;
14469 last_sample4 = sample4;
14470 last_sample5 = sample5;
14471 dst += 6;
14472 }
14473
14474 cvt->len_cvt = dstsize;
14475 if (cvt->filters[++cvt->filter_index]) {
14476 cvt->filters[cvt->filter_index] (cvt, format);
14477 }
14478 }
14479
14480 static void SDLCALL
14481 SDL_Upsample_F32LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14482 {
14483 #if DEBUG_CONVERT
14484 fprintf(stderr, "Upsample (x4) AUDIO_F32LSB, 6 channels.\n");
14485 #endif
14486
14487 const int dstsize = cvt->len_cvt * 4;
14488 float *dst = ((float *) (cvt->buf + dstsize)) - 6 * 4;
14489 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
14490 const float *target = ((const float *) cvt->buf);
14491 double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
14492 double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
14493 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14494 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14495 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14496 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14497 while (dst >= target) {
14498 const double sample5 = (double) SDL_SwapFloatLE(src[5]);
14499 const double sample4 = (double) SDL_SwapFloatLE(src[4]);
14500 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14501 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14502 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14503 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14504 src -= 6;
14505 dst[23] = (float) ((sample5 + (3.0 * last_sample5)) * 0.25);
14506 dst[22] = (float) ((sample4 + (3.0 * last_sample4)) * 0.25);
14507 dst[21] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
14508 dst[20] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
14509 dst[19] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
14510 dst[18] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
14511 dst[17] = (float) ((sample5 + last_sample5) * 0.5);
14512 dst[16] = (float) ((sample4 + last_sample4) * 0.5);
14513 dst[15] = (float) ((sample3 + last_sample3) * 0.5);
14514 dst[14] = (float) ((sample2 + last_sample2) * 0.5);
14515 dst[13] = (float) ((sample1 + last_sample1) * 0.5);
14516 dst[12] = (float) ((sample0 + last_sample0) * 0.5);
14517 dst[11] = (float) (((3.0 * sample5) + last_sample5) * 0.25);
14518 dst[10] = (float) (((3.0 * sample4) + last_sample4) * 0.25);
14519 dst[9] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
14520 dst[8] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
14521 dst[7] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
14522 dst[6] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
14523 dst[5] = (float) sample5;
14524 dst[4] = (float) sample4;
14525 dst[3] = (float) sample3;
14526 dst[2] = (float) sample2;
14527 dst[1] = (float) sample1;
14528 dst[0] = (float) sample0;
14529 last_sample5 = sample5;
14530 last_sample4 = sample4;
14531 last_sample3 = sample3;
14532 last_sample2 = sample2;
14533 last_sample1 = sample1;
14534 last_sample0 = sample0;
14535 dst -= 24;
14536 }
14537
14538 cvt->len_cvt = dstsize;
14539 if (cvt->filters[++cvt->filter_index]) {
14540 cvt->filters[cvt->filter_index] (cvt, format);
14541 }
14542 }
14543
14544 static void SDLCALL
14545 SDL_Downsample_F32LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14546 {
14547 #if DEBUG_CONVERT
14548 fprintf(stderr, "Downsample (x4) AUDIO_F32LSB, 6 channels.\n");
14549 #endif
14550
14551 const int dstsize = cvt->len_cvt / 4;
14552 float *dst = (float *) cvt->buf;
14553 const float *src = (float *) cvt->buf;
14554 const float *target = (const float *) (cvt->buf + dstsize);
14555 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14556 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14557 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14558 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14559 double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
14560 double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
14561 while (dst < target) {
14562 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14563 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14564 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14565 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14566 const double sample4 = (double) SDL_SwapFloatLE(src[4]);
14567 const double sample5 = (double) SDL_SwapFloatLE(src[5]);
14568 src += 24;
14569 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14570 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
14571 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
14572 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
14573 dst[4] = (float) ((sample4 + last_sample4) * 0.5);
14574 dst[5] = (float) ((sample5 + last_sample5) * 0.5);
14575 last_sample0 = sample0;
14576 last_sample1 = sample1;
14577 last_sample2 = sample2;
14578 last_sample3 = sample3;
14579 last_sample4 = sample4;
14580 last_sample5 = sample5;
14581 dst += 6;
14582 }
14583
14584 cvt->len_cvt = dstsize;
14585 if (cvt->filters[++cvt->filter_index]) {
14586 cvt->filters[cvt->filter_index] (cvt, format);
14587 }
14588 }
14589
14590 static void SDLCALL
14591 SDL_Upsample_F32LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14592 {
14593 #if DEBUG_CONVERT
14594 fprintf(stderr, "Upsample (x2) AUDIO_F32LSB, 8 channels.\n");
14595 #endif
14596
14597 const int dstsize = cvt->len_cvt * 2;
14598 float *dst = ((float *) (cvt->buf + dstsize)) - 8 * 2;
14599 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
14600 const float *target = ((const float *) cvt->buf);
14601 double last_sample7 = (double) SDL_SwapFloatLE(src[7]);
14602 double last_sample6 = (double) SDL_SwapFloatLE(src[6]);
14603 double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
14604 double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
14605 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14606 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14607 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14608 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14609 while (dst >= target) {
14610 const double sample7 = (double) SDL_SwapFloatLE(src[7]);
14611 const double sample6 = (double) SDL_SwapFloatLE(src[6]);
14612 const double sample5 = (double) SDL_SwapFloatLE(src[5]);
14613 const double sample4 = (double) SDL_SwapFloatLE(src[4]);
14614 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14615 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14616 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14617 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14618 src -= 8;
14619 dst[15] = (float) ((sample7 + last_sample7) * 0.5);
14620 dst[14] = (float) ((sample6 + last_sample6) * 0.5);
14621 dst[13] = (float) ((sample5 + last_sample5) * 0.5);
14622 dst[12] = (float) ((sample4 + last_sample4) * 0.5);
14623 dst[11] = (float) ((sample3 + last_sample3) * 0.5);
14624 dst[10] = (float) ((sample2 + last_sample2) * 0.5);
14625 dst[9] = (float) ((sample1 + last_sample1) * 0.5);
14626 dst[8] = (float) ((sample0 + last_sample0) * 0.5);
14627 dst[7] = (float) sample7;
14628 dst[6] = (float) sample6;
14629 dst[5] = (float) sample5;
14630 dst[4] = (float) sample4;
14631 dst[3] = (float) sample3;
14632 dst[2] = (float) sample2;
14633 dst[1] = (float) sample1;
14634 dst[0] = (float) sample0;
14635 last_sample7 = sample7;
14636 last_sample6 = sample6;
14637 last_sample5 = sample5;
14638 last_sample4 = sample4;
14639 last_sample3 = sample3;
14640 last_sample2 = sample2;
14641 last_sample1 = sample1;
14642 last_sample0 = sample0;
14643 dst -= 16;
14644 }
14645
14646 cvt->len_cvt = dstsize;
14647 if (cvt->filters[++cvt->filter_index]) {
14648 cvt->filters[cvt->filter_index] (cvt, format);
14649 }
14650 }
14651
14652 static void SDLCALL
14653 SDL_Downsample_F32LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14654 {
14655 #if DEBUG_CONVERT
14656 fprintf(stderr, "Downsample (x2) AUDIO_F32LSB, 8 channels.\n");
14657 #endif
14658
14659 const int dstsize = cvt->len_cvt / 2;
14660 float *dst = (float *) cvt->buf;
14661 const float *src = (float *) cvt->buf;
14662 const float *target = (const float *) (cvt->buf + dstsize);
14663 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14664 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14665 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14666 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14667 double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
14668 double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
14669 double last_sample6 = (double) SDL_SwapFloatLE(src[6]);
14670 double last_sample7 = (double) SDL_SwapFloatLE(src[7]);
14671 while (dst < target) {
14672 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14673 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14674 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14675 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14676 const double sample4 = (double) SDL_SwapFloatLE(src[4]);
14677 const double sample5 = (double) SDL_SwapFloatLE(src[5]);
14678 const double sample6 = (double) SDL_SwapFloatLE(src[6]);
14679 const double sample7 = (double) SDL_SwapFloatLE(src[7]);
14680 src += 16;
14681 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14682 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
14683 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
14684 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
14685 dst[4] = (float) ((sample4 + last_sample4) * 0.5);
14686 dst[5] = (float) ((sample5 + last_sample5) * 0.5);
14687 dst[6] = (float) ((sample6 + last_sample6) * 0.5);
14688 dst[7] = (float) ((sample7 + last_sample7) * 0.5);
14689 last_sample0 = sample0;
14690 last_sample1 = sample1;
14691 last_sample2 = sample2;
14692 last_sample3 = sample3;
14693 last_sample4 = sample4;
14694 last_sample5 = sample5;
14695 last_sample6 = sample6;
14696 last_sample7 = sample7;
14697 dst += 8;
14698 }
14699
14700 cvt->len_cvt = dstsize;
14701 if (cvt->filters[++cvt->filter_index]) {
14702 cvt->filters[cvt->filter_index] (cvt, format);
14703 }
14704 }
14705
14706 static void SDLCALL
14707 SDL_Upsample_F32LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14708 {
14709 #if DEBUG_CONVERT
14710 fprintf(stderr, "Upsample (x4) AUDIO_F32LSB, 8 channels.\n");
14711 #endif
14712
14713 const int dstsize = cvt->len_cvt * 4;
14714 float *dst = ((float *) (cvt->buf + dstsize)) - 8 * 4;
14715 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
14716 const float *target = ((const float *) cvt->buf);
14717 double last_sample7 = (double) SDL_SwapFloatLE(src[7]);
14718 double last_sample6 = (double) SDL_SwapFloatLE(src[6]);
14719 double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
14720 double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
14721 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14722 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14723 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14724 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14725 while (dst >= target) {
14726 const double sample7 = (double) SDL_SwapFloatLE(src[7]);
14727 const double sample6 = (double) SDL_SwapFloatLE(src[6]);
14728 const double sample5 = (double) SDL_SwapFloatLE(src[5]);
14729 const double sample4 = (double) SDL_SwapFloatLE(src[4]);
14730 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14731 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14732 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14733 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14734 src -= 8;
14735 dst[31] = (float) ((sample7 + (3.0 * last_sample7)) * 0.25);
14736 dst[30] = (float) ((sample6 + (3.0 * last_sample6)) * 0.25);
14737 dst[29] = (float) ((sample5 + (3.0 * last_sample5)) * 0.25);
14738 dst[28] = (float) ((sample4 + (3.0 * last_sample4)) * 0.25);
14739 dst[27] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
14740 dst[26] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
14741 dst[25] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
14742 dst[24] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
14743 dst[23] = (float) ((sample7 + last_sample7) * 0.5);
14744 dst[22] = (float) ((sample6 + last_sample6) * 0.5);
14745 dst[21] = (float) ((sample5 + last_sample5) * 0.5);
14746 dst[20] = (float) ((sample4 + last_sample4) * 0.5);
14747 dst[19] = (float) ((sample3 + last_sample3) * 0.5);
14748 dst[18] = (float) ((sample2 + last_sample2) * 0.5);
14749 dst[17] = (float) ((sample1 + last_sample1) * 0.5);
14750 dst[16] = (float) ((sample0 + last_sample0) * 0.5);
14751 dst[15] = (float) (((3.0 * sample7) + last_sample7) * 0.25);
14752 dst[14] = (float) (((3.0 * sample6) + last_sample6) * 0.25);
14753 dst[13] = (float) (((3.0 * sample5) + last_sample5) * 0.25);
14754 dst[12] = (float) (((3.0 * sample4) + last_sample4) * 0.25);
14755 dst[11] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
14756 dst[10] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
14757 dst[9] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
14758 dst[8] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
14759 dst[7] = (float) sample7;
14760 dst[6] = (float) sample6;
14761 dst[5] = (float) sample5;
14762 dst[4] = (float) sample4;
14763 dst[3] = (float) sample3;
14764 dst[2] = (float) sample2;
14765 dst[1] = (float) sample1;
14766 dst[0] = (float) sample0;
14767 last_sample7 = sample7;
14768 last_sample6 = sample6;
14769 last_sample5 = sample5;
14770 last_sample4 = sample4;
14771 last_sample3 = sample3;
14772 last_sample2 = sample2;
14773 last_sample1 = sample1;
14774 last_sample0 = sample0;
14775 dst -= 32;
14776 }
14777
14778 cvt->len_cvt = dstsize;
14779 if (cvt->filters[++cvt->filter_index]) {
14780 cvt->filters[cvt->filter_index] (cvt, format);
14781 }
14782 }
14783
14784 static void SDLCALL
14785 SDL_Downsample_F32LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14786 {
14787 #if DEBUG_CONVERT
14788 fprintf(stderr, "Downsample (x4) AUDIO_F32LSB, 8 channels.\n");
14789 #endif
14790
14791 const int dstsize = cvt->len_cvt / 4;
14792 float *dst = (float *) cvt->buf;
14793 const float *src = (float *) cvt->buf;
14794 const float *target = (const float *) (cvt->buf + dstsize);
14795 double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
14796 double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
14797 double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
14798 double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
14799 double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
14800 double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
14801 double last_sample6 = (double) SDL_SwapFloatLE(src[6]);
14802 double last_sample7 = (double) SDL_SwapFloatLE(src[7]);
14803 while (dst < target) {
14804 const double sample0 = (double) SDL_SwapFloatLE(src[0]);
14805 const double sample1 = (double) SDL_SwapFloatLE(src[1]);
14806 const double sample2 = (double) SDL_SwapFloatLE(src[2]);
14807 const double sample3 = (double) SDL_SwapFloatLE(src[3]);
14808 const double sample4 = (double) SDL_SwapFloatLE(src[4]);
14809 const double sample5 = (double) SDL_SwapFloatLE(src[5]);
14810 const double sample6 = (double) SDL_SwapFloatLE(src[6]);
14811 const double sample7 = (double) SDL_SwapFloatLE(src[7]);
14812 src += 32;
14813 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14814 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
14815 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
14816 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
14817 dst[4] = (float) ((sample4 + last_sample4) * 0.5);
14818 dst[5] = (float) ((sample5 + last_sample5) * 0.5);
14819 dst[6] = (float) ((sample6 + last_sample6) * 0.5);
14820 dst[7] = (float) ((sample7 + last_sample7) * 0.5);
14821 last_sample0 = sample0;
14822 last_sample1 = sample1;
14823 last_sample2 = sample2;
14824 last_sample3 = sample3;
14825 last_sample4 = sample4;
14826 last_sample5 = sample5;
14827 last_sample6 = sample6;
14828 last_sample7 = sample7;
14829 dst += 8;
14830 }
14831
14832 cvt->len_cvt = dstsize;
14833 if (cvt->filters[++cvt->filter_index]) {
14834 cvt->filters[cvt->filter_index] (cvt, format);
14835 }
14836 }
14837
14838 static void SDLCALL
14839 SDL_Upsample_F32MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14840 {
14841 #if DEBUG_CONVERT
14842 fprintf(stderr, "Upsample (x2) AUDIO_F32MSB, 1 channels.\n");
14843 #endif
14844
14845 const int dstsize = cvt->len_cvt * 2;
14846 float *dst = ((float *) (cvt->buf + dstsize)) - 1 * 2;
14847 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
14848 const float *target = ((const float *) cvt->buf);
14849 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
14850 while (dst >= target) {
14851 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
14852 src--;
14853 dst[1] = (float) ((sample0 + last_sample0) * 0.5);
14854 dst[0] = (float) sample0;
14855 last_sample0 = sample0;
14856 dst -= 2;
14857 }
14858
14859 cvt->len_cvt = dstsize;
14860 if (cvt->filters[++cvt->filter_index]) {
14861 cvt->filters[cvt->filter_index] (cvt, format);
14862 }
14863 }
14864
14865 static void SDLCALL
14866 SDL_Downsample_F32MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14867 {
14868 #if DEBUG_CONVERT
14869 fprintf(stderr, "Downsample (x2) AUDIO_F32MSB, 1 channels.\n");
14870 #endif
14871
14872 const int dstsize = cvt->len_cvt / 2;
14873 float *dst = (float *) cvt->buf;
14874 const float *src = (float *) cvt->buf;
14875 const float *target = (const float *) (cvt->buf + dstsize);
14876 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
14877 while (dst < target) {
14878 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
14879 src += 2;
14880 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14881 last_sample0 = sample0;
14882 dst++;
14883 }
14884
14885 cvt->len_cvt = dstsize;
14886 if (cvt->filters[++cvt->filter_index]) {
14887 cvt->filters[cvt->filter_index] (cvt, format);
14888 }
14889 }
14890
14891 static void SDLCALL
14892 SDL_Upsample_F32MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14893 {
14894 #if DEBUG_CONVERT
14895 fprintf(stderr, "Upsample (x4) AUDIO_F32MSB, 1 channels.\n");
14896 #endif
14897
14898 const int dstsize = cvt->len_cvt * 4;
14899 float *dst = ((float *) (cvt->buf + dstsize)) - 1 * 4;
14900 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
14901 const float *target = ((const float *) cvt->buf);
14902 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
14903 while (dst >= target) {
14904 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
14905 src--;
14906 dst[3] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
14907 dst[2] = (float) ((sample0 + last_sample0) * 0.5);
14908 dst[1] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
14909 dst[0] = (float) sample0;
14910 last_sample0 = sample0;
14911 dst -= 4;
14912 }
14913
14914 cvt->len_cvt = dstsize;
14915 if (cvt->filters[++cvt->filter_index]) {
14916 cvt->filters[cvt->filter_index] (cvt, format);
14917 }
14918 }
14919
14920 static void SDLCALL
14921 SDL_Downsample_F32MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14922 {
14923 #if DEBUG_CONVERT
14924 fprintf(stderr, "Downsample (x4) AUDIO_F32MSB, 1 channels.\n");
14925 #endif
14926
14927 const int dstsize = cvt->len_cvt / 4;
14928 float *dst = (float *) cvt->buf;
14929 const float *src = (float *) cvt->buf;
14930 const float *target = (const float *) (cvt->buf + dstsize);
14931 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
14932 while (dst < target) {
14933 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
14934 src += 4;
14935 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14936 last_sample0 = sample0;
14937 dst++;
14938 }
14939
14940 cvt->len_cvt = dstsize;
14941 if (cvt->filters[++cvt->filter_index]) {
14942 cvt->filters[cvt->filter_index] (cvt, format);
14943 }
14944 }
14945
14946 static void SDLCALL
14947 SDL_Upsample_F32MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14948 {
14949 #if DEBUG_CONVERT
14950 fprintf(stderr, "Upsample (x2) AUDIO_F32MSB, 2 channels.\n");
14951 #endif
14952
14953 const int dstsize = cvt->len_cvt * 2;
14954 float *dst = ((float *) (cvt->buf + dstsize)) - 2 * 2;
14955 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
14956 const float *target = ((const float *) cvt->buf);
14957 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
14958 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
14959 while (dst >= target) {
14960 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
14961 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
14962 src -= 2;
14963 dst[3] = (float) ((sample1 + last_sample1) * 0.5);
14964 dst[2] = (float) ((sample0 + last_sample0) * 0.5);
14965 dst[1] = (float) sample1;
14966 dst[0] = (float) sample0;
14967 last_sample1 = sample1;
14968 last_sample0 = sample0;
14969 dst -= 4;
14970 }
14971
14972 cvt->len_cvt = dstsize;
14973 if (cvt->filters[++cvt->filter_index]) {
14974 cvt->filters[cvt->filter_index] (cvt, format);
14975 }
14976 }
14977
14978 static void SDLCALL
14979 SDL_Downsample_F32MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
14980 {
14981 #if DEBUG_CONVERT
14982 fprintf(stderr, "Downsample (x2) AUDIO_F32MSB, 2 channels.\n");
14983 #endif
14984
14985 const int dstsize = cvt->len_cvt / 2;
14986 float *dst = (float *) cvt->buf;
14987 const float *src = (float *) cvt->buf;
14988 const float *target = (const float *) (cvt->buf + dstsize);
14989 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
14990 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
14991 while (dst < target) {
14992 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
14993 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
14994 src += 4;
14995 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
14996 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
14997 last_sample0 = sample0;
14998 last_sample1 = sample1;
14999 dst += 2;
15000 }
15001
15002 cvt->len_cvt = dstsize;
15003 if (cvt->filters[++cvt->filter_index]) {
15004 cvt->filters[cvt->filter_index] (cvt, format);
15005 }
15006 }
15007
15008 static void SDLCALL
15009 SDL_Upsample_F32MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15010 {
15011 #if DEBUG_CONVERT
15012 fprintf(stderr, "Upsample (x4) AUDIO_F32MSB, 2 channels.\n");
15013 #endif
15014
15015 const int dstsize = cvt->len_cvt * 4;
15016 float *dst = ((float *) (cvt->buf + dstsize)) - 2 * 4;
15017 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
15018 const float *target = ((const float *) cvt->buf);
15019 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15020 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15021 while (dst >= target) {
15022 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15023 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15024 src -= 2;
15025 dst[7] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
15026 dst[6] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
15027 dst[5] = (float) ((sample1 + last_sample1) * 0.5);
15028 dst[4] = (float) ((sample0 + last_sample0) * 0.5);
15029 dst[3] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
15030 dst[2] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
15031 dst[1] = (float) sample1;
15032 dst[0] = (float) sample0;
15033 last_sample1 = sample1;
15034 last_sample0 = sample0;
15035 dst -= 8;
15036 }
15037
15038 cvt->len_cvt = dstsize;
15039 if (cvt->filters[++cvt->filter_index]) {
15040 cvt->filters[cvt->filter_index] (cvt, format);
15041 }
15042 }
15043
15044 static void SDLCALL
15045 SDL_Downsample_F32MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15046 {
15047 #if DEBUG_CONVERT
15048 fprintf(stderr, "Downsample (x4) AUDIO_F32MSB, 2 channels.\n");
15049 #endif
15050
15051 const int dstsize = cvt->len_cvt / 4;
15052 float *dst = (float *) cvt->buf;
15053 const float *src = (float *) cvt->buf;
15054 const float *target = (const float *) (cvt->buf + dstsize);
15055 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15056 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15057 while (dst < target) {
15058 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15059 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15060 src += 8;
15061 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
15062 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
15063 last_sample0 = sample0;
15064 last_sample1 = sample1;
15065 dst += 2;
15066 }
15067
15068 cvt->len_cvt = dstsize;
15069 if (cvt->filters[++cvt->filter_index]) {
15070 cvt->filters[cvt->filter_index] (cvt, format);
15071 }
15072 }
15073
15074 static void SDLCALL
15075 SDL_Upsample_F32MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15076 {
15077 #if DEBUG_CONVERT
15078 fprintf(stderr, "Upsample (x2) AUDIO_F32MSB, 4 channels.\n");
15079 #endif
15080
15081 const int dstsize = cvt->len_cvt * 2;
15082 float *dst = ((float *) (cvt->buf + dstsize)) - 4 * 2;
15083 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
15084 const float *target = ((const float *) cvt->buf);
15085 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15086 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15087 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15088 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15089 while (dst >= target) {
15090 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15091 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15092 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15093 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15094 src -= 4;
15095 dst[7] = (float) ((sample3 + last_sample3) * 0.5);
15096 dst[6] = (float) ((sample2 + last_sample2) * 0.5);
15097 dst[5] = (float) ((sample1 + last_sample1) * 0.5);
15098 dst[4] = (float) ((sample0 + last_sample0) * 0.5);
15099 dst[3] = (float) sample3;
15100 dst[2] = (float) sample2;
15101 dst[1] = (float) sample1;
15102 dst[0] = (float) sample0;
15103 last_sample3 = sample3;
15104 last_sample2 = sample2;
15105 last_sample1 = sample1;
15106 last_sample0 = sample0;
15107 dst -= 8;
15108 }
15109
15110 cvt->len_cvt = dstsize;
15111 if (cvt->filters[++cvt->filter_index]) {
15112 cvt->filters[cvt->filter_index] (cvt, format);
15113 }
15114 }
15115
15116 static void SDLCALL
15117 SDL_Downsample_F32MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15118 {
15119 #if DEBUG_CONVERT
15120 fprintf(stderr, "Downsample (x2) AUDIO_F32MSB, 4 channels.\n");
15121 #endif
15122
15123 const int dstsize = cvt->len_cvt / 2;
15124 float *dst = (float *) cvt->buf;
15125 const float *src = (float *) cvt->buf;
15126 const float *target = (const float *) (cvt->buf + dstsize);
15127 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15128 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15129 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15130 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15131 while (dst < target) {
15132 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15133 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15134 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15135 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15136 src += 8;
15137 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
15138 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
15139 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
15140 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
15141 last_sample0 = sample0;
15142 last_sample1 = sample1;
15143 last_sample2 = sample2;
15144 last_sample3 = sample3;
15145 dst += 4;
15146 }
15147
15148 cvt->len_cvt = dstsize;
15149 if (cvt->filters[++cvt->filter_index]) {
15150 cvt->filters[cvt->filter_index] (cvt, format);
15151 }
15152 }
15153
15154 static void SDLCALL
15155 SDL_Upsample_F32MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15156 {
15157 #if DEBUG_CONVERT
15158 fprintf(stderr, "Upsample (x4) AUDIO_F32MSB, 4 channels.\n");
15159 #endif
15160
15161 const int dstsize = cvt->len_cvt * 4;
15162 float *dst = ((float *) (cvt->buf + dstsize)) - 4 * 4;
15163 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
15164 const float *target = ((const float *) cvt->buf);
15165 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15166 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15167 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15168 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15169 while (dst >= target) {
15170 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15171 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15172 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15173 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15174 src -= 4;
15175 dst[15] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
15176 dst[14] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
15177 dst[13] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
15178 dst[12] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
15179 dst[11] = (float) ((sample3 + last_sample3) * 0.5);
15180 dst[10] = (float) ((sample2 + last_sample2) * 0.5);
15181 dst[9] = (float) ((sample1 + last_sample1) * 0.5);
15182 dst[8] = (float) ((sample0 + last_sample0) * 0.5);
15183 dst[7] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
15184 dst[6] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
15185 dst[5] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
15186 dst[4] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
15187 dst[3] = (float) sample3;
15188 dst[2] = (float) sample2;
15189 dst[1] = (float) sample1;
15190 dst[0] = (float) sample0;
15191 last_sample3 = sample3;
15192 last_sample2 = sample2;
15193 last_sample1 = sample1;
15194 last_sample0 = sample0;
15195 dst -= 16;
15196 }
15197
15198 cvt->len_cvt = dstsize;
15199 if (cvt->filters[++cvt->filter_index]) {
15200 cvt->filters[cvt->filter_index] (cvt, format);
15201 }
15202 }
15203
15204 static void SDLCALL
15205 SDL_Downsample_F32MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15206 {
15207 #if DEBUG_CONVERT
15208 fprintf(stderr, "Downsample (x4) AUDIO_F32MSB, 4 channels.\n");
15209 #endif
15210
15211 const int dstsize = cvt->len_cvt / 4;
15212 float *dst = (float *) cvt->buf;
15213 const float *src = (float *) cvt->buf;
15214 const float *target = (const float *) (cvt->buf + dstsize);
15215 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15216 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15217 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15218 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15219 while (dst < target) {
15220 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15221 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15222 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15223 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15224 src += 16;
15225 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
15226 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
15227 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
15228 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
15229 last_sample0 = sample0;
15230 last_sample1 = sample1;
15231 last_sample2 = sample2;
15232 last_sample3 = sample3;
15233 dst += 4;
15234 }
15235
15236 cvt->len_cvt = dstsize;
15237 if (cvt->filters[++cvt->filter_index]) {
15238 cvt->filters[cvt->filter_index] (cvt, format);
15239 }
15240 }
15241
15242 static void SDLCALL
15243 SDL_Upsample_F32MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15244 {
15245 #if DEBUG_CONVERT
15246 fprintf(stderr, "Upsample (x2) AUDIO_F32MSB, 6 channels.\n");
15247 #endif
15248
15249 const int dstsize = cvt->len_cvt * 2;
15250 float *dst = ((float *) (cvt->buf + dstsize)) - 6 * 2;
15251 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
15252 const float *target = ((const float *) cvt->buf);
15253 double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
15254 double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
15255 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15256 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15257 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15258 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15259 while (dst >= target) {
15260 const double sample5 = (double) SDL_SwapFloatBE(src[5]);
15261 const double sample4 = (double) SDL_SwapFloatBE(src[4]);
15262 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15263 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15264 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15265 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15266 src -= 6;
15267 dst[11] = (float) ((sample5 + last_sample5) * 0.5);
15268 dst[10] = (float) ((sample4 + last_sample4) * 0.5);
15269 dst[9] = (float) ((sample3 + last_sample3) * 0.5);
15270 dst[8] = (float) ((sample2 + last_sample2) * 0.5);
15271 dst[7] = (float) ((sample1 + last_sample1) * 0.5);
15272 dst[6] = (float) ((sample0 + last_sample0) * 0.5);
15273 dst[5] = (float) sample5;
15274 dst[4] = (float) sample4;
15275 dst[3] = (float) sample3;
15276 dst[2] = (float) sample2;
15277 dst[1] = (float) sample1;
15278 dst[0] = (float) sample0;
15279 last_sample5 = sample5;
15280 last_sample4 = sample4;
15281 last_sample3 = sample3;
15282 last_sample2 = sample2;
15283 last_sample1 = sample1;
15284 last_sample0 = sample0;
15285 dst -= 12;
15286 }
15287
15288 cvt->len_cvt = dstsize;
15289 if (cvt->filters[++cvt->filter_index]) {
15290 cvt->filters[cvt->filter_index] (cvt, format);
15291 }
15292 }
15293
15294 static void SDLCALL
15295 SDL_Downsample_F32MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15296 {
15297 #if DEBUG_CONVERT
15298 fprintf(stderr, "Downsample (x2) AUDIO_F32MSB, 6 channels.\n");
15299 #endif
15300
15301 const int dstsize = cvt->len_cvt / 2;
15302 float *dst = (float *) cvt->buf;
15303 const float *src = (float *) cvt->buf;
15304 const float *target = (const float *) (cvt->buf + dstsize);
15305 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15306 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15307 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15308 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15309 double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
15310 double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
15311 while (dst < target) {
15312 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15313 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15314 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15315 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15316 const double sample4 = (double) SDL_SwapFloatBE(src[4]);
15317 const double sample5 = (double) SDL_SwapFloatBE(src[5]);
15318 src += 12;
15319 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
15320 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
15321 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
15322 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
15323 dst[4] = (float) ((sample4 + last_sample4) * 0.5);
15324 dst[5] = (float) ((sample5 + last_sample5) * 0.5);
15325 last_sample0 = sample0;
15326 last_sample1 = sample1;
15327 last_sample2 = sample2;
15328 last_sample3 = sample3;
15329 last_sample4 = sample4;
15330 last_sample5 = sample5;
15331 dst += 6;
15332 }
15333
15334 cvt->len_cvt = dstsize;
15335 if (cvt->filters[++cvt->filter_index]) {
15336 cvt->filters[cvt->filter_index] (cvt, format);
15337 }
15338 }
15339
15340 static void SDLCALL
15341 SDL_Upsample_F32MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15342 {
15343 #if DEBUG_CONVERT
15344 fprintf(stderr, "Upsample (x4) AUDIO_F32MSB, 6 channels.\n");
15345 #endif
15346
15347 const int dstsize = cvt->len_cvt * 4;
15348 float *dst = ((float *) (cvt->buf + dstsize)) - 6 * 4;
15349 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
15350 const float *target = ((const float *) cvt->buf);
15351 double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
15352 double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
15353 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15354 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15355 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15356 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15357 while (dst >= target) {
15358 const double sample5 = (double) SDL_SwapFloatBE(src[5]);
15359 const double sample4 = (double) SDL_SwapFloatBE(src[4]);
15360 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15361 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15362 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15363 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15364 src -= 6;
15365 dst[23] = (float) ((sample5 + (3.0 * last_sample5)) * 0.25);
15366 dst[22] = (float) ((sample4 + (3.0 * last_sample4)) * 0.25);
15367 dst[21] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
15368 dst[20] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
15369 dst[19] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
15370 dst[18] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
15371 dst[17] = (float) ((sample5 + last_sample5) * 0.5);
15372 dst[16] = (float) ((sample4 + last_sample4) * 0.5);
15373 dst[15] = (float) ((sample3 + last_sample3) * 0.5);
15374 dst[14] = (float) ((sample2 + last_sample2) * 0.5);
15375 dst[13] = (float) ((sample1 + last_sample1) * 0.5);
15376 dst[12] = (float) ((sample0 + last_sample0) * 0.5);
15377 dst[11] = (float) (((3.0 * sample5) + last_sample5) * 0.25);
15378 dst[10] = (float) (((3.0 * sample4) + last_sample4) * 0.25);
15379 dst[9] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
15380 dst[8] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
15381 dst[7] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
15382 dst[6] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
15383 dst[5] = (float) sample5;
15384 dst[4] = (float) sample4;
15385 dst[3] = (float) sample3;
15386 dst[2] = (float) sample2;
15387 dst[1] = (float) sample1;
15388 dst[0] = (float) sample0;
15389 last_sample5 = sample5;
15390 last_sample4 = sample4;
15391 last_sample3 = sample3;
15392 last_sample2 = sample2;
15393 last_sample1 = sample1;
15394 last_sample0 = sample0;
15395 dst -= 24;
15396 }
15397
15398 cvt->len_cvt = dstsize;
15399 if (cvt->filters[++cvt->filter_index]) {
15400 cvt->filters[cvt->filter_index] (cvt, format);
15401 }
15402 }
15403
15404 static void SDLCALL
15405 SDL_Downsample_F32MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15406 {
15407 #if DEBUG_CONVERT
15408 fprintf(stderr, "Downsample (x4) AUDIO_F32MSB, 6 channels.\n");
15409 #endif
15410
15411 const int dstsize = cvt->len_cvt / 4;
15412 float *dst = (float *) cvt->buf;
15413 const float *src = (float *) cvt->buf;
15414 const float *target = (const float *) (cvt->buf + dstsize);
15415 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15416 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15417 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15418 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15419 double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
15420 double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
15421 while (dst < target) {
15422 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15423 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15424 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15425 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15426 const double sample4 = (double) SDL_SwapFloatBE(src[4]);
15427 const double sample5 = (double) SDL_SwapFloatBE(src[5]);
15428 src += 24;
15429 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
15430 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
15431 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
15432 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
15433 dst[4] = (float) ((sample4 + last_sample4) * 0.5);
15434 dst[5] = (float) ((sample5 + last_sample5) * 0.5);
15435 last_sample0 = sample0;
15436 last_sample1 = sample1;
15437 last_sample2 = sample2;
15438 last_sample3 = sample3;
15439 last_sample4 = sample4;
15440 last_sample5 = sample5;
15441 dst += 6;
15442 }
15443
15444 cvt->len_cvt = dstsize;
15445 if (cvt->filters[++cvt->filter_index]) {
15446 cvt->filters[cvt->filter_index] (cvt, format);
15447 }
15448 }
15449
15450 static void SDLCALL
15451 SDL_Upsample_F32MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15452 {
15453 #if DEBUG_CONVERT
15454 fprintf(stderr, "Upsample (x2) AUDIO_F32MSB, 8 channels.\n");
15455 #endif
15456
15457 const int dstsize = cvt->len_cvt * 2;
15458 float *dst = ((float *) (cvt->buf + dstsize)) - 8 * 2;
15459 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
15460 const float *target = ((const float *) cvt->buf);
15461 double last_sample7 = (double) SDL_SwapFloatBE(src[7]);
15462 double last_sample6 = (double) SDL_SwapFloatBE(src[6]);
15463 double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
15464 double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
15465 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15466 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15467 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15468 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15469 while (dst >= target) {
15470 const double sample7 = (double) SDL_SwapFloatBE(src[7]);
15471 const double sample6 = (double) SDL_SwapFloatBE(src[6]);
15472 const double sample5 = (double) SDL_SwapFloatBE(src[5]);
15473 const double sample4 = (double) SDL_SwapFloatBE(src[4]);
15474 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15475 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15476 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15477 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15478 src -= 8;
15479 dst[15] = (float) ((sample7 + last_sample7) * 0.5);
15480 dst[14] = (float) ((sample6 + last_sample6) * 0.5);
15481 dst[13] = (float) ((sample5 + last_sample5) * 0.5);
15482 dst[12] = (float) ((sample4 + last_sample4) * 0.5);
15483 dst[11] = (float) ((sample3 + last_sample3) * 0.5);
15484 dst[10] = (float) ((sample2 + last_sample2) * 0.5);
15485 dst[9] = (float) ((sample1 + last_sample1) * 0.5);
15486 dst[8] = (float) ((sample0 + last_sample0) * 0.5);
15487 dst[7] = (float) sample7;
15488 dst[6] = (float) sample6;
15489 dst[5] = (float) sample5;
15490 dst[4] = (float) sample4;
15491 dst[3] = (float) sample3;
15492 dst[2] = (float) sample2;
15493 dst[1] = (float) sample1;
15494 dst[0] = (float) sample0;
15495 last_sample7 = sample7;
15496 last_sample6 = sample6;
15497 last_sample5 = sample5;
15498 last_sample4 = sample4;
15499 last_sample3 = sample3;
15500 last_sample2 = sample2;
15501 last_sample1 = sample1;
15502 last_sample0 = sample0;
15503 dst -= 16;
15504 }
15505
15506 cvt->len_cvt = dstsize;
15507 if (cvt->filters[++cvt->filter_index]) {
15508 cvt->filters[cvt->filter_index] (cvt, format);
15509 }
15510 }
15511
15512 static void SDLCALL
15513 SDL_Downsample_F32MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15514 {
15515 #if DEBUG_CONVERT
15516 fprintf(stderr, "Downsample (x2) AUDIO_F32MSB, 8 channels.\n");
15517 #endif
15518
15519 const int dstsize = cvt->len_cvt / 2;
15520 float *dst = (float *) cvt->buf;
15521 const float *src = (float *) cvt->buf;
15522 const float *target = (const float *) (cvt->buf + dstsize);
15523 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15524 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15525 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15526 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15527 double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
15528 double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
15529 double last_sample6 = (double) SDL_SwapFloatBE(src[6]);
15530 double last_sample7 = (double) SDL_SwapFloatBE(src[7]);
15531 while (dst < target) {
15532 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15533 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15534 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15535 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15536 const double sample4 = (double) SDL_SwapFloatBE(src[4]);
15537 const double sample5 = (double) SDL_SwapFloatBE(src[5]);
15538 const double sample6 = (double) SDL_SwapFloatBE(src[6]);
15539 const double sample7 = (double) SDL_SwapFloatBE(src[7]);
15540 src += 16;
15541 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
15542 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
15543 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
15544 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
15545 dst[4] = (float) ((sample4 + last_sample4) * 0.5);
15546 dst[5] = (float) ((sample5 + last_sample5) * 0.5);
15547 dst[6] = (float) ((sample6 + last_sample6) * 0.5);
15548 dst[7] = (float) ((sample7 + last_sample7) * 0.5);
15549 last_sample0 = sample0;
15550 last_sample1 = sample1;
15551 last_sample2 = sample2;
15552 last_sample3 = sample3;
15553 last_sample4 = sample4;
15554 last_sample5 = sample5;
15555 last_sample6 = sample6;
15556 last_sample7 = sample7;
15557 dst += 8;
15558 }
15559
15560 cvt->len_cvt = dstsize;
15561 if (cvt->filters[++cvt->filter_index]) {
15562 cvt->filters[cvt->filter_index] (cvt, format);
15563 }
15564 }
15565
15566 static void SDLCALL
15567 SDL_Upsample_F32MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15568 {
15569 #if DEBUG_CONVERT
15570 fprintf(stderr, "Upsample (x4) AUDIO_F32MSB, 8 channels.\n");
15571 #endif
15572
15573 const int dstsize = cvt->len_cvt * 4;
15574 float *dst = ((float *) (cvt->buf + dstsize)) - 8 * 4;
15575 const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
15576 const float *target = ((const float *) cvt->buf);
15577 double last_sample7 = (double) SDL_SwapFloatBE(src[7]);
15578 double last_sample6 = (double) SDL_SwapFloatBE(src[6]);
15579 double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
15580 double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
15581 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15582 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15583 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15584 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15585 while (dst >= target) {
15586 const double sample7 = (double) SDL_SwapFloatBE(src[7]);
15587 const double sample6 = (double) SDL_SwapFloatBE(src[6]);
15588 const double sample5 = (double) SDL_SwapFloatBE(src[5]);
15589 const double sample4 = (double) SDL_SwapFloatBE(src[4]);
15590 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15591 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15592 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15593 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15594 src -= 8;
15595 dst[31] = (float) ((sample7 + (3.0 * last_sample7)) * 0.25);
15596 dst[30] = (float) ((sample6 + (3.0 * last_sample6)) * 0.25);
15597 dst[29] = (float) ((sample5 + (3.0 * last_sample5)) * 0.25);
15598 dst[28] = (float) ((sample4 + (3.0 * last_sample4)) * 0.25);
15599 dst[27] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
15600 dst[26] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
15601 dst[25] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
15602 dst[24] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
15603 dst[23] = (float) ((sample7 + last_sample7) * 0.5);
15604 dst[22] = (float) ((sample6 + last_sample6) * 0.5);
15605 dst[21] = (float) ((sample5 + last_sample5) * 0.5);
15606 dst[20] = (float) ((sample4 + last_sample4) * 0.5);
15607 dst[19] = (float) ((sample3 + last_sample3) * 0.5);
15608 dst[18] = (float) ((sample2 + last_sample2) * 0.5);
15609 dst[17] = (float) ((sample1 + last_sample1) * 0.5);
15610 dst[16] = (float) ((sample0 + last_sample0) * 0.5);
15611 dst[15] = (float) (((3.0 * sample7) + last_sample7) * 0.25);
15612 dst[14] = (float) (((3.0 * sample6) + last_sample6) * 0.25);
15613 dst[13] = (float) (((3.0 * sample5) + last_sample5) * 0.25);
15614 dst[12] = (float) (((3.0 * sample4) + last_sample4) * 0.25);
15615 dst[11] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
15616 dst[10] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
15617 dst[9] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
15618 dst[8] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
15619 dst[7] = (float) sample7;
15620 dst[6] = (float) sample6;
15621 dst[5] = (float) sample5;
15622 dst[4] = (float) sample4;
15623 dst[3] = (float) sample3;
15624 dst[2] = (float) sample2;
15625 dst[1] = (float) sample1;
15626 dst[0] = (float) sample0;
15627 last_sample7 = sample7;
15628 last_sample6 = sample6;
15629 last_sample5 = sample5;
15630 last_sample4 = sample4;
15631 last_sample3 = sample3;
15632 last_sample2 = sample2;
15633 last_sample1 = sample1;
15634 last_sample0 = sample0;
15635 dst -= 32;
15636 }
15637
15638 cvt->len_cvt = dstsize;
15639 if (cvt->filters[++cvt->filter_index]) {
15640 cvt->filters[cvt->filter_index] (cvt, format);
15641 }
15642 }
15643
15644 static void SDLCALL
15645 SDL_Downsample_F32MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
15646 {
15647 #if DEBUG_CONVERT
15648 fprintf(stderr, "Downsample (x4) AUDIO_F32MSB, 8 channels.\n");
15649 #endif
15650
15651 const int dstsize = cvt->len_cvt / 4;
15652 float *dst = (float *) cvt->buf;
15653 const float *src = (float *) cvt->buf;
15654 const float *target = (const float *) (cvt->buf + dstsize);
15655 double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
15656 double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
15657 double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
15658 double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
15659 double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
15660 double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
15661 double last_sample6 = (double) SDL_SwapFloatBE(src[6]);
15662 double last_sample7 = (double) SDL_SwapFloatBE(src[7]);
15663 while (dst < target) {
15664 const double sample0 = (double) SDL_SwapFloatBE(src[0]);
15665 const double sample1 = (double) SDL_SwapFloatBE(src[1]);
15666 const double sample2 = (double) SDL_SwapFloatBE(src[2]);
15667 const double sample3 = (double) SDL_SwapFloatBE(src[3]);
15668 const double sample4 = (double) SDL_SwapFloatBE(src[4]);
15669 const double sample5 = (double) SDL_SwapFloatBE(src[5]);
15670 const double sample6 = (double) SDL_SwapFloatBE(src[6]);
15671 const double sample7 = (double) SDL_SwapFloatBE(src[7]);
15672 src += 32;
15673 dst[0] = (float) ((sample0 + last_sample0) * 0.5);
15674 dst[1] = (float) ((sample1 + last_sample1) * 0.5);
15675 dst[2] = (float) ((sample2 + last_sample2) * 0.5);
15676 dst[3] = (float) ((sample3 + last_sample3) * 0.5);
15677 dst[4] = (float) ((sample4 + last_sample4) * 0.5);
15678 dst[5] = (float) ((sample5 + last_sample5) * 0.5);
15679 dst[6] = (float) ((sample6 + last_sample6) * 0.5);
15680 dst[7] = (float) ((sample7 + last_sample7) * 0.5);
15681 last_sample0 = sample0;
15682 last_sample1 = sample1;
15683 last_sample2 = sample2;
15684 last_sample3 = sample3;
15685 last_sample4 = sample4;
15686 last_sample5 = sample5;
15687 last_sample6 = sample6;
15688 last_sample7 = sample7;
15689 dst += 8;
15690 }
15691
15692 cvt->len_cvt = dstsize;
15693 if (cvt->filters[++cvt->filter_index]) {
15694 cvt->filters[cvt->filter_index] (cvt, format);
15695 }
15696 }
15697
15698 #endif /* !LESS_RESAMPLERS */
15699 #endif /* !NO_RESAMPLERS */
15700
15701
15702 const SDL_AudioRateFilters sdl_audio_rate_filters[] =
15703 {
15704 #if !NO_RESAMPLERS
15705 { AUDIO_U8, 1, 0, 0, SDL_Downsample_U8_1c },
15706 { AUDIO_U8, 1, 1, 0, SDL_Upsample_U8_1c },
15707 { AUDIO_U8, 2, 0, 0, SDL_Downsample_U8_2c },
15708 { AUDIO_U8, 2, 1, 0, SDL_Upsample_U8_2c },
15709 { AUDIO_U8, 4, 0, 0, SDL_Downsample_U8_4c },
15710 { AUDIO_U8, 4, 1, 0, SDL_Upsample_U8_4c },
15711 { AUDIO_U8, 6, 0, 0, SDL_Downsample_U8_6c },
15712 { AUDIO_U8, 6, 1, 0, SDL_Upsample_U8_6c },
15713 { AUDIO_U8, 8, 0, 0, SDL_Downsample_U8_8c },
15714 { AUDIO_U8, 8, 1, 0, SDL_Upsample_U8_8c },
15715 { AUDIO_S8, 1, 0, 0, SDL_Downsample_S8_1c },
15716 { AUDIO_S8, 1, 1, 0, SDL_Upsample_S8_1c },
15717 { AUDIO_S8, 2, 0, 0, SDL_Downsample_S8_2c },
15718 { AUDIO_S8, 2, 1, 0, SDL_Upsample_S8_2c },
15719 { AUDIO_S8, 4, 0, 0, SDL_Downsample_S8_4c },
15720 { AUDIO_S8, 4, 1, 0, SDL_Upsample_S8_4c },
15721 { AUDIO_S8, 6, 0, 0, SDL_Downsample_S8_6c },
15722 { AUDIO_S8, 6, 1, 0, SDL_Upsample_S8_6c },
15723 { AUDIO_S8, 8, 0, 0, SDL_Downsample_S8_8c },
15724 { AUDIO_S8, 8, 1, 0, SDL_Upsample_S8_8c },
15725 { AUDIO_U16LSB, 1, 0, 0, SDL_Downsample_U16LSB_1c },
15726 { AUDIO_U16LSB, 1, 1, 0, SDL_Upsample_U16LSB_1c },
15727 { AUDIO_U16LSB, 2, 0, 0, SDL_Downsample_U16LSB_2c },
15728 { AUDIO_U16LSB, 2, 1, 0, SDL_Upsample_U16LSB_2c },
15729 { AUDIO_U16LSB, 4, 0, 0, SDL_Downsample_U16LSB_4c },
15730 { AUDIO_U16LSB, 4, 1, 0, SDL_Upsample_U16LSB_4c },
15731 { AUDIO_U16LSB, 6, 0, 0, SDL_Downsample_U16LSB_6c },
15732 { AUDIO_U16LSB, 6, 1, 0, SDL_Upsample_U16LSB_6c },
15733 { AUDIO_U16LSB, 8, 0, 0, SDL_Downsample_U16LSB_8c },
15734 { AUDIO_U16LSB, 8, 1, 0, SDL_Upsample_U16LSB_8c },
15735 { AUDIO_S16LSB, 1, 0, 0, SDL_Downsample_S16LSB_1c },
15736 { AUDIO_S16LSB, 1, 1, 0, SDL_Upsample_S16LSB_1c },
15737 { AUDIO_S16LSB, 2, 0, 0, SDL_Downsample_S16LSB_2c },
15738 { AUDIO_S16LSB, 2, 1, 0, SDL_Upsample_S16LSB_2c },
15739 { AUDIO_S16LSB, 4, 0, 0, SDL_Downsample_S16LSB_4c },
15740 { AUDIO_S16LSB, 4, 1, 0, SDL_Upsample_S16LSB_4c },
15741 { AUDIO_S16LSB, 6, 0, 0, SDL_Downsample_S16LSB_6c },
15742 { AUDIO_S16LSB, 6, 1, 0, SDL_Upsample_S16LSB_6c },
15743 { AUDIO_S16LSB, 8, 0, 0, SDL_Downsample_S16LSB_8c },
15744 { AUDIO_S16LSB, 8, 1, 0, SDL_Upsample_S16LSB_8c },
15745 { AUDIO_U16MSB, 1, 0, 0, SDL_Downsample_U16MSB_1c },
15746 { AUDIO_U16MSB, 1, 1, 0, SDL_Upsample_U16MSB_1c },
15747 { AUDIO_U16MSB, 2, 0, 0, SDL_Downsample_U16MSB_2c },
15748 { AUDIO_U16MSB, 2, 1, 0, SDL_Upsample_U16MSB_2c },
15749 { AUDIO_U16MSB, 4, 0, 0, SDL_Downsample_U16MSB_4c },
15750 { AUDIO_U16MSB, 4, 1, 0, SDL_Upsample_U16MSB_4c },
15751 { AUDIO_U16MSB, 6, 0, 0, SDL_Downsample_U16MSB_6c },
15752 { AUDIO_U16MSB, 6, 1, 0, SDL_Upsample_U16MSB_6c },
15753 { AUDIO_U16MSB, 8, 0, 0, SDL_Downsample_U16MSB_8c },
15754 { AUDIO_U16MSB, 8, 1, 0, SDL_Upsample_U16MSB_8c },
15755 { AUDIO_S16MSB, 1, 0, 0, SDL_Downsample_S16MSB_1c },
15756 { AUDIO_S16MSB, 1, 1, 0, SDL_Upsample_S16MSB_1c },
15757 { AUDIO_S16MSB, 2, 0, 0, SDL_Downsample_S16MSB_2c },
15758 { AUDIO_S16MSB, 2, 1, 0, SDL_Upsample_S16MSB_2c },
15759 { AUDIO_S16MSB, 4, 0, 0, SDL_Downsample_S16MSB_4c },
15760 { AUDIO_S16MSB, 4, 1, 0, SDL_Upsample_S16MSB_4c },
15761 { AUDIO_S16MSB, 6, 0, 0, SDL_Downsample_S16MSB_6c },
15762 { AUDIO_S16MSB, 6, 1, 0, SDL_Upsample_S16MSB_6c },
15763 { AUDIO_S16MSB, 8, 0, 0, SDL_Downsample_S16MSB_8c },
15764 { AUDIO_S16MSB, 8, 1, 0, SDL_Upsample_S16MSB_8c },
15765 { AUDIO_S32LSB, 1, 0, 0, SDL_Downsample_S32LSB_1c },
15766 { AUDIO_S32LSB, 1, 1, 0, SDL_Upsample_S32LSB_1c },
15767 { AUDIO_S32LSB, 2, 0, 0, SDL_Downsample_S32LSB_2c },
15768 { AUDIO_S32LSB, 2, 1, 0, SDL_Upsample_S32LSB_2c },
15769 { AUDIO_S32LSB, 4, 0, 0, SDL_Downsample_S32LSB_4c },
15770 { AUDIO_S32LSB, 4, 1, 0, SDL_Upsample_S32LSB_4c },
15771 { AUDIO_S32LSB, 6, 0, 0, SDL_Downsample_S32LSB_6c },
15772 { AUDIO_S32LSB, 6, 1, 0, SDL_Upsample_S32LSB_6c },
15773 { AUDIO_S32LSB, 8, 0, 0, SDL_Downsample_S32LSB_8c },
15774 { AUDIO_S32LSB, 8, 1, 0, SDL_Upsample_S32LSB_8c },
15775 { AUDIO_S32MSB, 1, 0, 0, SDL_Downsample_S32MSB_1c },
15776 { AUDIO_S32MSB, 1, 1, 0, SDL_Upsample_S32MSB_1c },
15777 { AUDIO_S32MSB, 2, 0, 0, SDL_Downsample_S32MSB_2c },
15778 { AUDIO_S32MSB, 2, 1, 0, SDL_Upsample_S32MSB_2c },
15779 { AUDIO_S32MSB, 4, 0, 0, SDL_Downsample_S32MSB_4c },
15780 { AUDIO_S32MSB, 4, 1, 0, SDL_Upsample_S32MSB_4c },
15781 { AUDIO_S32MSB, 6, 0, 0, SDL_Downsample_S32MSB_6c },
15782 { AUDIO_S32MSB, 6, 1, 0, SDL_Upsample_S32MSB_6c },
15783 { AUDIO_S32MSB, 8, 0, 0, SDL_Downsample_S32MSB_8c },
15784 { AUDIO_S32MSB, 8, 1, 0, SDL_Upsample_S32MSB_8c },
15785 { AUDIO_F32LSB, 1, 0, 0, SDL_Downsample_F32LSB_1c },
15786 { AUDIO_F32LSB, 1, 1, 0, SDL_Upsample_F32LSB_1c },
15787 { AUDIO_F32LSB, 2, 0, 0, SDL_Downsample_F32LSB_2c },
15788 { AUDIO_F32LSB, 2, 1, 0, SDL_Upsample_F32LSB_2c },
15789 { AUDIO_F32LSB, 4, 0, 0, SDL_Downsample_F32LSB_4c },
15790 { AUDIO_F32LSB, 4, 1, 0, SDL_Upsample_F32LSB_4c },
15791 { AUDIO_F32LSB, 6, 0, 0, SDL_Downsample_F32LSB_6c },
15792 { AUDIO_F32LSB, 6, 1, 0, SDL_Upsample_F32LSB_6c },
15793 { AUDIO_F32LSB, 8, 0, 0, SDL_Downsample_F32LSB_8c },
15794 { AUDIO_F32LSB, 8, 1, 0, SDL_Upsample_F32LSB_8c },
15795 { AUDIO_F32MSB, 1, 0, 0, SDL_Downsample_F32MSB_1c },
15796 { AUDIO_F32MSB, 1, 1, 0, SDL_Upsample_F32MSB_1c },
15797 { AUDIO_F32MSB, 2, 0, 0, SDL_Downsample_F32MSB_2c },
15798 { AUDIO_F32MSB, 2, 1, 0, SDL_Upsample_F32MSB_2c },
15799 { AUDIO_F32MSB, 4, 0, 0, SDL_Downsample_F32MSB_4c },
15800 { AUDIO_F32MSB, 4, 1, 0, SDL_Upsample_F32MSB_4c },
15801 { AUDIO_F32MSB, 6, 0, 0, SDL_Downsample_F32MSB_6c },
15802 { AUDIO_F32MSB, 6, 1, 0, SDL_Upsample_F32MSB_6c },
15803 { AUDIO_F32MSB, 8, 0, 0, SDL_Downsample_F32MSB_8c },
15804 { AUDIO_F32MSB, 8, 1, 0, SDL_Upsample_F32MSB_8c },
15805 #if !LESS_RESAMPLERS
15806 { AUDIO_U8, 1, 0, 2, SDL_Downsample_U8_1c_x2 },
15807 { AUDIO_U8, 1, 1, 2, SDL_Upsample_U8_1c_x2 },
15808 { AUDIO_U8, 1, 0, 4, SDL_Downsample_U8_1c_x4 },
15809 { AUDIO_U8, 1, 1, 4, SDL_Upsample_U8_1c_x4 },
15810 { AUDIO_U8, 2, 0, 2, SDL_Downsample_U8_2c_x2 },
15811 { AUDIO_U8, 2, 1, 2, SDL_Upsample_U8_2c_x2 },
15812 { AUDIO_U8, 2, 0, 4, SDL_Downsample_U8_2c_x4 },
15813 { AUDIO_U8, 2, 1, 4, SDL_Upsample_U8_2c_x4 },
15814 { AUDIO_U8, 4, 0, 2, SDL_Downsample_U8_4c_x2 },
15815 { AUDIO_U8, 4, 1, 2, SDL_Upsample_U8_4c_x2 },
15816 { AUDIO_U8, 4, 0, 4, SDL_Downsample_U8_4c_x4 },
15817 { AUDIO_U8, 4, 1, 4, SDL_Upsample_U8_4c_x4 },
15818 { AUDIO_U8, 6, 0, 2, SDL_Downsample_U8_6c_x2 },
15819 { AUDIO_U8, 6, 1, 2, SDL_Upsample_U8_6c_x2 },
15820 { AUDIO_U8, 6, 0, 4, SDL_Downsample_U8_6c_x4 },
15821 { AUDIO_U8, 6, 1, 4, SDL_Upsample_U8_6c_x4 },
15822 { AUDIO_U8, 8, 0, 2, SDL_Downsample_U8_8c_x2 },
15823 { AUDIO_U8, 8, 1, 2, SDL_Upsample_U8_8c_x2 },
15824 { AUDIO_U8, 8, 0, 4, SDL_Downsample_U8_8c_x4 },
15825 { AUDIO_U8, 8, 1, 4, SDL_Upsample_U8_8c_x4 },
15826 { AUDIO_S8, 1, 0, 2, SDL_Downsample_S8_1c_x2 },
15827 { AUDIO_S8, 1, 1, 2, SDL_Upsample_S8_1c_x2 },
15828 { AUDIO_S8, 1, 0, 4, SDL_Downsample_S8_1c_x4 },
15829 { AUDIO_S8, 1, 1, 4, SDL_Upsample_S8_1c_x4 },
15830 { AUDIO_S8, 2, 0, 2, SDL_Downsample_S8_2c_x2 },
15831 { AUDIO_S8, 2, 1, 2, SDL_Upsample_S8_2c_x2 },
15832 { AUDIO_S8, 2, 0, 4, SDL_Downsample_S8_2c_x4 },
15833 { AUDIO_S8, 2, 1, 4, SDL_Upsample_S8_2c_x4 },
15834 { AUDIO_S8, 4, 0, 2, SDL_Downsample_S8_4c_x2 },
15835 { AUDIO_S8, 4, 1, 2, SDL_Upsample_S8_4c_x2 },
15836 { AUDIO_S8, 4, 0, 4, SDL_Downsample_S8_4c_x4 },
15837 { AUDIO_S8, 4, 1, 4, SDL_Upsample_S8_4c_x4 },
15838 { AUDIO_S8, 6, 0, 2, SDL_Downsample_S8_6c_x2 },
15839 { AUDIO_S8, 6, 1, 2, SDL_Upsample_S8_6c_x2 },
15840 { AUDIO_S8, 6, 0, 4, SDL_Downsample_S8_6c_x4 },
15841 { AUDIO_S8, 6, 1, 4, SDL_Upsample_S8_6c_x4 },
15842 { AUDIO_S8, 8, 0, 2, SDL_Downsample_S8_8c_x2 },
15843 { AUDIO_S8, 8, 1, 2, SDL_Upsample_S8_8c_x2 },
15844 { AUDIO_S8, 8, 0, 4, SDL_Downsample_S8_8c_x4 },
15845 { AUDIO_S8, 8, 1, 4, SDL_Upsample_S8_8c_x4 },
15846 { AUDIO_U16LSB, 1, 0, 2, SDL_Downsample_U16LSB_1c_x2 },
15847 { AUDIO_U16LSB, 1, 1, 2, SDL_Upsample_U16LSB_1c_x2 },
15848 { AUDIO_U16LSB, 1, 0, 4, SDL_Downsample_U16LSB_1c_x4 },
15849 { AUDIO_U16LSB, 1, 1, 4, SDL_Upsample_U16LSB_1c_x4 },
15850 { AUDIO_U16LSB, 2, 0, 2, SDL_Downsample_U16LSB_2c_x2 },
15851 { AUDIO_U16LSB, 2, 1, 2, SDL_Upsample_U16LSB_2c_x2 },
15852 { AUDIO_U16LSB, 2, 0, 4, SDL_Downsample_U16LSB_2c_x4 },
15853 { AUDIO_U16LSB, 2, 1, 4, SDL_Upsample_U16LSB_2c_x4 },
15854 { AUDIO_U16LSB, 4, 0, 2, SDL_Downsample_U16LSB_4c_x2 },
15855 { AUDIO_U16LSB, 4, 1, 2, SDL_Upsample_U16LSB_4c_x2 },
15856 { AUDIO_U16LSB, 4, 0, 4, SDL_Downsample_U16LSB_4c_x4 },
15857 { AUDIO_U16LSB, 4, 1, 4, SDL_Upsample_U16LSB_4c_x4 },
15858 { AUDIO_U16LSB, 6, 0, 2, SDL_Downsample_U16LSB_6c_x2 },
15859 { AUDIO_U16LSB, 6, 1, 2, SDL_Upsample_U16LSB_6c_x2 },
15860 { AUDIO_U16LSB, 6, 0, 4, SDL_Downsample_U16LSB_6c_x4 },
15861 { AUDIO_U16LSB, 6, 1, 4, SDL_Upsample_U16LSB_6c_x4 },
15862 { AUDIO_U16LSB, 8, 0, 2, SDL_Downsample_U16LSB_8c_x2 },
15863 { AUDIO_U16LSB, 8, 1, 2, SDL_Upsample_U16LSB_8c_x2 },
15864 { AUDIO_U16LSB, 8, 0, 4, SDL_Downsample_U16LSB_8c_x4 },
15865 { AUDIO_U16LSB, 8, 1, 4, SDL_Upsample_U16LSB_8c_x4 },
15866 { AUDIO_S16LSB, 1, 0, 2, SDL_Downsample_S16LSB_1c_x2 },
15867 { AUDIO_S16LSB, 1, 1, 2, SDL_Upsample_S16LSB_1c_x2 },
15868 { AUDIO_S16LSB, 1, 0, 4, SDL_Downsample_S16LSB_1c_x4 },
15869 { AUDIO_S16LSB, 1, 1, 4, SDL_Upsample_S16LSB_1c_x4 },
15870 { AUDIO_S16LSB, 2, 0, 2, SDL_Downsample_S16LSB_2c_x2 },
15871 { AUDIO_S16LSB, 2, 1, 2, SDL_Upsample_S16LSB_2c_x2 },
15872 { AUDIO_S16LSB, 2, 0, 4, SDL_Downsample_S16LSB_2c_x4 },
15873 { AUDIO_S16LSB, 2, 1, 4, SDL_Upsample_S16LSB_2c_x4 },
15874 { AUDIO_S16LSB, 4, 0, 2, SDL_Downsample_S16LSB_4c_x2 },
15875 { AUDIO_S16LSB, 4, 1, 2, SDL_Upsample_S16LSB_4c_x2 },
15876 { AUDIO_S16LSB, 4, 0, 4, SDL_Downsample_S16LSB_4c_x4 },
15877 { AUDIO_S16LSB, 4, 1, 4, SDL_Upsample_S16LSB_4c_x4 },
15878 { AUDIO_S16LSB, 6, 0, 2, SDL_Downsample_S16LSB_6c_x2 },
15879 { AUDIO_S16LSB, 6, 1, 2, SDL_Upsample_S16LSB_6c_x2 },
15880 { AUDIO_S16LSB, 6, 0, 4, SDL_Downsample_S16LSB_6c_x4 },
15881 { AUDIO_S16LSB, 6, 1, 4, SDL_Upsample_S16LSB_6c_x4 },
15882 { AUDIO_S16LSB, 8, 0, 2, SDL_Downsample_S16LSB_8c_x2 },
15883 { AUDIO_S16LSB, 8, 1, 2, SDL_Upsample_S16LSB_8c_x2 },
15884 { AUDIO_S16LSB, 8, 0, 4, SDL_Downsample_S16LSB_8c_x4 },
15885 { AUDIO_S16LSB, 8, 1, 4, SDL_Upsample_S16LSB_8c_x4 },
15886 { AUDIO_U16MSB, 1, 0, 2, SDL_Downsample_U16MSB_1c_x2 },
15887 { AUDIO_U16MSB, 1, 1, 2, SDL_Upsample_U16MSB_1c_x2 },
15888 { AUDIO_U16MSB, 1, 0, 4, SDL_Downsample_U16MSB_1c_x4 },
15889 { AUDIO_U16MSB, 1, 1, 4, SDL_Upsample_U16MSB_1c_x4 },
15890 { AUDIO_U16MSB, 2, 0, 2, SDL_Downsample_U16MSB_2c_x2 },
15891 { AUDIO_U16MSB, 2, 1, 2, SDL_Upsample_U16MSB_2c_x2 },
15892 { AUDIO_U16MSB, 2, 0, 4, SDL_Downsample_U16MSB_2c_x4 },
15893 { AUDIO_U16MSB, 2, 1, 4, SDL_Upsample_U16MSB_2c_x4 },
15894 { AUDIO_U16MSB, 4, 0, 2, SDL_Downsample_U16MSB_4c_x2 },
15895 { AUDIO_U16MSB, 4, 1, 2, SDL_Upsample_U16MSB_4c_x2 },
15896 { AUDIO_U16MSB, 4, 0, 4, SDL_Downsample_U16MSB_4c_x4 },
15897 { AUDIO_U16MSB, 4, 1, 4, SDL_Upsample_U16MSB_4c_x4 },
15898 { AUDIO_U16MSB, 6, 0, 2, SDL_Downsample_U16MSB_6c_x2 },
15899 { AUDIO_U16MSB, 6, 1, 2, SDL_Upsample_U16MSB_6c_x2 },
15900 { AUDIO_U16MSB, 6, 0, 4, SDL_Downsample_U16MSB_6c_x4 },
15901 { AUDIO_U16MSB, 6, 1, 4, SDL_Upsample_U16MSB_6c_x4 },
15902 { AUDIO_U16MSB, 8, 0, 2, SDL_Downsample_U16MSB_8c_x2 },
15903 { AUDIO_U16MSB, 8, 1, 2, SDL_Upsample_U16MSB_8c_x2 },
15904 { AUDIO_U16MSB, 8, 0, 4, SDL_Downsample_U16MSB_8c_x4 },
15905 { AUDIO_U16MSB, 8, 1, 4, SDL_Upsample_U16MSB_8c_x4 },
15906 { AUDIO_S16MSB, 1, 0, 2, SDL_Downsample_S16MSB_1c_x2 },
15907 { AUDIO_S16MSB, 1, 1, 2, SDL_Upsample_S16MSB_1c_x2 },
15908 { AUDIO_S16MSB, 1, 0, 4, SDL_Downsample_S16MSB_1c_x4 },
15909 { AUDIO_S16MSB, 1, 1, 4, SDL_Upsample_S16MSB_1c_x4 },
15910 { AUDIO_S16MSB, 2, 0, 2, SDL_Downsample_S16MSB_2c_x2 },
15911 { AUDIO_S16MSB, 2, 1, 2, SDL_Upsample_S16MSB_2c_x2 },
15912 { AUDIO_S16MSB, 2, 0, 4, SDL_Downsample_S16MSB_2c_x4 },
15913 { AUDIO_S16MSB, 2, 1, 4, SDL_Upsample_S16MSB_2c_x4 },
15914 { AUDIO_S16MSB, 4, 0, 2, SDL_Downsample_S16MSB_4c_x2 },
15915 { AUDIO_S16MSB, 4, 1, 2, SDL_Upsample_S16MSB_4c_x2 },
15916 { AUDIO_S16MSB, 4, 0, 4, SDL_Downsample_S16MSB_4c_x4 },
15917 { AUDIO_S16MSB, 4, 1, 4, SDL_Upsample_S16MSB_4c_x4 },
15918 { AUDIO_S16MSB, 6, 0, 2, SDL_Downsample_S16MSB_6c_x2 },
15919 { AUDIO_S16MSB, 6, 1, 2, SDL_Upsample_S16MSB_6c_x2 },
15920 { AUDIO_S16MSB, 6, 0, 4, SDL_Downsample_S16MSB_6c_x4 },
15921 { AUDIO_S16MSB, 6, 1, 4, SDL_Upsample_S16MSB_6c_x4 },
15922 { AUDIO_S16MSB, 8, 0, 2, SDL_Downsample_S16MSB_8c_x2 },
15923 { AUDIO_S16MSB, 8, 1, 2, SDL_Upsample_S16MSB_8c_x2 },
15924 { AUDIO_S16MSB, 8, 0, 4, SDL_Downsample_S16MSB_8c_x4 },
15925 { AUDIO_S16MSB, 8, 1, 4, SDL_Upsample_S16MSB_8c_x4 },
15926 { AUDIO_S32LSB, 1, 0, 2, SDL_Downsample_S32LSB_1c_x2 },
15927 { AUDIO_S32LSB, 1, 1, 2, SDL_Upsample_S32LSB_1c_x2 },
15928 { AUDIO_S32LSB, 1, 0, 4, SDL_Downsample_S32LSB_1c_x4 },
15929 { AUDIO_S32LSB, 1, 1, 4, SDL_Upsample_S32LSB_1c_x4 },
15930 { AUDIO_S32LSB, 2, 0, 2, SDL_Downsample_S32LSB_2c_x2 },
15931 { AUDIO_S32LSB, 2, 1, 2, SDL_Upsample_S32LSB_2c_x2 },
15932 { AUDIO_S32LSB, 2, 0, 4, SDL_Downsample_S32LSB_2c_x4 },
15933 { AUDIO_S32LSB, 2, 1, 4, SDL_Upsample_S32LSB_2c_x4 },
15934 { AUDIO_S32LSB, 4, 0, 2, SDL_Downsample_S32LSB_4c_x2 },
15935 { AUDIO_S32LSB, 4, 1, 2, SDL_Upsample_S32LSB_4c_x2 },
15936 { AUDIO_S32LSB, 4, 0, 4, SDL_Downsample_S32LSB_4c_x4 },
15937 { AUDIO_S32LSB, 4, 1, 4, SDL_Upsample_S32LSB_4c_x4 },
15938 { AUDIO_S32LSB, 6, 0, 2, SDL_Downsample_S32LSB_6c_x2 },
15939 { AUDIO_S32LSB, 6, 1, 2, SDL_Upsample_S32LSB_6c_x2 },
15940 { AUDIO_S32LSB, 6, 0, 4, SDL_Downsample_S32LSB_6c_x4 },
15941 { AUDIO_S32LSB, 6, 1, 4, SDL_Upsample_S32LSB_6c_x4 },
15942 { AUDIO_S32LSB, 8, 0, 2, SDL_Downsample_S32LSB_8c_x2 },
15943 { AUDIO_S32LSB, 8, 1, 2, SDL_Upsample_S32LSB_8c_x2 },
15944 { AUDIO_S32LSB, 8, 0, 4, SDL_Downsample_S32LSB_8c_x4 },
15945 { AUDIO_S32LSB, 8, 1, 4, SDL_Upsample_S32LSB_8c_x4 },
15946 { AUDIO_S32MSB, 1, 0, 2, SDL_Downsample_S32MSB_1c_x2 },
15947 { AUDIO_S32MSB, 1, 1, 2, SDL_Upsample_S32MSB_1c_x2 },
15948 { AUDIO_S32MSB, 1, 0, 4, SDL_Downsample_S32MSB_1c_x4 },
15949 { AUDIO_S32MSB, 1, 1, 4, SDL_Upsample_S32MSB_1c_x4 },
15950 { AUDIO_S32MSB, 2, 0, 2, SDL_Downsample_S32MSB_2c_x2 },
15951 { AUDIO_S32MSB, 2, 1, 2, SDL_Upsample_S32MSB_2c_x2 },
15952 { AUDIO_S32MSB, 2, 0, 4, SDL_Downsample_S32MSB_2c_x4 },
15953 { AUDIO_S32MSB, 2, 1, 4, SDL_Upsample_S32MSB_2c_x4 },
15954 { AUDIO_S32MSB, 4, 0, 2, SDL_Downsample_S32MSB_4c_x2 },
15955 { AUDIO_S32MSB, 4, 1, 2, SDL_Upsample_S32MSB_4c_x2 },
15956 { AUDIO_S32MSB, 4, 0, 4, SDL_Downsample_S32MSB_4c_x4 },
15957 { AUDIO_S32MSB, 4, 1, 4, SDL_Upsample_S32MSB_4c_x4 },
15958 { AUDIO_S32MSB, 6, 0, 2, SDL_Downsample_S32MSB_6c_x2 },
15959 { AUDIO_S32MSB, 6, 1, 2, SDL_Upsample_S32MSB_6c_x2 },
15960 { AUDIO_S32MSB, 6, 0, 4, SDL_Downsample_S32MSB_6c_x4 },
15961 { AUDIO_S32MSB, 6, 1, 4, SDL_Upsample_S32MSB_6c_x4 },
15962 { AUDIO_S32MSB, 8, 0, 2, SDL_Downsample_S32MSB_8c_x2 },
15963 { AUDIO_S32MSB, 8, 1, 2, SDL_Upsample_S32MSB_8c_x2 },
15964 { AUDIO_S32MSB, 8, 0, 4, SDL_Downsample_S32MSB_8c_x4 },
15965 { AUDIO_S32MSB, 8, 1, 4, SDL_Upsample_S32MSB_8c_x4 },
15966 { AUDIO_F32LSB, 1, 0, 2, SDL_Downsample_F32LSB_1c_x2 },
15967 { AUDIO_F32LSB, 1, 1, 2, SDL_Upsample_F32LSB_1c_x2 },
15968 { AUDIO_F32LSB, 1, 0, 4, SDL_Downsample_F32LSB_1c_x4 },
15969 { AUDIO_F32LSB, 1, 1, 4, SDL_Upsample_F32LSB_1c_x4 },
15970 { AUDIO_F32LSB, 2, 0, 2, SDL_Downsample_F32LSB_2c_x2 },
15971 { AUDIO_F32LSB, 2, 1, 2, SDL_Upsample_F32LSB_2c_x2 },
15972 { AUDIO_F32LSB, 2, 0, 4, SDL_Downsample_F32LSB_2c_x4 },
15973 { AUDIO_F32LSB, 2, 1, 4, SDL_Upsample_F32LSB_2c_x4 },
15974 { AUDIO_F32LSB, 4, 0, 2, SDL_Downsample_F32LSB_4c_x2 },
15975 { AUDIO_F32LSB, 4, 1, 2, SDL_Upsample_F32LSB_4c_x2 },
15976 { AUDIO_F32LSB, 4, 0, 4, SDL_Downsample_F32LSB_4c_x4 },
15977 { AUDIO_F32LSB, 4, 1, 4, SDL_Upsample_F32LSB_4c_x4 },
15978 { AUDIO_F32LSB, 6, 0, 2, SDL_Downsample_F32LSB_6c_x2 },
15979 { AUDIO_F32LSB, 6, 1, 2, SDL_Upsample_F32LSB_6c_x2 },
15980 { AUDIO_F32LSB, 6, 0, 4, SDL_Downsample_F32LSB_6c_x4 },
15981 { AUDIO_F32LSB, 6, 1, 4, SDL_Upsample_F32LSB_6c_x4 },
15982 { AUDIO_F32LSB, 8, 0, 2, SDL_Downsample_F32LSB_8c_x2 },
15983 { AUDIO_F32LSB, 8, 1, 2, SDL_Upsample_F32LSB_8c_x2 },
15984 { AUDIO_F32LSB, 8, 0, 4, SDL_Downsample_F32LSB_8c_x4 },
15985 { AUDIO_F32LSB, 8, 1, 4, SDL_Upsample_F32LSB_8c_x4 },
15986 { AUDIO_F32MSB, 1, 0, 2, SDL_Downsample_F32MSB_1c_x2 },
15987 { AUDIO_F32MSB, 1, 1, 2, SDL_Upsample_F32MSB_1c_x2 },
15988 { AUDIO_F32MSB, 1, 0, 4, SDL_Downsample_F32MSB_1c_x4 },
15989 { AUDIO_F32MSB, 1, 1, 4, SDL_Upsample_F32MSB_1c_x4 },
15990 { AUDIO_F32MSB, 2, 0, 2, SDL_Downsample_F32MSB_2c_x2 },
15991 { AUDIO_F32MSB, 2, 1, 2, SDL_Upsample_F32MSB_2c_x2 },
15992 { AUDIO_F32MSB, 2, 0, 4, SDL_Downsample_F32MSB_2c_x4 },
15993 { AUDIO_F32MSB, 2, 1, 4, SDL_Upsample_F32MSB_2c_x4 },
15994 { AUDIO_F32MSB, 4, 0, 2, SDL_Downsample_F32MSB_4c_x2 },
15995 { AUDIO_F32MSB, 4, 1, 2, SDL_Upsample_F32MSB_4c_x2 },
15996 { AUDIO_F32MSB, 4, 0, 4, SDL_Downsample_F32MSB_4c_x4 },
15997 { AUDIO_F32MSB, 4, 1, 4, SDL_Upsample_F32MSB_4c_x4 },
15998 { AUDIO_F32MSB, 6, 0, 2, SDL_Downsample_F32MSB_6c_x2 },
15999 { AUDIO_F32MSB, 6, 1, 2, SDL_Upsample_F32MSB_6c_x2 },
16000 { AUDIO_F32MSB, 6, 0, 4, SDL_Downsample_F32MSB_6c_x4 },
16001 { AUDIO_F32MSB, 6, 1, 4, SDL_Upsample_F32MSB_6c_x4 },
16002 { AUDIO_F32MSB, 8, 0, 2, SDL_Downsample_F32MSB_8c_x2 },
16003 { AUDIO_F32MSB, 8, 1, 2, SDL_Upsample_F32MSB_8c_x2 },
16004 { AUDIO_F32MSB, 8, 0, 4, SDL_Downsample_F32MSB_8c_x4 },
16005 { AUDIO_F32MSB, 8, 1, 4, SDL_Upsample_F32MSB_8c_x4 },
16006 #endif /* !LESS_RESAMPLERS */
16007 #endif /* !NO_RESAMPLERS */
16008 { 0, 0, 0, 0, NULL }
16009 };
16010
16011 /* 390 converters generated. */
16012
16013 /* *INDENT-ON* */
16014
16015 /* vi: set ts=4 sw=4 expandtab: */
SDL_Downsample_U16LSB_8c_x2
static void SDLCALL SDL_Downsample_U16LSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9493
SDL_Upsample_F32MSB_6c
static void SDLCALL SDL_Upsample_F32MSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6848
SDL_Downsample_U16LSB_1c_x4
static void SDLCALL SDL_Downsample_U16LSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8901
SDL_Downsample_U16MSB_8c_x4
static void SDLCALL SDL_Downsample_U16MSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11345
SDL_Upsample_U16LSB_8c_x4
static void SDLCALL SDL_Upsample_U16LSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9547
SDL_Upsample_S16MSB_2c_x4
static void SDLCALL SDL_Upsample_S16MSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11569
SDL_Upsample_S16LSB_4c_x2
static void SDLCALL SDL_Upsample_S16LSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9915
SDL_Upsample_U16LSB_4c_x4
static void SDLCALL SDL_Upsample_U16LSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9135
SDL_Upsample_S32MSB_1c_x2
static void SDLCALL SDL_Upsample_S32MSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13119
SDL_Upsample_S16MSB_8c_x4
static void SDLCALL SDL_Upsample_S16MSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12127
SDL_Downsample_F32LSB_2c
static void SDLCALL SDL_Downsample_F32LSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6237
SDL_Upsample_S8_6c_x2
static void SDLCALL SDL_Upsample_S8_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8363
SDL_Downsample_S16LSB_4c_x4
static void SDLCALL SDL_Downsample_S16LSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10045
SDL_Convert_S16MSB_to_U16LSB
static void SDLCALL SDL_Convert_S16MSB_to_U16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1176
SDL_Convert_U16MSB_to_U16LSB
static void SDLCALL SDL_Convert_U16MSB_to_U16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:963
SDL_Convert_S16LSB_to_S32LSB
static void SDLCALL SDL_Convert_S16LSB_to_S32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:819
val
GLuint const GLfloat * val
Definition: glew.h:2715
SDL_Upsample_U16LSB_1c_x2
static void SDLCALL SDL_Upsample_U16LSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8819
SDL_Upsample_F32MSB_8c_x2
static void SDLCALL SDL_Upsample_F32MSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15451
SDL_Downsample_U16MSB_8c
static void SDLCALL SDL_Downsample_U16MSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4629
SDL_Convert_U8_to_F32LSB
static void SDLCALL SDL_Convert_U8_to_F32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:226
SDL_Convert_F32LSB_to_U16LSB
static void SDLCALL SDL_Convert_F32LSB_to_U16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1815
SDL_Convert_U16MSB_to_F32MSB
static void SDLCALL SDL_Convert_U16MSB_to_F32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1104
SDL_Downsample_S16LSB_8c_x2
static void SDLCALL SDL_Downsample_S16LSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10353
SDL_Upsample_U16MSB_2c
static void SDLCALL SDL_Upsample_U16MSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4280
SDL_Upsample_U8_8c
static void SDLCALL SDL_Upsample_U8_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2642
SDL_SwapFloatBE
#define SDL_SwapFloatBE(X)
Definition: SDL_endian.h:218
SDL_Downsample_S32MSB_4c
static void SDLCALL SDL_Downsample_S32MSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5841
SDL_Convert_S32MSB_to_S32LSB
static void SDLCALL SDL_Convert_S32MSB_to_S32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1698
SDL_Downsample_S8_8c
static void SDLCALL SDL_Downsample_S8_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3189
SDL_Upsample_U8_4c_x4
static void SDLCALL SDL_Upsample_U8_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7415
SDL_Upsample_S8_2c
static void SDLCALL SDL_Upsample_S8_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2840
AUDIO_S32MSB
#define AUDIO_S32MSB
Definition: SDL_audio.h:104
SDL_Convert_S8_to_U16MSB
static void SDLCALL SDL_Convert_S8_to_U16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:345
SDL_Downsample_F32LSB_8c_x4
static void SDLCALL SDL_Downsample_F32LSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14785
Sint32
int32_t Sint32
A signed 32-bit integer type.
Definition: SDL_stdinc.h:141
SDL_Upsample_F32MSB_8c
static void SDLCALL SDL_Upsample_F32MSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6962
SDL_Convert_S32MSB_to_S16MSB
static void SDLCALL SDL_Convert_S32MSB_to_S16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1674
SDL_Upsample_S32MSB_4c_x2
static void SDLCALL SDL_Upsample_S32MSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13355
SDL_Upsample_S32MSB_4c
static void SDLCALL SDL_Upsample_S32MSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5794
SDL_Convert_F32MSB_to_S32LSB
static void SDLCALL SDL_Convert_F32MSB_to_S32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2124
SDL_Convert_U8_to_U16LSB
static void SDLCALL SDL_Convert_U8_to_U16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:82
SDL_Upsample_U8_8c_x2
static void SDLCALL SDL_Upsample_U8_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7711
SDL_Upsample_S16LSB_8c_x4
static void SDLCALL SDL_Upsample_S16LSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10407
SDL_Upsample_F32MSB_4c_x2
static void SDLCALL SDL_Upsample_F32MSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15075
SDL_Convert_S16MSB_to_S32MSB
static void SDLCALL SDL_Convert_S16MSB_to_S32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1269
SDL_Upsample_S16MSB_8c
static void SDLCALL SDL_Upsample_S16MSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5042
SDL_Downsample_U8_6c
static void SDLCALL SDL_Downsample_U8_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2585
SDL_Convert_F32LSB_to_S16LSB
static void SDLCALL SDL_Convert_F32LSB_to_S16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1839
NULL
#define NULL
Definition: ftobjs.h:61
SDL_Upsample_F32LSB_4c_x2
static void SDLCALL SDL_Upsample_F32LSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14215
SDL_Downsample_S32LSB_2c_x4
static void SDLCALL SDL_Downsample_S32LSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12465
SDL_Downsample_S32LSB_1c_x2
static void SDLCALL SDL_Downsample_S32LSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12286
SDL_Downsample_S32MSB_1c_x2
static void SDLCALL SDL_Downsample_S32MSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13146
SDL_Downsample_S16MSB_6c_x2
static void SDLCALL SDL_Downsample_S16MSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11855
AUDIO_U16LSB
#define AUDIO_U16LSB
Definition: SDL_audio.h:91
SDL_Downsample_F32LSB_6c_x2
static void SDLCALL SDL_Downsample_F32LSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14435
f
GLclampf f
Definition: glew.h:3390
SDL_AudioCVT::buf
Uint8 * buf
Definition: SDL_audio.h:203
SDL_Downsample_S32MSB_8c_x2
static void SDLCALL SDL_Downsample_S32MSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13793
SDL_Upsample_F32LSB_8c_x4
static void SDLCALL SDL_Upsample_F32LSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14707
SDL_Upsample_U16LSB_2c_x4
static void SDLCALL SDL_Upsample_U16LSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8989
SDL_Upsample_S8_8c_x2
static void SDLCALL SDL_Upsample_S8_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8571
SDL_Downsample_S8_6c
static void SDLCALL SDL_Downsample_S8_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3065
SDL_Convert_S32MSB_to_U8
static void SDLCALL SDL_Convert_S32MSB_to_U8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1554
SDL_Convert_U8_to_S32LSB
static void SDLCALL SDL_Convert_U8_to_S32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:178
SDL_Downsample_U16LSB_4c_x2
static void SDLCALL SDL_Downsample_U16LSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9097
SDL_Downsample_F32LSB_4c_x2
static void SDLCALL SDL_Downsample_F32LSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14257
SDL_Upsample_U16LSB_8c_x2
static void SDLCALL SDL_Upsample_U16LSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9431
SDL_Upsample_U16LSB_6c_x4
static void SDLCALL SDL_Upsample_U16LSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9321
SDL_Upsample_S16LSB_4c
static void SDLCALL SDL_Upsample_S16LSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3874
SDL_Downsample_F32LSB_2c_x4
static void SDLCALL SDL_Downsample_F32LSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14185
SDL_Upsample_S16MSB_1c_x4
static void SDLCALL SDL_Upsample_S16MSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11452
SDL_Downsample_S16MSB_6c
static void SDLCALL SDL_Downsample_S16MSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4985
SDL_AudioCVT::filter_index
int filter_index
Definition: SDL_audio.h:209
SDL_Upsample_F32LSB_2c_x2
static void SDLCALL SDL_Upsample_F32LSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14087
SDL_Upsample_U16MSB_6c_x4
static void SDLCALL SDL_Upsample_U16MSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11041
SDL_Convert_S16LSB_to_F32LSB
static void SDLCALL SDL_Convert_S16LSB_to_F32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:867
SDL_Upsample_S8_8c
static void SDLCALL SDL_Upsample_S8_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3122
SDL_Upsample_S8_4c_x4
static void SDLCALL SDL_Upsample_S8_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8275
SDL_Downsample_U16LSB_2c
static void SDLCALL SDL_Downsample_U16LSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3357
SDL_Downsample_S16LSB_2c_x2
static void SDLCALL SDL_Downsample_S16LSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9819
SDL_Upsample_S32MSB_1c
static void SDLCALL SDL_Upsample_S32MSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5656
SDL_Upsample_S16LSB_8c
static void SDLCALL SDL_Upsample_S16LSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4082
SDL_Downsample_U16LSB_4c_x4
static void SDLCALL SDL_Downsample_U16LSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9185
SDL_Upsample_F32LSB_1c
static void SDLCALL SDL_Upsample_F32LSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6136
SDL_Convert_U16LSB_to_S32LSB
static void SDLCALL SDL_Convert_U16LSB_to_S32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:606
SDL_Convert_F32MSB_to_S8
static void SDLCALL SDL_Convert_F32MSB_to_S8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2004
SDL_Downsample_S16LSB_4c
static void SDLCALL SDL_Downsample_S16LSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3921
SDL_Downsample_U8_8c
static void SDLCALL SDL_Downsample_U8_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2709
SDL_Upsample_S32LSB_8c_x4
static void SDLCALL SDL_Upsample_S32LSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12987
SDL_Upsample_S8_8c_x4
static void SDLCALL SDL_Upsample_S8_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8687
SDL_Convert_S32MSB_to_F32LSB
static void SDLCALL SDL_Convert_S32MSB_to_F32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1721
SDL_Downsample_F32MSB_4c
static void SDLCALL SDL_Downsample_F32MSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6801
SDL_Upsample_U16MSB_8c
static void SDLCALL SDL_Upsample_U16MSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4562
SDL_Upsample_F32MSB_1c_x4
static void SDLCALL SDL_Upsample_F32MSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14892
SDL_Upsample_S32MSB_6c_x4
static void SDLCALL SDL_Upsample_S32MSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13621
SDL_Upsample_F32LSB_4c
static void SDLCALL SDL_Upsample_F32LSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6274
SDL_Downsample_F32LSB_6c_x4
static void SDLCALL SDL_Downsample_F32LSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14545
SDL_Downsample_S32MSB_8c_x4
static void SDLCALL SDL_Downsample_S32MSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13925
SDL_Downsample_S16LSB_6c
static void SDLCALL SDL_Downsample_S16LSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4025
SDL_Upsample_S8_2c_x4
static void SDLCALL SDL_Upsample_S8_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8129
SDL_Convert_U16LSB_to_S32MSB
static void SDLCALL SDL_Convert_U16LSB_to_S32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:630
SDL_Downsample_S16MSB_4c_x2
static void SDLCALL SDL_Downsample_S16MSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11677
SDL_AudioFormat
Uint16 SDL_AudioFormat
Audio format flags.
Definition: SDL_audio.h:64
SDL_Upsample_F32MSB_8c_x4
static void SDLCALL SDL_Upsample_F32MSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15567
sdl_audio_type_filters
const SDL_AudioTypeFilters sdl_audio_type_filters[]
Definition: SDL_audiotypecvt.c:2195
SDL_Downsample_S32MSB_6c_x2
static void SDLCALL SDL_Downsample_S32MSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13575
SDL_Downsample_F32MSB_6c_x2
static void SDLCALL SDL_Downsample_F32MSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15295
SDL_Convert_S32LSB_to_S16LSB
static void SDLCALL SDL_Convert_S32LSB_to_S16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1413
SDL_Upsample_U8_2c_x2
static void SDLCALL SDL_Upsample_U8_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7207
SDL_SwapFloatLE
#define SDL_SwapFloatLE(X)
Definition: SDL_endian.h:214
SDL_Downsample_U16LSB_6c_x4
static void SDLCALL SDL_Downsample_U16LSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9385
SDL_Upsample_U16MSB_4c_x2
static void SDLCALL SDL_Upsample_U16MSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10775
SDL_Upsample_S32LSB_6c
static void SDLCALL SDL_Upsample_S32LSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5408
SDL_Convert_S8_to_S16LSB
static void SDLCALL SDL_Convert_S8_to_S16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:321
SDLCALL
#define SDLCALL
Definition: begin_code.h:72
SDL_Downsample_S8_6c_x4
static void SDLCALL SDL_Downsample_S8_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8525
SDL_Convert_S8_to_F32LSB
static void SDLCALL SDL_Convert_S8_to_F32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:441
SDL_Downsample_U16MSB_2c_x2
static void SDLCALL SDL_Downsample_U16MSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10679
SDL_Downsample_U16LSB_8c
static void SDLCALL SDL_Downsample_U16LSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3669
SDL_Convert_S16MSB_to_S8
static void SDLCALL SDL_Convert_S16MSB_to_S8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1152
SDL_Downsample_F32LSB_8c
static void SDLCALL SDL_Downsample_F32LSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6549
SDL_Downsample_S16LSB_6c_x4
static void SDLCALL SDL_Downsample_S16LSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10245
SDL_Convert_F32LSB_to_S8
static void SDLCALL SDL_Convert_F32LSB_to_S8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1791
SDL_Upsample_S16MSB_1c_x2
static void SDLCALL SDL_Upsample_S16MSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11399
SDL_Convert_U16MSB_to_U8
static void SDLCALL SDL_Convert_U16MSB_to_U8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:915
SDL_Downsample_S8_2c
static void SDLCALL SDL_Downsample_S8_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2877
SDL_Upsample_F32MSB_4c
static void SDLCALL SDL_Upsample_F32MSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6754
SDL_Downsample_U8_6c_x2
static void SDLCALL SDL_Downsample_U8_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7555
SDL_Downsample_S32LSB_1c_x4
static void SDLCALL SDL_Downsample_S32LSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12341
SDL_Upsample_S32MSB_6c_x2
static void SDLCALL SDL_Upsample_S32MSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13523
SDL_config.h
SDL_Downsample_U16MSB_2c_x4
static void SDLCALL SDL_Downsample_U16MSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10745
SDL_Convert_U8_to_U16MSB
static void SDLCALL SDL_Convert_U8_to_U16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:130
SDL_Downsample_U16LSB_6c_x2
static void SDLCALL SDL_Downsample_U16LSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9275
SDL_Downsample_U16MSB_2c
static void SDLCALL SDL_Downsample_U16MSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4317
SDL_SwapBE32
#define SDL_SwapBE32(X)
Definition: SDL_endian.h:216
SDL_Downsample_U16MSB_1c_x4
static void SDLCALL SDL_Downsample_U16MSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10621
SDL_Convert_S32MSB_to_F32MSB
static void SDLCALL SDL_Convert_S32MSB_to_F32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1744
SDL_SwapBE16
#define SDL_SwapBE16(X)
Definition: SDL_endian.h:215
SDL_Upsample_S8_2c_x2
static void SDLCALL SDL_Upsample_S8_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8067
SDL_Upsample_S16LSB_8c_x2
static void SDLCALL SDL_Upsample_S16LSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10291
SDL_Downsample_S32MSB_6c
static void SDLCALL SDL_Downsample_S32MSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5945
SDL_Downsample_F32MSB_1c_x2
static void SDLCALL SDL_Downsample_F32MSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14866
SDL_Convert_S16LSB_to_U16MSB
static void SDLCALL SDL_Convert_S16LSB_to_U16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:773
SDL_AudioCVT
Definition: SDL_audio.h:197
SDL_Convert_U16MSB_to_S16MSB
static void SDLCALL SDL_Convert_U16MSB_to_S16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1009
SDL_Downsample_S8_4c
static void SDLCALL SDL_Downsample_S8_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2961
SDL_Convert_F32LSB_to_U16MSB
static void SDLCALL SDL_Convert_F32LSB_to_U16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1863
SDL_Upsample_F32MSB_2c
static void SDLCALL SDL_Upsample_F32MSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6680
SDL_Convert_S32LSB_to_S16MSB
static void SDLCALL SDL_Convert_S32LSB_to_S16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1461
SDL_Upsample_S8_1c_x4
static void SDLCALL SDL_Upsample_S8_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8012
SDL_Upsample_F32LSB_8c
static void SDLCALL SDL_Upsample_F32LSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6482
SDL_Downsample_S16MSB_2c_x4
static void SDLCALL SDL_Downsample_S16MSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11605
SDL_Downsample_S16LSB_1c
static void SDLCALL SDL_Downsample_S16LSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3768
SDL_Convert_F32MSB_to_F32LSB
static void SDLCALL SDL_Convert_F32MSB_to_F32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2170
AUDIO_F32MSB
#define AUDIO_F32MSB
Definition: SDL_audio.h:113
SDL_AudioRateFilters
Definition: SDL_audio_c.h:45
target
EGLContext EGLenum target
Definition: eglext.h:87
SDL_Downsample_S32LSB_4c
static void SDLCALL SDL_Downsample_S32LSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5361
SDL_Downsample_S32MSB_6c_x4
static void SDLCALL SDL_Downsample_S32MSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13685
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:145
SDL_Upsample_F32MSB_1c
static void SDLCALL SDL_Upsample_F32MSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6616
SDL_Convert_U16LSB_to_U16MSB
static void SDLCALL SDL_Convert_U16LSB_to_U16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:560
SDL_Downsample_U16MSB_6c_x2
static void SDLCALL SDL_Downsample_U16MSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10995
SDL_Convert_U8_to_S32MSB
static void SDLCALL SDL_Convert_U8_to_S32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:202
SDL_Downsample_S32MSB_8c
static void SDLCALL SDL_Downsample_S32MSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6069
SDL_Downsample_U8_1c_x2
static void SDLCALL SDL_Downsample_U8_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7126
SDL_Convert_S8_to_U16LSB
static void SDLCALL SDL_Convert_S8_to_U16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:297
SDL_Upsample_F32LSB_6c_x2
static void SDLCALL SDL_Upsample_F32LSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14383
SDL_Downsample_U16LSB_1c
static void SDLCALL SDL_Downsample_U16LSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3288
AUDIO_U8
#define AUDIO_U8
Definition: SDL_audio.h:89
SDL_Upsample_U16LSB_4c
static void SDLCALL SDL_Upsample_U16LSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3394
SDL_Upsample_S8_6c_x4
static void SDLCALL SDL_Upsample_S8_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8461
SDL_Convert_S32LSB_to_U8
static void SDLCALL SDL_Convert_S32LSB_to_U8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1341
SDL_Downsample_S32MSB_1c_x4
static void SDLCALL SDL_Downsample_S32MSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13201
SDL_Upsample_U16LSB_6c
static void SDLCALL SDL_Upsample_U16LSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3488
SDL_Upsample_S16LSB_6c_x2
static void SDLCALL SDL_Upsample_S16LSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10083
SDL_Downsample_S32LSB_6c_x4
static void SDLCALL SDL_Downsample_S32LSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12825
SDL_Downsample_U8_2c_x4
static void SDLCALL SDL_Downsample_U8_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7305
SDL_Upsample_F32MSB_4c_x4
static void SDLCALL SDL_Upsample_F32MSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15155
SDL_Convert_S8_to_S32MSB
static void SDLCALL SDL_Convert_S8_to_S32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:417
SDL_Upsample_U16MSB_6c
static void SDLCALL SDL_Upsample_U16MSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4448
SDL_Upsample_S32LSB_2c_x2
static void SDLCALL SDL_Upsample_S32LSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12367
SDL_Downsample_U16LSB_8c_x4
static void SDLCALL SDL_Downsample_U16LSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9625
SDL_Downsample_U16MSB_4c_x4
static void SDLCALL SDL_Downsample_U16MSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10905
SDL_Convert_S16LSB_to_S32MSB
static void SDLCALL SDL_Convert_S16LSB_to_S32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:843
SDL_Downsample_U8_6c_x4
static void SDLCALL SDL_Downsample_U8_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7665
SDL_Convert_F32MSB_to_U16LSB
static void SDLCALL SDL_Convert_F32MSB_to_U16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2028
SDL_Upsample_F32LSB_1c_x2
static void SDLCALL SDL_Upsample_F32LSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13979
SDL_Downsample_U16LSB_6c
static void SDLCALL SDL_Downsample_U16LSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3545
dst
GLenum GLenum dst
Definition: glew.h:2396
SDL_Upsample_S32LSB_8c_x2
static void SDLCALL SDL_Upsample_S32LSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12871
int
int
Definition: SDL_systhread.c:37
SDL_Upsample_F32LSB_2c_x4
static void SDLCALL SDL_Upsample_F32LSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14149
SDL_AudioCVT::filters
SDL_AudioFilter filters[10]
Definition: SDL_audio.h:208
SDL_Upsample_S16MSB_1c
static void SDLCALL SDL_Upsample_S16MSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4696
SDL_Convert_S16MSB_to_U8
static void SDLCALL SDL_Convert_S16MSB_to_U8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1128
SDL_Downsample_S32LSB_4c_x2
static void SDLCALL SDL_Downsample_S32LSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12537
SDL_Convert_F32MSB_to_S16LSB
static void SDLCALL SDL_Convert_F32MSB_to_S16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2052
SDL_Upsample_S16MSB_6c
static void SDLCALL SDL_Upsample_S16MSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4928
SDL_audio_c.h
SDL_Downsample_U8_4c_x2
static void SDLCALL SDL_Downsample_U8_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7377
SDL_Convert_U8_to_S8
static void SDLCALL SDL_Convert_U8_to_S8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:59
SDL_Downsample_S32LSB_8c
static void SDLCALL SDL_Downsample_S32LSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5589
SDL_Convert_S16LSB_to_S8
static void SDLCALL SDL_Convert_S16LSB_to_S8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:726
SDL_Convert_S16LSB_to_S16MSB
static void SDLCALL SDL_Convert_S16LSB_to_S16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:796
SDL_Upsample_S16MSB_8c_x2
static void SDLCALL SDL_Upsample_S16MSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12011
SDL_Convert_S32MSB_to_S16LSB
static void SDLCALL SDL_Convert_S32MSB_to_S16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1626
SDL_Upsample_U8_8c_x4
static void SDLCALL SDL_Upsample_U8_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7827
SDL_Downsample_S32MSB_4c_x2
static void SDLCALL SDL_Downsample_S32MSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13397
SDL_Upsample_F32MSB_6c_x4
static void SDLCALL SDL_Upsample_F32MSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15341
SDL_Downsample_F32MSB_6c
static void SDLCALL SDL_Downsample_F32MSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6905
SDL_Upsample_F32LSB_8c_x2
static void SDLCALL SDL_Upsample_F32LSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14591
SDL_SwapLE32
#define SDL_SwapLE32(X)
Definition: SDL_endian.h:212
AUDIO_F32LSB
#define AUDIO_F32LSB
Definition: SDL_audio.h:112
SDL_Convert_S8_to_S16MSB
static void SDLCALL SDL_Convert_S8_to_S16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:369
SDL_Upsample_U8_4c
static void SDLCALL SDL_Upsample_U8_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2434
SDL_Downsample_S16MSB_8c
static void SDLCALL SDL_Downsample_S16MSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5109
SDL_Upsample_S32LSB_2c_x4
static void SDLCALL SDL_Upsample_S32LSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12429
SDL_Convert_F32MSB_to_U16MSB
static void SDLCALL SDL_Convert_F32MSB_to_U16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2076
SDL_Downsample_F32LSB_4c
static void SDLCALL SDL_Downsample_F32LSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6321
SDL_Downsample_U8_8c_x4
static void SDLCALL SDL_Downsample_U8_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7905
SDL_Upsample_S32LSB_6c_x2
static void SDLCALL SDL_Upsample_S32LSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12663
DIVBY32767
#define DIVBY32767
Definition: SDL_audiotypecvt.c:53
SDL_Upsample_S16LSB_2c
static void SDLCALL SDL_Upsample_S16LSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3800
SDL_Convert_S16MSB_to_F32LSB
static void SDLCALL SDL_Convert_S16MSB_to_F32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1293
SDL_Convert_S8_to_U8
static void SDLCALL SDL_Convert_S8_to_U8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:274
SDL_Downsample_F32MSB_8c
static void SDLCALL SDL_Downsample_F32MSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7029
SDL_Convert_F32LSB_to_S32LSB
static void SDLCALL SDL_Convert_F32LSB_to_S32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1911
SDL_Downsample_U8_4c
static void SDLCALL SDL_Downsample_U8_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2481
SDL_Upsample_S32MSB_8c_x2
static void SDLCALL SDL_Upsample_S32MSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13731
SDL_Convert_S16LSB_to_U8
static void SDLCALL SDL_Convert_S16LSB_to_U8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:702
SDL_Downsample_S32LSB_6c_x2
static void SDLCALL SDL_Downsample_S32LSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12715
SDL_Upsample_U8_1c_x2
static void SDLCALL SDL_Upsample_U8_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7099
SDL_Upsample_U16MSB_4c_x4
static void SDLCALL SDL_Upsample_U16MSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10855
SDL_Downsample_S8_1c
static void SDLCALL SDL_Downsample_S8_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2808
SDL_Convert_S32LSB_to_S32MSB
static void SDLCALL SDL_Convert_S32LSB_to_S32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1485
SDL_Downsample_F32LSB_6c
static void SDLCALL SDL_Downsample_F32LSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6425
SDL_Upsample_F32MSB_2c_x4
static void SDLCALL SDL_Upsample_F32MSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15009
SDL_Upsample_U16MSB_1c
static void SDLCALL SDL_Upsample_U16MSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4216
SDL_Upsample_S16MSB_2c
static void SDLCALL SDL_Upsample_S16MSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4760
AUDIO_S32LSB
#define AUDIO_S32LSB
Definition: SDL_audio.h:103
format
GLint GLenum GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl2ext.h:845
DIVBY2147483647
#define DIVBY2147483647
Definition: SDL_audiotypecvt.c:54
SDL_Convert_S32MSB_to_S8
static void SDLCALL SDL_Convert_S32MSB_to_S8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1578
SDL_Upsample_S32LSB_1c_x4
static void SDLCALL SDL_Upsample_S32LSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12312
SDL_Downsample_U16MSB_6c_x4
static void SDLCALL SDL_Downsample_U16MSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11105
SDL_Downsample_S8_4c_x2
static void SDLCALL SDL_Downsample_S8_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8237
SDL_Upsample_S32LSB_1c_x2
static void SDLCALL SDL_Upsample_S32LSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12259
SDL_Convert_S32MSB_to_U16LSB
static void SDLCALL SDL_Convert_S32MSB_to_U16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1602
SDL_Upsample_S16LSB_4c_x4
static void SDLCALL SDL_Upsample_S16LSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9995
SDL_Downsample_F32LSB_1c
static void SDLCALL SDL_Downsample_F32LSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6168
SDL_Upsample_U8_6c_x2
static void SDLCALL SDL_Upsample_U8_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7503
SDL_Convert_F32LSB_to_U8
static void SDLCALL SDL_Convert_F32LSB_to_U8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1767
SDL_Downsample_F32MSB_8c_x4
static void SDLCALL SDL_Downsample_F32MSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15645
SDL_Upsample_S16MSB_2c_x2
static void SDLCALL SDL_Upsample_S16MSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11507
SDL_Downsample_F32LSB_8c_x2
static void SDLCALL SDL_Downsample_F32LSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14653
SDL_Upsample_F32MSB_6c_x2
static void SDLCALL SDL_Upsample_F32MSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15243
SDL_Convert_F32MSB_to_S16MSB
static void SDLCALL SDL_Convert_F32MSB_to_S16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2100
SDL_Convert_S16MSB_to_U16MSB
static void SDLCALL SDL_Convert_S16MSB_to_U16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1222
SDL_Upsample_U8_1c
static void SDLCALL SDL_Upsample_U8_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2296
SDL_Upsample_U16MSB_2c_x4
static void SDLCALL SDL_Upsample_U16MSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10709
DIVBY127
#define DIVBY127
Definition: SDL_audiotypecvt.c:52
SDL_Convert_F32LSB_to_S16MSB
static void SDLCALL SDL_Convert_F32LSB_to_S16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1887
SDL_Upsample_F32MSB_1c_x2
static void SDLCALL SDL_Upsample_F32MSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14839
SDL_Downsample_S16MSB_2c_x2
static void SDLCALL SDL_Downsample_S16MSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11539
SDL_Convert_F32LSB_to_S32MSB
static void SDLCALL SDL_Convert_F32LSB_to_S32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1934
SDL_Convert_U16MSB_to_S16LSB
static void SDLCALL SDL_Convert_U16MSB_to_S16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:986
SDL_Downsample_S16MSB_6c_x4
static void SDLCALL SDL_Downsample_S16MSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11965
SDL_Convert_U16MSB_to_F32LSB
static void SDLCALL SDL_Convert_U16MSB_to_F32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1080
SDL_Upsample_S16LSB_1c
static void SDLCALL SDL_Upsample_S16LSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3736
SDL_Upsample_S32MSB_2c_x4
static void SDLCALL SDL_Upsample_S32MSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13289
SDL_Downsample_U16MSB_8c_x2
static void SDLCALL SDL_Downsample_U16MSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11213
SDL_Convert_U16LSB_to_U8
static void SDLCALL SDL_Convert_U16LSB_to_U8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:489
SDL_Downsample_S16LSB_4c_x2
static void SDLCALL SDL_Downsample_S16LSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9957
SDL_Downsample_S8_8c_x2
static void SDLCALL SDL_Downsample_S8_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8633
SDL_Upsample_S32LSB_4c
static void SDLCALL SDL_Upsample_S32LSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5314
SDL_Downsample_S32MSB_1c
static void SDLCALL SDL_Downsample_S32MSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5688
SDL_Upsample_S32LSB_1c
static void SDLCALL SDL_Upsample_S32LSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5176
SDL_Downsample_S32LSB_4c_x4
static void SDLCALL SDL_Downsample_S32LSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12625
SDL_Downsample_U16LSB_2c_x4
static void SDLCALL SDL_Downsample_U16LSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9025
SDL_Downsample_F32MSB_1c
static void SDLCALL SDL_Downsample_F32MSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6648
SDL_Upsample_U16LSB_4c_x2
static void SDLCALL SDL_Upsample_U16LSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9055
SDL_Upsample_S32MSB_8c_x4
static void SDLCALL SDL_Upsample_S32MSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13847
SDL_Upsample_U16MSB_4c
static void SDLCALL SDL_Upsample_U16MSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4354
SDL_AudioCVT::len_cvt
int len_cvt
Definition: SDL_audio.h:205
SDL_Downsample_U16LSB_2c_x2
static void SDLCALL SDL_Downsample_U16LSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8959
SDL_Downsample_U16MSB_1c_x2
static void SDLCALL SDL_Downsample_U16MSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10566
SDL_Convert_U8_to_S16LSB
static void SDLCALL SDL_Convert_U8_to_S16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:106
SDL_Downsample_S32LSB_1c
static void SDLCALL SDL_Downsample_S32LSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5208
SDL_Upsample_F32LSB_1c_x4
static void SDLCALL SDL_Upsample_F32LSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14032
sizeof
sizeof(FT_AutofitterRec)
SDL_Convert_S16LSB_to_U16LSB
static void SDLCALL SDL_Convert_S16LSB_to_U16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:750
SDL_Convert_S8_to_S32LSB
static void SDLCALL SDL_Convert_S8_to_S32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:393
SDL_Downsample_U16LSB_4c
static void SDLCALL SDL_Downsample_U16LSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3441
SDL_Upsample_S16LSB_1c_x2
static void SDLCALL SDL_Upsample_S16LSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9679
SDL_Upsample_F32LSB_6c_x4
static void SDLCALL SDL_Upsample_F32LSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14481
SDL_Upsample_U8_6c_x4
static void SDLCALL SDL_Upsample_U8_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7601
SDL_Downsample_F32LSB_2c_x2
static void SDLCALL SDL_Downsample_F32LSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14119
SDL_Downsample_U16MSB_4c
static void SDLCALL SDL_Downsample_U16MSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4401
SDL_Downsample_S32MSB_4c_x4
static void SDLCALL SDL_Downsample_S32MSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13485
SDL_Downsample_S32LSB_8c_x4
static void SDLCALL SDL_Downsample_S32LSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13065
SDL_Convert_S16LSB_to_F32MSB
static void SDLCALL SDL_Convert_S16LSB_to_F32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:891
SDL_Upsample_S32MSB_1c_x4
static void SDLCALL SDL_Upsample_S32MSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13172
SDL_Upsample_S16LSB_2c_x2
static void SDLCALL SDL_Upsample_S16LSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9787
SDL_Upsample_S16MSB_4c_x2
static void SDLCALL SDL_Upsample_S16MSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11635
SDL_Upsample_U8_4c_x2
static void SDLCALL SDL_Upsample_U8_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7335
SDL_Convert_S32MSB_to_U16MSB
static void SDLCALL SDL_Convert_S32MSB_to_U16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1650
SDL_Upsample_U16LSB_1c
static void SDLCALL SDL_Upsample_U16LSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3256
SDL_Upsample_S16LSB_2c_x4
static void SDLCALL SDL_Upsample_S16LSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9849
SDL_Downsample_U8_4c_x4
static void SDLCALL SDL_Downsample_U8_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7465
SDL_Upsample_S16MSB_4c
static void SDLCALL SDL_Upsample_S16MSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4834
SDL_Convert_S16MSB_to_F32MSB
static void SDLCALL SDL_Convert_S16MSB_to_F32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1317
SDL_Upsample_U16MSB_2c_x2
static void SDLCALL SDL_Upsample_U16MSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10647
SDL_Convert_U16LSB_to_F32MSB
static void SDLCALL SDL_Convert_U16LSB_to_F32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:678
SDL_Upsample_U16LSB_8c
static void SDLCALL SDL_Upsample_U16LSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3602
SDL_Convert_S8_to_F32MSB
static void SDLCALL SDL_Convert_S8_to_F32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:465
SDL_Upsample_S32MSB_6c
static void SDLCALL SDL_Upsample_S32MSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5888
SDL_Convert_S32LSB_to_U16LSB
static void SDLCALL SDL_Convert_S32LSB_to_U16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1389
SDL_Upsample_S8_4c_x2
static void SDLCALL SDL_Upsample_S8_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8195
SDL_Downsample_S32MSB_2c_x2
static void SDLCALL SDL_Downsample_S32MSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13259
SDL_Downsample_S16LSB_8c_x4
static void SDLCALL SDL_Downsample_S16LSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10485
SDL_Downsample_S8_2c_x4
static void SDLCALL SDL_Downsample_S8_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8165
AUDIO_S16MSB
#define AUDIO_S16MSB
Definition: SDL_audio.h:94
SDL_Upsample_U16MSB_1c_x4
static void SDLCALL SDL_Upsample_U16MSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10592
SDL_audio.h
SDL_Upsample_S32LSB_4c_x4
static void SDLCALL SDL_Upsample_S32LSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12575
SDL_Downsample_U16MSB_4c_x2
static void SDLCALL SDL_Downsample_U16MSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10817
SDL_Downsample_S16MSB_8c_x2
static void SDLCALL SDL_Downsample_S16MSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12073
SDL_Downsample_U8_1c
static void SDLCALL SDL_Downsample_U8_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2328
SDL_Downsample_S16LSB_1c_x4
static void SDLCALL SDL_Downsample_S16LSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9761
SDL_Upsample_S8_1c
static void SDLCALL SDL_Upsample_S8_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2776
SDL_Upsample_S32MSB_2c
static void SDLCALL SDL_Upsample_S32MSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5720
SDL_Downsample_F32MSB_4c_x2
static void SDLCALL SDL_Downsample_F32MSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15117
SDL_Convert_U16MSB_to_S32MSB
static void SDLCALL SDL_Convert_U16MSB_to_S32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1056
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:129
SDL_Upsample_S8_6c
static void SDLCALL SDL_Upsample_S8_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3008
SDL_Convert_U8_to_F32MSB
static void SDLCALL SDL_Convert_U8_to_F32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:250
SDL_Downsample_S16LSB_2c_x4
static void SDLCALL SDL_Downsample_S16LSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9885
SDL_Downsample_U8_8c_x2
static void SDLCALL SDL_Downsample_U8_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7773
SDL_Downsample_S32LSB_2c
static void SDLCALL SDL_Downsample_S32LSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5277
SDL_Upsample_F32LSB_6c
static void SDLCALL SDL_Upsample_F32LSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6368
SDL_Upsample_S16LSB_1c_x4
static void SDLCALL SDL_Upsample_S16LSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9732
SDL_Downsample_S16LSB_1c_x2
static void SDLCALL SDL_Downsample_S16LSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9706
SDL_Downsample_S16LSB_6c_x2
static void SDLCALL SDL_Downsample_S16LSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10135
SDL_Upsample_S32LSB_4c_x2
static void SDLCALL SDL_Upsample_S32LSB_4c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12495
SDL_Downsample_S32LSB_6c
static void SDLCALL SDL_Downsample_S32LSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5465
SDL_AudioCVT::rate_incr
double rate_incr
Definition: SDL_audio.h:202
SDL_Convert_U16LSB_to_S16MSB
static void SDLCALL SDL_Convert_U16LSB_to_S16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:583
SDL_Downsample_F32LSB_1c_x2
static void SDLCALL SDL_Downsample_F32LSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14006
SDL_Downsample_F32MSB_8c_x2
static void SDLCALL SDL_Downsample_F32MSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15513
SDL_Downsample_S8_2c_x2
static void SDLCALL SDL_Downsample_S8_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8099
SDL_Upsample_F32LSB_2c
static void SDLCALL SDL_Upsample_F32LSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6200
AUDIO_S16LSB
#define AUDIO_S16LSB
Definition: SDL_audio.h:92
Sint16
int16_t Sint16
A signed 16-bit integer type.
Definition: SDL_stdinc.h:133
sdl_audio_rate_filters
const SDL_AudioRateFilters sdl_audio_rate_filters[]
Definition: SDL_audiotypecvt.c:15702
SDL_Upsample_F32LSB_4c_x4
static void SDLCALL SDL_Upsample_F32LSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14295
SDL_Downsample_S32LSB_2c_x2
static void SDLCALL SDL_Downsample_S32LSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12399
SDL_Downsample_F32MSB_2c_x2
static void SDLCALL SDL_Downsample_F32MSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14979
SDL_Downsample_S16MSB_4c
static void SDLCALL SDL_Downsample_S16MSB_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4881
SDL_Convert_S16MSB_to_S32LSB
static void SDLCALL SDL_Convert_S16MSB_to_S32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1245
SDL_Convert_U8_to_S16MSB
static void SDLCALL SDL_Convert_U8_to_S16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:154
SDL_Convert_S32LSB_to_F32MSB
static void SDLCALL SDL_Convert_S32LSB_to_F32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1531
SDL_Upsample_S8_4c
static void SDLCALL SDL_Upsample_S8_4c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2914
SDL_Downsample_F32MSB_4c_x4
static void SDLCALL SDL_Downsample_F32MSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15205
SDL_Convert_S16MSB_to_S16LSB
static void SDLCALL SDL_Convert_S16MSB_to_S16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1199
SDL_Downsample_S16LSB_8c
static void SDLCALL SDL_Downsample_S16LSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4149
SDL_Downsample_U8_1c_x4
static void SDLCALL SDL_Downsample_U8_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7181
SDL_Upsample_U16MSB_6c_x2
static void SDLCALL SDL_Upsample_U16MSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10943
SDL_Upsample_U16LSB_2c_x2
static void SDLCALL SDL_Upsample_U16LSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8927
SDL_Convert_U16MSB_to_S32LSB
static void SDLCALL SDL_Convert_U16MSB_to_S32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1032
SDL_Downsample_S16MSB_1c_x4
static void SDLCALL SDL_Downsample_S16MSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11481
Uint16
uint16_t Uint16
An unsigned 16-bit integer type.
Definition: SDL_stdinc.h:137
SDL_Downsample_S8_1c_x4
static void SDLCALL SDL_Downsample_S8_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8041
SDL_Convert_U16MSB_to_S8
static void SDLCALL SDL_Convert_U16MSB_to_S8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:939
SDL_Downsample_U16LSB_1c_x2
static void SDLCALL SDL_Downsample_U16LSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8846
SDL_Downsample_S8_4c_x4
static void SDLCALL SDL_Downsample_S8_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8325
SDL_Convert_U16LSB_to_S16LSB
static void SDLCALL SDL_Convert_U16LSB_to_S16LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:537
SDL_Convert_S32LSB_to_F32LSB
static void SDLCALL SDL_Convert_S32LSB_to_F32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1508
SDL_Upsample_S32MSB_4c_x4
static void SDLCALL SDL_Upsample_S32MSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13435
SDL_Upsample_U16MSB_8c_x4
static void SDLCALL SDL_Upsample_U16MSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11267
SDL_Upsample_U16MSB_8c_x2
static void SDLCALL SDL_Upsample_U16MSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11151
SDL_Upsample_S8_1c_x2
static void SDLCALL SDL_Upsample_S8_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7959
SDL_Upsample_S32LSB_2c
static void SDLCALL SDL_Upsample_S32LSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5240
src
GLenum src
Definition: glew.h:2396
SDL_Downsample_S16MSB_4c_x4
static void SDLCALL SDL_Downsample_S16MSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11765
SDL_Upsample_S16MSB_6c_x4
static void SDLCALL SDL_Upsample_S16MSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11901
i
int i
Definition: pngrutil.c:1377
SDL_Downsample_S8_1c_x2
static void SDLCALL SDL_Downsample_S8_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7986
SDL_Downsample_S16MSB_1c
static void SDLCALL SDL_Downsample_S16MSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4728
SDL_Convert_U16LSB_to_S8
static void SDLCALL SDL_Convert_U16LSB_to_S8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:513
SDL_Downsample_S32LSB_8c_x2
static void SDLCALL SDL_Downsample_S32LSB_8c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12933
SDL_Downsample_S8_6c_x2
static void SDLCALL SDL_Downsample_S8_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8415
SDL_Upsample_U16LSB_6c_x2
static void SDLCALL SDL_Upsample_U16LSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:9223
SDL_Upsample_S32LSB_8c
static void SDLCALL SDL_Upsample_S32LSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5522
SDL_Downsample_S16LSB_2c
static void SDLCALL SDL_Downsample_S16LSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3837
SDL_Downsample_U8_2c_x2
static void SDLCALL SDL_Downsample_U8_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7239
SDL_SwapLE16
#define SDL_SwapLE16(X)
Definition: SDL_endian.h:211
SDL_Upsample_U8_2c
static void SDLCALL SDL_Upsample_U8_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2360
SDL_Downsample_F32LSB_1c_x4
static void SDLCALL SDL_Downsample_F32LSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14061
SDL_Downsample_S16MSB_1c_x2
static void SDLCALL SDL_Downsample_S16MSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11426
AUDIO_S8
#define AUDIO_S8
Definition: SDL_audio.h:90
SDL_Convert_F32MSB_to_U8
static void SDLCALL SDL_Convert_F32MSB_to_U8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1980
SDL_Downsample_F32MSB_1c_x4
static void SDLCALL SDL_Downsample_F32MSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14921
Sint64
int64_t Sint64
A signed 64-bit integer type.
Definition: SDL_stdinc.h:150
SDL_Upsample_S16MSB_4c_x4
static void SDLCALL SDL_Upsample_S16MSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11715
SDL_Upsample_F32MSB_2c_x2
static void SDLCALL SDL_Upsample_F32MSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14947
SDL_Convert_S32LSB_to_S8
static void SDLCALL SDL_Convert_S32LSB_to_S8(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1365
SDL_Upsample_U8_2c_x4
static void SDLCALL SDL_Upsample_U8_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7269
SDL_Downsample_U8_2c
static void SDLCALL SDL_Downsample_U8_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2397
SDL_Upsample_U16LSB_2c
static void SDLCALL SDL_Upsample_U16LSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3320
SDL_Downsample_S16MSB_8c_x4
static void SDLCALL SDL_Downsample_S16MSB_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12205
SDL_Downsample_S8_8c_x4
static void SDLCALL SDL_Downsample_S8_8c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8765
SDL_Downsample_U16MSB_6c
static void SDLCALL SDL_Downsample_U16MSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4505
SDL_Downsample_F32MSB_2c
static void SDLCALL SDL_Downsample_F32MSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6717
Sint8
int8_t Sint8
A signed 8-bit integer type.
Definition: SDL_stdinc.h:125
SDL_Downsample_F32MSB_2c_x4
static void SDLCALL SDL_Downsample_F32MSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15045
SDL_Upsample_U16MSB_1c_x2
static void SDLCALL SDL_Upsample_U16MSB_1c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10539
SDL_Downsample_S32MSB_2c_x4
static void SDLCALL SDL_Downsample_S32MSB_2c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13325
SDL_Downsample_U16MSB_1c
static void SDLCALL SDL_Downsample_U16MSB_1c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4248
SDL_Upsample_S16MSB_6c_x2
static void SDLCALL SDL_Upsample_S16MSB_6c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:11803
SDL_Upsample_U8_6c
static void SDLCALL SDL_Upsample_U8_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2528
SDL_Downsample_F32LSB_4c_x4
static void SDLCALL SDL_Downsample_F32LSB_4c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:14345
SDL_Upsample_S32MSB_8c
static void SDLCALL SDL_Upsample_S32MSB_8c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:6002
SDL_Upsample_S16LSB_6c_x4
static void SDLCALL SDL_Upsample_S16LSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:10181
SDL_Convert_U16LSB_to_F32LSB
static void SDLCALL SDL_Convert_U16LSB_to_F32LSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:654
SDL_Upsample_S16LSB_6c
static void SDLCALL SDL_Upsample_S16LSB_6c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:3968
SDL_Upsample_U16LSB_1c_x4
static void SDLCALL SDL_Upsample_U16LSB_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:8872
AUDIO_U16MSB
#define AUDIO_U16MSB
Definition: SDL_audio.h:93
SDL_Upsample_S32LSB_6c_x4
static void SDLCALL SDL_Upsample_S32LSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:12761
SDL_Downsample_S32MSB_2c
static void SDLCALL SDL_Downsample_S32MSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:5757
SDL_Upsample_S32MSB_2c_x2
static void SDLCALL SDL_Upsample_S32MSB_2c_x2(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:13227
SDL_Convert_F32LSB_to_F32MSB
static void SDLCALL SDL_Convert_F32LSB_to_F32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1957
SDL_Upsample_U8_1c_x4
static void SDLCALL SDL_Upsample_U8_1c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:7152
SDL_Downsample_F32MSB_6c_x4
static void SDLCALL SDL_Downsample_F32MSB_6c_x4(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:15405
SDL_Convert_F32MSB_to_S32MSB
static void SDLCALL SDL_Convert_F32MSB_to_S32MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:2147
SDL_Convert_S32LSB_to_U16MSB
static void SDLCALL SDL_Convert_S32LSB_to_U16MSB(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:1437
SDL_AudioTypeFilters
Definition: SDL_audio_c.h:36
SDL_Downsample_S16MSB_2c
static void SDLCALL SDL_Downsample_S16MSB_2c(SDL_AudioCVT *cvt, SDL_AudioFormat format)
Definition: SDL_audiotypecvt.c:4797