Mercurial > SDL_sound_CoreAudio
annotate extra_rwops.c @ 474:c66080364dff
Most decoders now report total sample play time, now. Technically, this
breaks binary compatibility with the 1.0 branch, since it extends the
Sound_Sample struct, but most (all?) programs are just passing pointers
allocated by SDL_sound around, and might be okay.
Source-level compatibility is not broken...yet! :)
--ryan.
-------- Original Message --------
Subject: SDL_sound patch: Finding total length of time of sound file.
Date: Sun, 26 Jan 2003 09:31:17 -0800 (PST)
Hi Ryan,
I am working with Eric Wing and helping him modify
SDL_sound. AS part of our efforts in improving and
enhancing SDL_sound, we like to submit this patch. We
modified the codecs to find the total time of a sound
file. Below is the explanation of the patch. The
patch is appended as an attachment to this email.
* MOTIVATION:
We needed the ability to get the total play time of a
sample (And we noticed that we're not the only ones).
Since SDL_sound blocks direct access to the specific
decoders, there is no way for a user to know this
information short of decoding the whole thing.
Because of this, we believe this will be a useful
addition, even though the accuracy may not be perfect
(subject to each decoder) or the information may not
always be available.
* CONTRIBUTORS:
Wesley Leong (modified the majority of the codecs and
verified the results)
Eric Wing (showed everyone how to do modify codec,
modified mikmod)
Wang Lam (modified a handful of codecs, researched
into specs and int overflow)
Ahilan Anantha (modified a few codecs and helped with
integer math)
* GENERAL ISSUES:
We chose the value to be milliseconds as an Sint32.
Milliseconds because that's what Sound_Seek takes as a
parameter and -1 to allow for instances/codecs where
the value could not be determined. We are
not sure if this is the final convention you want, so
we are willing to work with you on this.
We also expect the total_time field to be set on open
and never again modified by SDL_sound. Users may
access it directly much like the sample buffer and
buffer_size. We thought about recomputing the time
on DecodeAll, but since users may seek or decode small
chunks first, not all the data may be there. So this
is better done by the user. This may be good
information to document.
Currently, all the main codecs are implemented except
for QuickTime.
| author | Ryan C. Gordon <icculus@icculus.org> |
|---|---|
| date | Sat, 08 May 2004 08:19:50 +0000 |
| parents | 47cc2de2ae36 |
| children | 137c0b00ea4c 50bb9a6cebfe |
| rev | line source |
|---|---|
| 8 | 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 * Some extra RWops that are needed or are just handy to have. | |
| 22 * | |
|
184
47cc2de2ae36
Changed reference to "LICENSE" file to "COPYING".
Ryan C. Gordon <icculus@icculus.org>
parents:
83
diff
changeset
|
23 * Please see the file COPYING in the source's root directory. |
| 8 | 24 * |
| 25 * This file written by Ryan C. Gordon. (icculus@clutteredmind.org) | |
| 26 */ | |
| 27 | |
| 28 #include <stdio.h> | |
| 29 #include <stdlib.h> | |
| 30 #include "SDL.h" | |
| 31 | |
| 32 | |
| 33 /* | |
| 34 * The Reference Counter RWops... | |
| 35 */ | |
| 36 | |
| 37 | |
| 38 typedef struct | |
| 39 { | |
| 40 SDL_RWops *rw; /* The actual RWops we're refcounting... */ | |
| 41 int refcount; /* The refcount; starts at 1. If goes to 0, delete. */ | |
| 42 } RWRefCounterData; | |
| 43 | |
| 44 | |
| 45 /* Just pass through to the actual SDL_RWops's method... */ | |
| 46 static int refcounter_seek(SDL_RWops *rw, int offset, int whence) | |
| 47 { | |
| 48 RWRefCounterData *data = (RWRefCounterData *) rw->hidden.unknown.data1; | |
| 49 return(data->rw->seek(data->rw, offset, whence)); | |
| 50 } /* refcounter_seek */ | |
| 51 | |
| 52 | |
| 53 /* Just pass through to the actual SDL_RWops's method... */ | |
| 54 static int refcounter_read(SDL_RWops *rw, void *ptr, int size, int maxnum) | |
| 55 { | |
| 56 RWRefCounterData *data = (RWRefCounterData *) rw->hidden.unknown.data1; | |
| 57 return(data->rw->read(data->rw, ptr, size, maxnum)); | |
| 58 } /* refcounter_read */ | |
| 59 | |
| 60 | |
| 61 /* Just pass through to the actual SDL_RWops's method... */ | |
| 62 static int refcounter_write(SDL_RWops *rw, const void *ptr, int size, int num) | |
| 63 { | |
| 64 RWRefCounterData *data = (RWRefCounterData *) rw->hidden.unknown.data1; | |
| 65 return(data->rw->write(data->rw, ptr, size, num)); | |
| 66 } /* refcounter_write */ | |
| 67 | |
| 68 | |
| 69 /* | |
| 70 * Decrement the reference count. If there are no more references, pass | |
| 71 * through to the actual SDL_RWops's method, and then clean ourselves up. | |
| 72 */ | |
| 73 static int refcounter_close(SDL_RWops *rw) | |
| 74 { | |
| 75 int retval = 0; | |
| 76 RWRefCounterData *data = (RWRefCounterData *) rw->hidden.unknown.data1; | |
| 77 data->refcount--; | |
| 78 if (data->refcount <= 0) | |
| 79 { | |
| 80 retval = data->rw->close(data->rw); | |
| 81 free(data); | |
| 82 SDL_FreeRW(rw); | |
| 83 } /* if */ | |
| 84 | |
| 85 return(retval); | |
| 86 } /* refcounter_close */ | |
| 87 | |
| 88 | |
| 89 void RWops_RWRefCounter_addRef(SDL_RWops *rw) | |
| 90 { | |
| 91 RWRefCounterData *data = (RWRefCounterData *) rw->hidden.unknown.data1; | |
| 92 data->refcount++; | |
| 93 } /* RWops_RWRefCounter_addRef */ | |
| 94 | |
| 95 | |
| 96 SDL_RWops *RWops_RWRefCounter_new(SDL_RWops *rw) | |
| 97 { | |
| 98 SDL_RWops *retval = NULL; | |
| 99 | |
| 100 if (rw == NULL) | |
| 101 { | |
| 102 SDL_SetError("NULL argument to RWops_RWRefCounter_new()."); | |
| 103 return(NULL); | |
| 104 } /* if */ | |
| 105 | |
| 106 retval = SDL_AllocRW(); | |
| 107 if (retval != NULL) | |
| 108 { | |
| 109 RWRefCounterData *data; | |
| 110 data = (RWRefCounterData *) malloc(sizeof (RWRefCounterData)); | |
| 111 if (data == NULL) | |
| 112 { | |
|
83
2b5ba7f33840
Stopped using SDL_OutOfMemory().
Ryan C. Gordon <icculus@icculus.org>
parents:
8
diff
changeset
|
113 SDL_SetError("Out of memory."); |
| 8 | 114 SDL_FreeRW(retval); |
| 115 retval = NULL; | |
| 116 } /* if */ | |
| 117 else | |
| 118 { | |
| 119 data->rw = rw; | |
| 120 data->refcount = 1; | |
| 121 retval->hidden.unknown.data1 = data; | |
| 122 retval->seek = refcounter_seek; | |
| 123 retval->read = refcounter_read; | |
| 124 retval->write = refcounter_write; | |
| 125 retval->close = refcounter_close; | |
| 126 } /* else */ | |
| 127 } /* if */ | |
| 128 | |
| 129 return(retval); | |
| 130 } /* RWops_RWRefCounter_new */ | |
| 131 | |
| 132 | |
| 133 /* end of extra_rwops.c ... */ | |
| 134 | |
| 135 |