Mercurial > SDL_sound_CoreAudio
annotate decoders/mpg123.c @ 591:8faf61a640f0 tip
Resynced fixes for unit conversion bugs in the Ogg Tremor decoder from SoundDecoder/ALmixer.
Ogg Vorbis uses seconds and we multiply by 1000 to convert to milliseconds. But Ogg Tremor already uses milliseconds but I was still multiplying by 1000.
| author | Eric Wing <ewing . public |-at-| gmail . com> |
|---|---|
| date | Thu, 25 Oct 2012 16:34:18 -0700 |
| parents | 2e5e01679f32 |
| children |
| rev | line source |
|---|---|
| 562 | 1 /* |
| 2 * SDL_sound -- An abstract sound format decoding API. | |
| 3 * Copyright (C) 2001 Ryan C. Gordon. | |
| 4 * | |
| 5 * This library is free software; you can redistribute it and/or | |
| 6 * modify it under the terms of the GNU Lesser General Public | |
| 7 * License as published by the Free Software Foundation; either | |
| 8 * version 2.1 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 * Lesser General Public License for more details. | |
| 14 * | |
| 15 * You should have received a copy of the GNU Lesser General Public | |
| 16 * License along with this library; if not, write to the Free Software | |
| 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| 18 */ | |
| 19 | |
| 20 /* | |
| 21 * libmpg123 decoder for SDL_sound. This is a very lightweight MP3 decoder, | |
| 22 * which is included with the SDL_sound source, so that it doesn't rely on | |
| 23 * unnecessary external libraries. | |
| 24 * | |
| 25 * libmpg123 is part of mpg123, and can be found in its original | |
| 26 * form at: http://www.mpg123.org/ | |
| 27 * | |
| 28 * Please see the file LICENSE.txt in the source's root directory. The included | |
| 29 * source code for libmpg123 falls under the LGPL, which is the same license | |
| 30 * as SDL_sound (so you can consider it a single work). | |
| 31 * | |
| 32 * This file written by Ryan C. Gordon. (icculus@icculus.org) | |
| 33 */ | |
| 34 | |
| 35 #if HAVE_CONFIG_H | |
| 36 # include <config.h> | |
| 37 #endif | |
| 38 | |
| 39 #ifdef SOUND_SUPPORTS_MPG123 | |
| 40 | |
| 41 #include <stdio.h> | |
| 42 #include <stdlib.h> | |
| 43 #include <string.h> | |
| 44 | |
|
584
2e5e01679f32
Minor changes to mpg123.c to compile with Visual Studio and modern mpg123.c instead of bundled version.
Eric Wing <ewing@anscamobile.com>
parents:
566
diff
changeset
|
45 #include "mpg123.h" |
| 562 | 46 |
| 47 #include "SDL_sound.h" | |
| 48 | |
| 49 #define __SDL_SOUND_INTERNAL__ | |
| 50 #include "SDL_sound_internal.h" | |
| 51 | |
|
584
2e5e01679f32
Minor changes to mpg123.c to compile with Visual Studio and modern mpg123.c instead of bundled version.
Eric Wing <ewing@anscamobile.com>
parents:
566
diff
changeset
|
52 #ifdef _MSC_VER |
|
2e5e01679f32
Minor changes to mpg123.c to compile with Visual Studio and modern mpg123.c instead of bundled version.
Eric Wing <ewing@anscamobile.com>
parents:
566
diff
changeset
|
53 #define snprintf _snprintf |
|
2e5e01679f32
Minor changes to mpg123.c to compile with Visual Studio and modern mpg123.c instead of bundled version.
Eric Wing <ewing@anscamobile.com>
parents:
566
diff
changeset
|
54 #endif |
|
2e5e01679f32
Minor changes to mpg123.c to compile with Visual Studio and modern mpg123.c instead of bundled version.
Eric Wing <ewing@anscamobile.com>
parents:
566
diff
changeset
|
55 |
|
2e5e01679f32
Minor changes to mpg123.c to compile with Visual Studio and modern mpg123.c instead of bundled version.
Eric Wing <ewing@anscamobile.com>
parents:
566
diff
changeset
|
56 |
| 562 | 57 static int MPG123_init(void); |
| 58 static void MPG123_quit(void); | |
| 59 static int MPG123_open(Sound_Sample *sample, const char *ext); | |
| 60 static void MPG123_close(Sound_Sample *sample); | |
| 61 static Uint32 MPG123_read(Sound_Sample *sample); | |
| 62 static int MPG123_rewind(Sound_Sample *sample); | |
| 63 static int MPG123_seek(Sound_Sample *sample, Uint32 ms); | |
| 64 | |
| 65 /* !!! FIXME: MPEG and MPG extensions? */ | |
| 66 static const char *extensions_mpg123[] = { "MP3", NULL }; | |
| 67 const Sound_DecoderFunctions __Sound_DecoderFunctions_MPG123 = | |
| 68 { | |
| 69 { | |
| 70 extensions_mpg123, | |
| 71 "MP3 decoding via internal libmpg123", | |
| 72 "Ryan C. Gordon <icculus@icculus.org>", | |
| 73 "http://www.icculus.org/SDL_sound/" | |
| 74 }, | |
| 75 | |
| 76 MPG123_init, /* init() method */ | |
| 77 MPG123_quit, /* quit() method */ | |
| 78 MPG123_open, /* open() method */ | |
| 79 MPG123_close, /* close() method */ | |
| 80 MPG123_read, /* read() method */ | |
| 81 MPG123_rewind, /* rewind() method */ | |
| 82 MPG123_seek /* seek() method */ | |
| 83 }; | |
| 84 | |
| 85 | |
| 86 /* this is what we store in our internal->decoder_private field... */ | |
| 87 typedef mpg123_handle mpg123_t; | |
| 88 | |
| 89 static SDL_mutex *mpg123_mutex = NULL; | |
| 90 static int mpg123_rwops_count = 0; | |
| 91 static SDL_RWops **mpg123_rwops = NULL; | |
| 92 | |
| 93 static void print_decoders(const char *kind, char **decoders) | |
| 94 { | |
| 95 SNDDBG(("%s:", kind)); | |
| 96 if (*decoders == NULL) | |
| 97 SNDDBG((" [none]")); | |
| 98 else | |
| 99 { | |
| 100 do | |
| 101 { | |
| 102 SNDDBG((" %s", *decoders)); | |
| 103 } while (*(++decoders)); | |
| 104 } /* else */ | |
| 564 | 105 SNDDBG(("\n")); |
| 562 | 106 } /* print_decoders */ |
| 107 | |
| 108 | |
| 109 static int MPG123_init(void) | |
| 110 { | |
| 111 int retval = 0; | |
| 112 assert(mpg123_mutex == NULL); | |
| 113 if (mpg123_init() == MPG123_OK) | |
| 114 { | |
| 115 char **supported = mpg123_supported_decoders(); | |
| 116 print_decoders("ALL MPG123 DECODERS", mpg123_decoders()); | |
| 117 print_decoders("SUPPORTED MPG123 DECODERS", mpg123_supported_decoders()); | |
| 118 if ((supported != NULL) && (*supported != NULL)) | |
| 119 { | |
| 120 mpg123_mutex = SDL_CreateMutex(); | |
| 121 if (mpg123_mutex != NULL) | |
| 122 retval = 1; /* at least one decoder available. */ | |
| 123 } /* if */ | |
| 124 } /* if */ | |
| 125 | |
| 126 return retval; | |
| 127 } /* MPG123_init */ | |
| 128 | |
| 129 | |
| 130 static void MPG123_quit(void) | |
| 131 { | |
| 132 mpg123_exit(); | |
| 133 SDL_DestroyMutex(mpg123_mutex); | |
| 134 mpg123_mutex = NULL; | |
| 135 free(mpg123_rwops); | |
| 136 mpg123_rwops = NULL; | |
| 137 mpg123_rwops_count = 0; | |
| 138 } /* MPG123_quit */ | |
| 139 | |
| 140 | |
| 141 /* bridge rwops reading to libmpg123 hooks. */ | |
| 142 static ssize_t rwread(int fd, void *buf, size_t len) | |
| 143 { | |
| 144 SDL_RWops *rw = NULL; | |
| 145 SDL_LockMutex(mpg123_mutex); | |
| 146 rw = mpg123_rwops[fd]; | |
| 147 SDL_UnlockMutex(mpg123_mutex); | |
| 148 return (ssize_t) SDL_RWread(rw, buf, 1, len); | |
| 149 } /* rwread */ | |
| 150 | |
| 151 | |
| 152 /* bridge rwops seeking to libmpg123 hooks. */ | |
| 153 static off_t rwseek(int fd, off_t pos, int whence) | |
| 154 { | |
| 155 SDL_RWops *rw = NULL; | |
| 156 SDL_LockMutex(mpg123_mutex); | |
| 157 rw = mpg123_rwops[fd]; | |
| 158 SDL_UnlockMutex(mpg123_mutex); | |
| 159 return (off_t) SDL_RWseek(rw, pos, whence); | |
| 160 } /* rwseek */ | |
| 161 | |
| 162 | |
| 163 static const char *set_error(mpg123_handle *mp, const int err) | |
| 164 { | |
| 165 char buffer[128]; | |
| 166 const char *str = NULL; | |
| 167 if ((err == MPG123_ERR) && (mp != NULL)) | |
| 168 str = mpg123_strerror(mp); | |
| 169 else | |
| 170 str = mpg123_plain_strerror(err); | |
| 171 | |
| 172 snprintf(buffer, sizeof (buffer), "MPG123: %s", str); | |
| 173 __Sound_SetError(buffer); | |
| 174 | |
| 175 return(NULL); /* this is for BAIL_MACRO to not try to reset the string. */ | |
| 176 } /* set_error */ | |
| 177 | |
| 178 | |
| 179 /* Make sure we are only given decoded data in a format we can handle. */ | |
| 180 static int set_formats(mpg123_handle *mp) | |
| 181 { | |
| 182 int rc = 0; | |
| 183 const long *rates = NULL; | |
| 184 size_t ratecount = 0; | |
| 185 const int channels = MPG123_STEREO | MPG123_MONO; | |
| 186 const int encodings = /* !!! FIXME: SDL 1.3 can do sint32 and float32. | |
| 187 MPG123_ENC_SIGNED_32 | MPG123_ENC_FLOAT_32 | */ | |
| 188 MPG123_ENC_SIGNED_8 | MPG123_ENC_UNSIGNED_8 | | |
| 189 MPG123_ENC_SIGNED_16 | MPG123_ENC_UNSIGNED_16; | |
| 190 | |
| 191 mpg123_rates(&rates, &ratecount); | |
| 192 | |
| 193 rc = mpg123_format_none(mp); | |
| 194 while ((ratecount--) && (rc == MPG123_OK)) | |
| 195 rc = mpg123_format(mp, *(rates++), channels, encodings); | |
| 196 | |
| 197 return(rc); | |
| 198 } /* set_formats */ | |
| 199 | |
| 200 | |
| 201 static int MPG123_open(Sound_Sample *sample, const char *ext) | |
| 202 { | |
| 203 Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque; | |
| 204 mpg123_handle *mp = NULL; | |
| 205 long rate = 0; | |
| 206 int channels = 0; | |
| 207 int fmt = 0; | |
| 208 int rc = 0; | |
| 209 off_t len = 0; | |
| 210 int seekable = 0; | |
| 211 void *ptr = NULL; | |
| 212 int rwops = 0; | |
| 213 | |
| 214 /* !!! FIXME: so much tapdance because we need a pointer, not an int. */ | |
| 215 SDL_LockMutex(mpg123_mutex); | |
| 216 for (rwops = 0; rwops < mpg123_rwops_count; rwops++) | |
| 217 { | |
| 218 if (mpg123_rwops[rwops] == NULL) | |
| 219 break; | |
| 220 } /* for */ | |
| 221 if (rwops < mpg123_rwops_count) | |
| 222 ptr = mpg123_rwops; | |
| 223 else | |
| 224 { | |
| 225 mpg123_rwops_count++; | |
| 226 ptr = realloc(mpg123_rwops, sizeof (SDL_RWops *) * mpg123_rwops_count); | |
| 227 if (ptr != NULL) | |
| 228 mpg123_rwops = (SDL_RWops **) ptr; | |
| 229 } /* else */ | |
| 230 if (ptr != NULL) | |
| 231 mpg123_rwops[rwops] = internal->rw; | |
| 232 SDL_UnlockMutex(mpg123_mutex); | |
| 233 BAIL_IF_MACRO(ptr == NULL, ERR_OUT_OF_MEMORY, 0); | |
| 234 | |
| 235 if ((mp = mpg123_new(NULL, &rc)) == NULL) | |
| 236 goto mpg123_open_failed; | |
| 237 else if ((rc = set_formats(mp)) != MPG123_OK) | |
| 238 goto mpg123_open_failed; | |
| 239 else if ((rc = mpg123_replace_reader(mp, rwread, rwseek)) != MPG123_OK) | |
| 240 goto mpg123_open_failed; | |
| 241 else if ((rc = mpg123_open_fd(mp, rwops)) != MPG123_OK) | |
| 242 goto mpg123_open_failed; | |
| 243 else if ((rc = mpg123_scan(mp)) != MPG123_OK) | |
| 244 goto mpg123_open_failed; /* !!! FIXME: this may be wrong. */ | |
| 245 else if ((rc = mpg123_getformat(mp, &rate, &channels, &fmt)) != MPG123_OK) | |
| 246 goto mpg123_open_failed; | |
| 247 | |
| 248 if (mpg123_seek(mp, 0, SEEK_END) >= 0) /* can seek? */ | |
| 249 { | |
| 250 len = mpg123_tell(mp); | |
| 251 if ((rc = (int) mpg123_seek(mp, 0, SEEK_SET)) < 0) | |
| 252 goto mpg123_open_failed; | |
| 253 seekable = 1; | |
| 254 } /* if */ | |
| 255 | |
| 256 internal->decoder_private = mp; | |
| 257 sample->actual.rate = rate; | |
| 258 sample->actual.channels = channels; | |
| 259 | |
| 260 rc = MPG123_BAD_OUTFORMAT; /* in case this fails... */ | |
| 261 if (fmt == MPG123_ENC_SIGNED_8) | |
| 262 sample->actual.format = AUDIO_S8; | |
| 263 else if (fmt == MPG123_ENC_UNSIGNED_8) | |
| 264 sample->actual.format = AUDIO_U8; | |
| 265 else if (fmt == MPG123_ENC_SIGNED_16) | |
| 266 sample->actual.format = AUDIO_S16SYS; | |
| 267 else if (fmt == MPG123_ENC_UNSIGNED_16) | |
| 268 sample->actual.format = AUDIO_U16SYS; | |
| 269 /* !!! FIXME: SDL 1.3 can do sint32 and float32 ... | |
| 270 else if (fmt == MPG123_ENC_SIGNED_32) | |
| 271 sample->actual.format = AUDIO_S32SYS; | |
| 272 else if (fmt == MPG123_ENC_FLOAT_32) | |
| 273 sample->actual.format = AUDIO_F32SYS; | |
| 274 */ | |
| 275 else | |
| 276 goto mpg123_open_failed; | |
| 277 | |
|
566
74405e7be04b
Moved SNDDBG output a little later.
Ryan C. Gordon <icculus@icculus.org>
parents:
564
diff
changeset
|
278 SNDDBG(("MPG123: Accepting data stream.\n")); |
|
74405e7be04b
Moved SNDDBG output a little later.
Ryan C. Gordon <icculus@icculus.org>
parents:
564
diff
changeset
|
279 |
| 562 | 280 sample->flags = SOUND_SAMPLEFLAG_NONE; |
| 281 internal->total_time = -1; | |
| 282 if (seekable) | |
| 283 { | |
| 284 sample->flags |= SOUND_SAMPLEFLAG_CANSEEK; | |
| 285 internal->total_time = ((len / rate) * 1000) + | |
| 286 (((len % rate) * 1000) / rate); | |
| 287 } /* if */ | |
| 288 | |
| 289 return(1); /* we'll handle this data. */ | |
| 290 | |
| 291 mpg123_open_failed: | |
| 292 SDL_LockMutex(mpg123_mutex); | |
| 293 mpg123_rwops[rwops] = NULL; | |
| 294 if (rwops == mpg123_rwops_count) | |
| 295 mpg123_rwops_count--; | |
| 296 SDL_UnlockMutex(mpg123_mutex); | |
| 297 set_error(mp, rc); | |
| 298 mpg123_delete(mp); /* NULL is safe. */ | |
| 299 return(0); | |
| 300 } /* MPG123_open */ | |
| 301 | |
| 302 | |
| 303 static void MPG123_close(Sound_Sample *sample) | |
| 304 { | |
| 305 Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque; | |
| 306 mpg123_t *mp = ((mpg123_t *) internal->decoder_private); | |
| 307 int i; | |
| 308 | |
| 309 SDL_LockMutex(mpg123_mutex); | |
| 310 for (i = 0; i < mpg123_rwops_count; i++) | |
| 311 { | |
| 312 if (mpg123_rwops[i] == internal->rw) | |
| 313 mpg123_rwops[i] = NULL; | |
| 314 } /* for */ | |
| 315 | |
| 316 for (i = mpg123_rwops_count-1; i >= 0; i--) | |
| 317 { | |
| 318 if (mpg123_rwops[i] != NULL) | |
| 319 break; | |
| 320 } /* for */ | |
| 321 mpg123_rwops_count = i + 1; | |
| 322 SDL_UnlockMutex(mpg123_mutex); | |
| 323 | |
| 324 mpg123_close(mp); /* don't need this at the moment, but it's safe. */ | |
| 325 mpg123_delete(mp); | |
| 326 } /* MPG123_close */ | |
| 327 | |
| 328 | |
| 329 static Uint32 MPG123_read(Sound_Sample *sample) | |
| 330 { | |
| 331 Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque; | |
| 332 mpg123_t *mp = ((mpg123_t *) internal->decoder_private); | |
| 333 size_t bw = 0; | |
| 334 const int rc = mpg123_read(mp, (unsigned char *) internal->buffer, | |
| 335 internal->buffer_size, &bw); | |
| 336 if (rc == MPG123_DONE) | |
| 337 sample->flags |= SOUND_SAMPLEFLAG_EOF; | |
| 338 else if (rc != MPG123_OK) | |
| 339 { | |
| 340 sample->flags |= SOUND_SAMPLEFLAG_ERROR; | |
| 341 set_error(mp, rc); | |
| 342 } /* else if */ | |
| 343 | |
| 344 return((Uint32) bw); | |
| 345 } /* MPG123_read */ | |
| 346 | |
| 347 | |
| 348 static int MPG123_rewind(Sound_Sample *sample) | |
| 349 { | |
| 350 Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque; | |
| 351 mpg123_t *mp = ((mpg123_t *) internal->decoder_private); | |
| 352 const int rc = (int) mpg123_seek(mp, 0, SEEK_SET); | |
| 353 BAIL_IF_MACRO(rc < 0, set_error(mp, rc), 0); | |
| 354 return(1); | |
| 355 } /* MPG123_rewind */ | |
| 356 | |
| 357 | |
| 358 static int MPG123_seek(Sound_Sample *sample, Uint32 ms) | |
| 359 { | |
| 360 Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque; | |
| 361 mpg123_t *mp = ((mpg123_t *) internal->decoder_private); | |
| 362 const float frames_per_ms = ((float) sample->actual.rate) / 1000.0f; | |
| 363 const off_t frame_offset = (off_t) (frames_per_ms * ((float) ms)); | |
| 364 const int rc = (int) mpg123_seek(mp, frame_offset , SEEK_SET); | |
| 365 BAIL_IF_MACRO(rc < 0, set_error(mp, rc), 0); | |
| 366 return(1); | |
| 367 } /* MPG123_seek */ | |
| 368 | |
| 369 #endif /* SOUND_SUPPORTS_MPG123 */ | |
| 370 | |
| 371 /* end of mpg123.c ... */ | |
| 372 |