Mercurial > sdl-ios-xcode
annotate src/audio/SDL_audiocvt.c @ 641:df178851293b
Date: 28 Jun 2003 22:42:52 +0100
From: Alan Swanson
Subject: Re: [SDL] New XFree 4.3 Video Mode Patch
I have a wee amendment that moves the qsort in set_best_resolution
to only occur after failing to find an exact match only. This would
make absolutely sure we get a user set mode.
While I've never had any problems for my normal resolutions (1280x1024,
1024x768, 800x600 & 640,480) while closely examining the output from
qsort I've noticed it doesn't seem to sort the modes fully. These is
one definite wrong at 1152x768 and a few that just look wrong to me.
From a program (attached) I made to examine this more easily. X has
sorted its mode list using the same method as ours (plus frequency),
and our user modes get inserted without any other movement.
On the patch I've made I've also changed cmpmodes to sort on vertical
resolution and then horizontal. Ie vertical is now most significant
bit.
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Sat, 28 Jun 2003 21:52:26 +0000 |
| parents | f6ffac90895c |
| children | b8d311d90021 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
|
297
f6ffac90895c
Updated copyright information for 2002
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
| 6 modify it under the terms of the GNU Library General Public | |
| 7 License as published by the Free Software Foundation; either | |
| 8 version 2 of the License, or (at your option) any later version. | |
| 9 | |
| 10 This library is distributed in the hope that it will be useful, | |
| 11 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 13 Library General Public License for more details. | |
| 14 | |
| 15 You should have received a copy of the GNU Library General Public | |
| 16 License along with this library; if not, write to the Free | |
| 17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| 18 | |
| 19 Sam Lantinga | |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
0
diff
changeset
|
20 slouken@libsdl.org |
| 0 | 21 */ |
| 22 | |
| 23 #ifdef SAVE_RCSID | |
| 24 static char rcsid = | |
| 25 "@(#) $Id$"; | |
| 26 #endif | |
| 27 | |
| 28 /* Functions for audio drivers to perform runtime conversion of audio format */ | |
| 29 | |
| 30 #include <stdio.h> | |
| 31 | |
| 32 #include "SDL_error.h" | |
| 33 #include "SDL_audio.h" | |
| 34 | |
| 35 | |
| 36 /* Effectively mix right and left channels into a single channel */ | |
| 37 void SDL_ConvertMono(SDL_AudioCVT *cvt, Uint16 format) | |
| 38 { | |
| 39 int i; | |
| 40 Sint32 sample; | |
| 41 | |
| 42 #ifdef DEBUG_CONVERT | |
| 43 fprintf(stderr, "Converting to mono\n"); | |
| 44 #endif | |
| 45 switch (format&0x8018) { | |
| 46 | |
| 47 case AUDIO_U8: { | |
| 48 Uint8 *src, *dst; | |
| 49 | |
| 50 src = cvt->buf; | |
| 51 dst = cvt->buf; | |
| 52 for ( i=cvt->len_cvt/2; i; --i ) { | |
| 53 sample = src[0] + src[1]; | |
| 54 if ( sample > 255 ) { | |
| 55 *dst = 255; | |
| 56 } else { | |
| 57 *dst = sample; | |
| 58 } | |
| 59 src += 2; | |
| 60 dst += 1; | |
| 61 } | |
| 62 } | |
| 63 break; | |
| 64 | |
| 65 case AUDIO_S8: { | |
| 66 Sint8 *src, *dst; | |
| 67 | |
| 68 src = (Sint8 *)cvt->buf; | |
| 69 dst = (Sint8 *)cvt->buf; | |
| 70 for ( i=cvt->len_cvt/2; i; --i ) { | |
| 71 sample = src[0] + src[1]; | |
| 72 if ( sample > 127 ) { | |
| 73 *dst = 127; | |
| 74 } else | |
| 75 if ( sample < -128 ) { | |
| 76 *dst = -128; | |
| 77 } else { | |
| 78 *dst = sample; | |
| 79 } | |
| 80 src += 2; | |
| 81 dst += 1; | |
| 82 } | |
| 83 } | |
| 84 break; | |
| 85 | |
| 86 case AUDIO_U16: { | |
| 87 Uint8 *src, *dst; | |
| 88 | |
| 89 src = cvt->buf; | |
| 90 dst = cvt->buf; | |
| 91 if ( (format & 0x1000) == 0x1000 ) { | |
| 92 for ( i=cvt->len_cvt/4; i; --i ) { | |
| 93 sample = (Uint16)((src[0]<<8)|src[1])+ | |
| 94 (Uint16)((src[2]<<8)|src[3]); | |
| 95 if ( sample > 65535 ) { | |
| 96 dst[0] = 0xFF; | |
| 97 dst[1] = 0xFF; | |
| 98 } else { | |
| 99 dst[1] = (sample&0xFF); | |
| 100 sample >>= 8; | |
| 101 dst[0] = (sample&0xFF); | |
| 102 } | |
| 103 src += 4; | |
| 104 dst += 2; | |
| 105 } | |
| 106 } else { | |
| 107 for ( i=cvt->len_cvt/4; i; --i ) { | |
| 108 sample = (Uint16)((src[1]<<8)|src[0])+ | |
| 109 (Uint16)((src[3]<<8)|src[2]); | |
| 110 if ( sample > 65535 ) { | |
| 111 dst[0] = 0xFF; | |
| 112 dst[1] = 0xFF; | |
| 113 } else { | |
| 114 dst[0] = (sample&0xFF); | |
| 115 sample >>= 8; | |
| 116 dst[1] = (sample&0xFF); | |
| 117 } | |
| 118 src += 4; | |
| 119 dst += 2; | |
| 120 } | |
| 121 } | |
| 122 } | |
| 123 break; | |
| 124 | |
| 125 case AUDIO_S16: { | |
| 126 Uint8 *src, *dst; | |
| 127 | |
| 128 src = cvt->buf; | |
| 129 dst = cvt->buf; | |
| 130 if ( (format & 0x1000) == 0x1000 ) { | |
| 131 for ( i=cvt->len_cvt/4; i; --i ) { | |
| 132 sample = (Sint16)((src[0]<<8)|src[1])+ | |
| 133 (Sint16)((src[2]<<8)|src[3]); | |
| 134 if ( sample > 32767 ) { | |
| 135 dst[0] = 0x7F; | |
| 136 dst[1] = 0xFF; | |
| 137 } else | |
| 138 if ( sample < -32768 ) { | |
| 139 dst[0] = 0x80; | |
| 140 dst[1] = 0x00; | |
| 141 } else { | |
| 142 dst[1] = (sample&0xFF); | |
| 143 sample >>= 8; | |
| 144 dst[0] = (sample&0xFF); | |
| 145 } | |
| 146 src += 4; | |
| 147 dst += 2; | |
| 148 } | |
| 149 } else { | |
| 150 for ( i=cvt->len_cvt/4; i; --i ) { | |
| 151 sample = (Sint16)((src[1]<<8)|src[0])+ | |
| 152 (Sint16)((src[3]<<8)|src[2]); | |
| 153 if ( sample > 32767 ) { | |
| 154 dst[1] = 0x7F; | |
| 155 dst[0] = 0xFF; | |
| 156 } else | |
| 157 if ( sample < -32768 ) { | |
| 158 dst[1] = 0x80; | |
| 159 dst[0] = 0x00; | |
| 160 } else { | |
| 161 dst[0] = (sample&0xFF); | |
| 162 sample >>= 8; | |
| 163 dst[1] = (sample&0xFF); | |
| 164 } | |
| 165 src += 4; | |
| 166 dst += 2; | |
| 167 } | |
| 168 } | |
| 169 } | |
| 170 break; | |
| 171 } | |
| 172 cvt->len_cvt /= 2; | |
| 173 if ( cvt->filters[++cvt->filter_index] ) { | |
| 174 cvt->filters[cvt->filter_index](cvt, format); | |
| 175 } | |
| 176 } | |
| 177 | |
| 178 | |
| 179 /* Duplicate a mono channel to both stereo channels */ | |
| 180 void SDL_ConvertStereo(SDL_AudioCVT *cvt, Uint16 format) | |
| 181 { | |
| 182 int i; | |
| 183 | |
| 184 #ifdef DEBUG_CONVERT | |
| 185 fprintf(stderr, "Converting to stereo\n"); | |
| 186 #endif | |
| 187 if ( (format & 0xFF) == 16 ) { | |
| 188 Uint16 *src, *dst; | |
| 189 | |
| 190 src = (Uint16 *)(cvt->buf+cvt->len_cvt); | |
| 191 dst = (Uint16 *)(cvt->buf+cvt->len_cvt*2); | |
| 192 for ( i=cvt->len_cvt/2; i; --i ) { | |
| 193 dst -= 2; | |
| 194 src -= 1; | |
| 195 dst[0] = src[0]; | |
| 196 dst[1] = src[0]; | |
| 197 } | |
| 198 } else { | |
| 199 Uint8 *src, *dst; | |
| 200 | |
| 201 src = cvt->buf+cvt->len_cvt; | |
| 202 dst = cvt->buf+cvt->len_cvt*2; | |
| 203 for ( i=cvt->len_cvt; i; --i ) { | |
| 204 dst -= 2; | |
| 205 src -= 1; | |
| 206 dst[0] = src[0]; | |
| 207 dst[1] = src[0]; | |
| 208 } | |
| 209 } | |
| 210 cvt->len_cvt *= 2; | |
| 211 if ( cvt->filters[++cvt->filter_index] ) { | |
| 212 cvt->filters[cvt->filter_index](cvt, format); | |
| 213 } | |
| 214 } | |
| 215 | |
| 216 /* Convert 8-bit to 16-bit - LSB */ | |
| 217 void SDL_Convert16LSB(SDL_AudioCVT *cvt, Uint16 format) | |
| 218 { | |
| 219 int i; | |
| 220 Uint8 *src, *dst; | |
| 221 | |
| 222 #ifdef DEBUG_CONVERT | |
| 223 fprintf(stderr, "Converting to 16-bit LSB\n"); | |
| 224 #endif | |
| 225 src = cvt->buf+cvt->len_cvt; | |
| 226 dst = cvt->buf+cvt->len_cvt*2; | |
| 227 for ( i=cvt->len_cvt; i; --i ) { | |
| 228 src -= 1; | |
| 229 dst -= 2; | |
| 230 dst[1] = *src; | |
| 231 dst[0] = 0; | |
| 232 } | |
| 233 format = ((format & ~0x0008) | AUDIO_U16LSB); | |
| 234 cvt->len_cvt *= 2; | |
| 235 if ( cvt->filters[++cvt->filter_index] ) { | |
| 236 cvt->filters[cvt->filter_index](cvt, format); | |
| 237 } | |
| 238 } | |
| 239 /* Convert 8-bit to 16-bit - MSB */ | |
| 240 void SDL_Convert16MSB(SDL_AudioCVT *cvt, Uint16 format) | |
| 241 { | |
| 242 int i; | |
| 243 Uint8 *src, *dst; | |
| 244 | |
| 245 #ifdef DEBUG_CONVERT | |
| 246 fprintf(stderr, "Converting to 16-bit MSB\n"); | |
| 247 #endif | |
| 248 src = cvt->buf+cvt->len_cvt; | |
| 249 dst = cvt->buf+cvt->len_cvt*2; | |
| 250 for ( i=cvt->len_cvt; i; --i ) { | |
| 251 src -= 1; | |
| 252 dst -= 2; | |
| 253 dst[0] = *src; | |
| 254 dst[1] = 0; | |
| 255 } | |
| 256 format = ((format & ~0x0008) | AUDIO_U16MSB); | |
| 257 cvt->len_cvt *= 2; | |
| 258 if ( cvt->filters[++cvt->filter_index] ) { | |
| 259 cvt->filters[cvt->filter_index](cvt, format); | |
| 260 } | |
| 261 } | |
| 262 | |
| 263 /* Convert 16-bit to 8-bit */ | |
| 264 void SDL_Convert8(SDL_AudioCVT *cvt, Uint16 format) | |
| 265 { | |
| 266 int i; | |
| 267 Uint8 *src, *dst; | |
| 268 | |
| 269 #ifdef DEBUG_CONVERT | |
| 270 fprintf(stderr, "Converting to 8-bit\n"); | |
| 271 #endif | |
| 272 src = cvt->buf; | |
| 273 dst = cvt->buf; | |
| 274 if ( (format & 0x1000) != 0x1000 ) { /* Little endian */ | |
| 275 ++src; | |
| 276 } | |
| 277 for ( i=cvt->len_cvt/2; i; --i ) { | |
| 278 *dst = *src; | |
| 279 src += 2; | |
| 280 dst += 1; | |
| 281 } | |
| 282 format = ((format & ~0x9010) | AUDIO_U8); | |
| 283 cvt->len_cvt /= 2; | |
| 284 if ( cvt->filters[++cvt->filter_index] ) { | |
| 285 cvt->filters[cvt->filter_index](cvt, format); | |
| 286 } | |
| 287 } | |
| 288 | |
| 289 /* Toggle signed/unsigned */ | |
| 290 void SDL_ConvertSign(SDL_AudioCVT *cvt, Uint16 format) | |
| 291 { | |
| 292 int i; | |
| 293 Uint8 *data; | |
| 294 | |
| 295 #ifdef DEBUG_CONVERT | |
| 296 fprintf(stderr, "Converting audio signedness\n"); | |
| 297 #endif | |
| 298 data = cvt->buf; | |
| 299 if ( (format & 0xFF) == 16 ) { | |
| 300 if ( (format & 0x1000) != 0x1000 ) { /* Little endian */ | |
| 301 ++data; | |
| 302 } | |
| 303 for ( i=cvt->len_cvt/2; i; --i ) { | |
| 304 *data ^= 0x80; | |
| 305 data += 2; | |
| 306 } | |
| 307 } else { | |
| 308 for ( i=cvt->len_cvt; i; --i ) { | |
| 309 *data++ ^= 0x80; | |
| 310 } | |
| 311 } | |
| 312 format = (format ^ 0x8000); | |
| 313 if ( cvt->filters[++cvt->filter_index] ) { | |
| 314 cvt->filters[cvt->filter_index](cvt, format); | |
| 315 } | |
| 316 } | |
| 317 | |
| 318 /* Toggle endianness */ | |
| 319 void SDL_ConvertEndian(SDL_AudioCVT *cvt, Uint16 format) | |
| 320 { | |
| 321 int i; | |
| 322 Uint8 *data, tmp; | |
| 323 | |
| 324 #ifdef DEBUG_CONVERT | |
| 325 fprintf(stderr, "Converting audio endianness\n"); | |
| 326 #endif | |
| 327 data = cvt->buf; | |
| 328 for ( i=cvt->len_cvt/2; i; --i ) { | |
| 329 tmp = data[0]; | |
| 330 data[0] = data[1]; | |
| 331 data[1] = tmp; | |
| 332 data += 2; | |
| 333 } | |
| 334 format = (format ^ 0x1000); | |
| 335 if ( cvt->filters[++cvt->filter_index] ) { | |
| 336 cvt->filters[cvt->filter_index](cvt, format); | |
| 337 } | |
| 338 } | |
| 339 | |
| 340 /* Convert rate up by multiple of 2 */ | |
| 341 void SDL_RateMUL2(SDL_AudioCVT *cvt, Uint16 format) | |
| 342 { | |
| 343 int i; | |
| 344 Uint8 *src, *dst; | |
| 345 | |
| 346 #ifdef DEBUG_CONVERT | |
| 347 fprintf(stderr, "Converting audio rate * 2\n"); | |
| 348 #endif | |
| 349 src = cvt->buf+cvt->len_cvt; | |
| 350 dst = cvt->buf+cvt->len_cvt*2; | |
| 351 switch (format & 0xFF) { | |
| 352 case 8: | |
| 353 for ( i=cvt->len_cvt; i; --i ) { | |
| 354 src -= 1; | |
| 355 dst -= 2; | |
| 356 dst[0] = src[0]; | |
| 357 dst[1] = src[0]; | |
| 358 } | |
| 359 break; | |
| 360 case 16: | |
| 361 for ( i=cvt->len_cvt/2; i; --i ) { | |
| 362 src -= 2; | |
| 363 dst -= 4; | |
| 364 dst[0] = src[0]; | |
| 365 dst[1] = src[1]; | |
| 366 dst[2] = src[0]; | |
| 367 dst[3] = src[1]; | |
| 368 } | |
| 369 break; | |
| 370 } | |
| 371 cvt->len_cvt *= 2; | |
| 372 if ( cvt->filters[++cvt->filter_index] ) { | |
| 373 cvt->filters[cvt->filter_index](cvt, format); | |
| 374 } | |
| 375 } | |
| 376 | |
| 377 /* Convert rate down by multiple of 2 */ | |
| 378 void SDL_RateDIV2(SDL_AudioCVT *cvt, Uint16 format) | |
| 379 { | |
| 380 int i; | |
| 381 Uint8 *src, *dst; | |
| 382 | |
| 383 #ifdef DEBUG_CONVERT | |
| 384 fprintf(stderr, "Converting audio rate / 2\n"); | |
| 385 #endif | |
| 386 src = cvt->buf; | |
| 387 dst = cvt->buf; | |
| 388 switch (format & 0xFF) { | |
| 389 case 8: | |
| 390 for ( i=cvt->len_cvt/2; i; --i ) { | |
| 391 dst[0] = src[0]; | |
| 392 src += 2; | |
| 393 dst += 1; | |
| 394 } | |
| 395 break; | |
| 396 case 16: | |
| 397 for ( i=cvt->len_cvt/4; i; --i ) { | |
| 398 dst[0] = src[0]; | |
| 399 dst[1] = src[1]; | |
| 400 src += 4; | |
| 401 dst += 2; | |
| 402 } | |
| 403 break; | |
| 404 } | |
| 405 cvt->len_cvt /= 2; | |
| 406 if ( cvt->filters[++cvt->filter_index] ) { | |
| 407 cvt->filters[cvt->filter_index](cvt, format); | |
| 408 } | |
| 409 } | |
| 410 | |
| 411 /* Very slow rate conversion routine */ | |
| 412 void SDL_RateSLOW(SDL_AudioCVT *cvt, Uint16 format) | |
| 413 { | |
| 414 double ipos; | |
| 415 int i, clen; | |
| 416 | |
| 417 #ifdef DEBUG_CONVERT | |
| 418 fprintf(stderr, "Converting audio rate * %4.4f\n", 1.0/cvt->rate_incr); | |
| 419 #endif | |
| 420 clen = (int)((double)cvt->len_cvt / cvt->rate_incr); | |
| 421 if ( cvt->rate_incr > 1.0 ) { | |
| 422 switch (format & 0xFF) { | |
| 423 case 8: { | |
| 424 Uint8 *output; | |
| 425 | |
| 426 output = cvt->buf; | |
| 427 ipos = 0.0; | |
| 428 for ( i=clen; i; --i ) { | |
| 429 *output = cvt->buf[(int)ipos]; | |
| 430 ipos += cvt->rate_incr; | |
| 431 output += 1; | |
| 432 } | |
| 433 } | |
| 434 break; | |
| 435 | |
| 436 case 16: { | |
| 437 Uint16 *output; | |
| 438 | |
| 439 clen &= ~1; | |
| 440 output = (Uint16 *)cvt->buf; | |
| 441 ipos = 0.0; | |
| 442 for ( i=clen/2; i; --i ) { | |
| 443 *output=((Uint16 *)cvt->buf)[(int)ipos]; | |
| 444 ipos += cvt->rate_incr; | |
| 445 output += 1; | |
| 446 } | |
| 447 } | |
| 448 break; | |
| 449 } | |
| 450 } else { | |
| 451 switch (format & 0xFF) { | |
| 452 case 8: { | |
| 453 Uint8 *output; | |
| 454 | |
| 455 output = cvt->buf+clen; | |
| 456 ipos = (double)cvt->len_cvt; | |
| 457 for ( i=clen; i; --i ) { | |
| 458 ipos -= cvt->rate_incr; | |
| 459 output -= 1; | |
| 460 *output = cvt->buf[(int)ipos]; | |
| 461 } | |
| 462 } | |
| 463 break; | |
| 464 | |
| 465 case 16: { | |
| 466 Uint16 *output; | |
| 467 | |
| 468 clen &= ~1; | |
| 469 output = (Uint16 *)(cvt->buf+clen); | |
| 470 ipos = (double)cvt->len_cvt/2; | |
| 471 for ( i=clen/2; i; --i ) { | |
| 472 ipos -= cvt->rate_incr; | |
| 473 output -= 1; | |
| 474 *output=((Uint16 *)cvt->buf)[(int)ipos]; | |
| 475 } | |
| 476 } | |
| 477 break; | |
| 478 } | |
| 479 } | |
| 480 cvt->len_cvt = clen; | |
| 481 if ( cvt->filters[++cvt->filter_index] ) { | |
| 482 cvt->filters[cvt->filter_index](cvt, format); | |
| 483 } | |
| 484 } | |
| 485 | |
| 486 int SDL_ConvertAudio(SDL_AudioCVT *cvt) | |
| 487 { | |
| 488 /* Make sure there's data to convert */ | |
| 489 if ( cvt->buf == NULL ) { | |
| 490 SDL_SetError("No buffer allocated for conversion"); | |
| 491 return(-1); | |
| 492 } | |
| 493 /* Return okay if no conversion is necessary */ | |
| 494 cvt->len_cvt = cvt->len; | |
| 495 if ( cvt->filters[0] == NULL ) { | |
| 496 return(0); | |
| 497 } | |
| 498 | |
| 499 /* Set up the conversion and go! */ | |
| 500 cvt->filter_index = 0; | |
| 501 cvt->filters[0](cvt, cvt->src_format); | |
| 502 return(0); | |
| 503 } | |
| 504 | |
| 505 /* Creates a set of audio filters to convert from one format to another. | |
| 506 Returns -1 if the format conversion is not supported, or 1 if the | |
| 507 audio filter is set up. | |
| 508 */ | |
| 509 | |
| 510 int SDL_BuildAudioCVT(SDL_AudioCVT *cvt, | |
| 511 Uint16 src_format, Uint8 src_channels, int src_rate, | |
| 512 Uint16 dst_format, Uint8 dst_channels, int dst_rate) | |
| 513 { | |
| 514 /* Start off with no conversion necessary */ | |
| 515 cvt->needed = 0; | |
| 516 cvt->filter_index = 0; | |
| 517 cvt->filters[0] = NULL; | |
| 518 cvt->len_mult = 1; | |
| 519 cvt->len_ratio = 1.0; | |
| 520 | |
| 521 /* First filter: Endian conversion from src to dst */ | |
| 522 if ( (src_format & 0x1000) != (dst_format & 0x1000) | |
| 523 && ((src_format & 0xff) != 8) ) { | |
| 524 cvt->filters[cvt->filter_index++] = SDL_ConvertEndian; | |
| 525 } | |
| 526 | |
| 527 /* Second filter: Sign conversion -- signed/unsigned */ | |
| 528 if ( (src_format & 0x8000) != (dst_format & 0x8000) ) { | |
| 529 cvt->filters[cvt->filter_index++] = SDL_ConvertSign; | |
| 530 } | |
| 531 | |
| 532 /* Next filter: Convert 16 bit <--> 8 bit PCM */ | |
| 533 if ( (src_format & 0xFF) != (dst_format & 0xFF) ) { | |
| 534 switch (dst_format&0x10FF) { | |
| 535 case AUDIO_U8: | |
| 536 cvt->filters[cvt->filter_index++] = | |
| 537 SDL_Convert8; | |
| 538 cvt->len_ratio /= 2; | |
| 539 break; | |
| 540 case AUDIO_U16LSB: | |
| 541 cvt->filters[cvt->filter_index++] = | |
| 542 SDL_Convert16LSB; | |
| 543 cvt->len_mult *= 2; | |
| 544 cvt->len_ratio *= 2; | |
| 545 break; | |
| 546 case AUDIO_U16MSB: | |
| 547 cvt->filters[cvt->filter_index++] = | |
| 548 SDL_Convert16MSB; | |
| 549 cvt->len_mult *= 2; | |
| 550 cvt->len_ratio *= 2; | |
| 551 break; | |
| 552 } | |
| 553 } | |
| 554 | |
| 555 /* Last filter: Mono/Stereo conversion */ | |
| 556 if ( src_channels != dst_channels ) { | |
| 557 while ( (src_channels*2) <= dst_channels ) { | |
| 558 cvt->filters[cvt->filter_index++] = | |
| 559 SDL_ConvertStereo; | |
| 560 cvt->len_mult *= 2; | |
| 561 src_channels *= 2; | |
| 562 cvt->len_ratio *= 2; | |
| 563 } | |
| 564 /* This assumes that 4 channel audio is in the format: | |
| 565 Left {front/back} + Right {front/back} | |
| 566 so converting to L/R stereo works properly. | |
| 567 */ | |
| 568 while ( ((src_channels%2) == 0) && | |
| 569 ((src_channels/2) >= dst_channels) ) { | |
| 570 cvt->filters[cvt->filter_index++] = | |
| 571 SDL_ConvertMono; | |
| 572 src_channels /= 2; | |
| 573 cvt->len_ratio /= 2; | |
| 574 } | |
| 575 if ( src_channels != dst_channels ) { | |
| 576 /* Uh oh.. */; | |
| 577 } | |
| 578 } | |
| 579 | |
| 580 /* Do rate conversion */ | |
| 581 cvt->rate_incr = 0.0; | |
| 582 if ( (src_rate/100) != (dst_rate/100) ) { | |
| 583 Uint32 hi_rate, lo_rate; | |
| 584 int len_mult; | |
| 585 double len_ratio; | |
| 586 void (*rate_cvt)(SDL_AudioCVT *cvt, Uint16 format); | |
| 587 | |
| 588 if ( src_rate > dst_rate ) { | |
| 589 hi_rate = src_rate; | |
| 590 lo_rate = dst_rate; | |
| 591 rate_cvt = SDL_RateDIV2; | |
| 592 len_mult = 1; | |
| 593 len_ratio = 0.5; | |
| 594 } else { | |
| 595 hi_rate = dst_rate; | |
| 596 lo_rate = src_rate; | |
| 597 rate_cvt = SDL_RateMUL2; | |
| 598 len_mult = 2; | |
| 599 len_ratio = 2.0; | |
| 600 } | |
| 601 /* If hi_rate = lo_rate*2^x then conversion is easy */ | |
| 602 while ( ((lo_rate*2)/100) <= (hi_rate/100) ) { | |
| 603 cvt->filters[cvt->filter_index++] = rate_cvt; | |
| 604 cvt->len_mult *= len_mult; | |
| 605 lo_rate *= 2; | |
| 606 cvt->len_ratio *= len_ratio; | |
| 607 } | |
| 608 /* We may need a slow conversion here to finish up */ | |
| 609 if ( (lo_rate/100) != (hi_rate/100) ) { | |
| 610 #if 1 | |
| 611 /* The problem with this is that if the input buffer is | |
| 612 say 1K, and the conversion rate is say 1.1, then the | |
| 613 output buffer is 1.1K, which may not be an acceptable | |
| 614 buffer size for the audio driver (not a power of 2) | |
| 615 */ | |
| 616 /* For now, punt and hope the rate distortion isn't great. | |
| 617 */ | |
| 618 #else | |
| 619 if ( src_rate < dst_rate ) { | |
| 620 cvt->rate_incr = (double)lo_rate/hi_rate; | |
| 621 cvt->len_mult *= 2; | |
| 622 cvt->len_ratio /= cvt->rate_incr; | |
| 623 } else { | |
| 624 cvt->rate_incr = (double)hi_rate/lo_rate; | |
| 625 cvt->len_ratio *= cvt->rate_incr; | |
| 626 } | |
| 627 cvt->filters[cvt->filter_index++] = SDL_RateSLOW; | |
| 628 #endif | |
| 629 } | |
| 630 } | |
| 631 | |
| 632 /* Set up the filter information */ | |
| 633 if ( cvt->filter_index != 0 ) { | |
| 634 cvt->needed = 1; | |
| 635 cvt->src_format = src_format; | |
| 636 cvt->dst_format = dst_format; | |
| 637 cvt->len = 0; | |
| 638 cvt->buf = NULL; | |
| 639 cvt->filters[cvt->filter_index] = NULL; | |
| 640 } | |
| 641 return(cvt->needed); | |
| 642 } |