[00:19:39] *** Walt has quit IRC
[00:33:42] * KittyCat is back.
[00:36:42] *** juanmabc has quit IRC
[00:45:21] *** Walt has joined #openal
[00:45:21] *** ChanServ sets mode: +v Walt
[00:47:02] *** prophile has quit IRC
[02:09:13] *** juanmabc has joined #openal
[02:09:13] *** ChanServ sets mode: +v juanmabc
[02:20:45] *** juanmabc has quit IRC
[03:26:05] <KittyCat> hmm. I'm trying to get alut to dynamicly load libvorbis and libogg. but if I have warnings on, I get tons of
[03:26:07] <KittyCat> warning: ISO C forbids assignment between function pointer and ?void *?
[03:26:18] <KittyCat> where trying to load the functions
[03:27:05] <KittyCat> how am I supposed to load a function (where dlsym returns void*) without writing out each function individually? libogg and libvorbis have a lot of functions..
[03:52:53] <KittyCat> heh. it doesn't even let me use a proper cast
[03:53:04] <KittyCat> warning: ISO C forbids conversion of object pointer to function pointer type
[03:53:25] <KittyCat> ISO C didn't have a lot of forsight into dynamicly loading libs/functions, did it?
[09:20:11] *** predaeus has joined #openal
[09:20:13] *** ChanServ sets mode: +v predaeus
[09:56:37] *** Walt has quit IRC
[10:02:08] *** Walt has joined #openal
[10:02:08] *** ChanServ sets mode: +v Walt
[10:51:19] *** predaeus has quit IRC
[11:25:15] *** Walt has quit IRC
[11:36:16] *** Walt has joined #openal
[11:36:16] *** ChanServ sets mode: +v Walt
[12:07:23] *** prophile has joined #openal
[12:07:23] *** ChanServ sets mode: +v prophile
[14:41:30] *** kb1ooo has joined #openal
[14:41:30] *** ChanServ sets mode: +v kb1ooo
[15:54:57] *** juanmabc has joined #openal
[15:54:57] *** ChanServ sets mode: +v juanmabc
[16:35:58] <kb1ooo> is there any code floaing around out there that adapts the posix system calls used in the oss api to use openal?
[16:38:40] <KittyCat> you mean like an oss->openal wrapper?
[16:38:42] <kb1ooo> e.g. i have a simple app that i'm porting from oss to openal.  I'm using funopen which maps a FILE* stream to a set of write, read, close functions.
[16:38:47] <kb1ooo> yes, exactly
[16:39:09] <KittyCat> nope. the two are ratehr different
[16:39:38] <KittyCat> with oss, you meainly stream out audio. with openal, you *can* stream out audio, but it's more for moving 3d sounds and getting everything mixed together
[16:39:56] <kb1ooo> well, what I'm doing is the funopen (available on BSD and OSX) trick and then do streaming openal
[16:40:23] <KittyCat> what does funopen do?
[16:41:55] <kb1ooo> creates a FILE* stream for you such that write, open, and close system calls on its file descriptor to write, open and close functions that you define
[16:42:28] <kb1ooo> to write -> map to write
[16:43:01] <KittyCat> ah
[16:43:44] <kb1ooo> it let's you carry around data as well.
[16:44:06] <kb1ooo> anyway, i just figured that someone out there has already done something similar.
[16:44:14] <KittyCat> well, the most you could do is create a set of AL buffers and queue them on a source
[16:44:38] <KittyCat> when data is written, you pop a buffer off of the source, write to it, requeue it, then make sure it's still playing
[16:44:43] <kb1ooo> ya, that's what i was going to do.
[16:45:39] <kb1ooo> i was going to make it pseudo blocking so that a write call waits until one of the buffers is free before returning.
[16:46:42] <KittyCat> yeah, that's how OSS works, generally
[16:46:54] <KittyCat> it blocks until the data you gave it is all written out
[16:53:28] <kb1ooo> yeah, that's what I'm trying to achieve.   The nice thing with oss it seems is that there's no buffering.  you can call write separately on each sample without problems, i think.
[16:53:45] <kb1ooo> on each -> for each
[16:54:43] <kb1ooo> btw, what's the smallest safe buffer size with openal?
[16:55:15] <kb1ooo> i think that i've read 4k?
[16:58:25] <KittyCat> that's hard to determine, really
[16:59:25] <KittyCat> it's whatever the size the mixer decides to you. but that's not really visible to apps
[16:59:50] <KittyCat> 4K or so should be alright, I think
[17:00:23] <kb1ooo> the funopen thing is cool.  it's one of the few things that i've found to be easier in C than C++.   Deriving from ios to make a custom iostream is more complicated.
[17:00:54] <kb1ooo> ok, thanks, I figured it'd be hard to nail down.
[17:06:35] <KittyCat> kind of odd to route OSS through OpenAL, though. why not just use OpenAL?
[17:06:55] *** predaeus has joined #openal
[17:06:55] *** ChanServ sets mode: +v predaeus
[17:11:12] <kb1ooo> I would if it were my app.  So, I rather not disturb the code base.  It also makes it easy to maintain the option of building it against oss or openal.
[17:13:13] <kb1ooo> it makes it so you essentially just swap in the init method that gives you the file descriptor.
[17:13:24] <kb1ooo> performance wise, I don't think that anything is lost.
[17:28:40] <kb1ooo> ok, bbl thanks for your help.
[17:38:27] *** kb1ooo_ has joined #openal
[17:38:27] *** ChanServ sets mode: +v kb1ooo_
[17:46:33] *** kb1ooo has quit IRC
[17:48:12] *** prophile has quit IRC
[17:53:18] * KittyCat is away: sleep
[18:29:11] *** prophile has joined #openal
[18:29:11] *** ChanServ sets mode: +v prophile
[19:06:34] <kb1ooo_> KittyCat, I've got some comments on your "using C++ in alut thread".  If I join the list to post them, I'll get majorly distracted :)
[19:06:41] <kb1ooo_> ping me when ur awake.
[20:03:53] *** echelog has joined #openal
[20:03:53] *** ChanServ sets mode: +v echelog
[20:07:57] *** echelog has joined #openal
[20:07:57] *** ChanServ sets mode: +v echelog
[20:12:02] *** echelog` has joined #openal
[20:12:02] *** ChanServ sets mode: +v echelog`
[20:16:06] *** echelog has joined #openal
[20:16:06] *** ChanServ sets mode: +v echelog
[20:20:12] *** echelog has joined #openal
[20:20:12] *** ChanServ sets mode: +v echelog
[20:24:17] *** echelog has joined #openal
[20:24:17] *** ChanServ sets mode: +v echelog
[20:28:23] *** echelog has joined #openal
[20:28:23] *** ChanServ sets mode: +v echelog
[20:32:31] *** echelog` has joined #openal
[20:32:33] *** ChanServ sets mode: +v echelog`
[20:32:39] *** kb1ooo_ has quit IRC
[20:36:37] *** echelog has joined #openal
[20:36:37] *** ChanServ sets mode: +v echelog
[20:40:43] *** echelog has joined #openal
[20:40:43] *** ChanServ sets mode: +v echelog
[20:44:46] *** echelog has joined #openal
[20:44:46] *** ChanServ sets mode: +v echelog
[20:48:51] *** echelog has joined #openal
[20:48:51] *** ChanServ sets mode: +v echelog
[20:52:57] *** echelog` has joined #openal
[20:52:57] *** ChanServ sets mode: +v echelog`
[20:57:04] *** echelog has joined #openal
[20:57:04] *** ChanServ sets mode: +v echelog
[21:01:08] *** echelog has joined #openal
[21:01:08] *** ChanServ sets mode: +v echelog
[21:05:13] *** echelog has joined #openal
[21:05:13] *** ChanServ sets mode: +v echelog
[21:09:19] *** echelog` has joined #openal
[21:09:19] *** ChanServ sets mode: +v echelog`
[21:13:24] *** echelog has joined #openal
[21:13:25] *** ChanServ sets mode: +v echelog
[21:17:28] *** echelog has joined #openal
[21:17:28] *** ChanServ sets mode: +v echelog
[21:21:36] *** echelog has joined #openal
[21:21:36] *** ChanServ sets mode: +v echelog
[21:25:42] *** echelog has joined #openal
[21:25:42] *** ChanServ sets mode: +v echelog
[21:29:48] *** echelog has joined #openal
[21:29:48] *** ChanServ sets mode: +v echelog
[21:33:54] *** echelog` has joined #openal
[21:33:54] *** ChanServ sets mode: +v echelog`
[21:38:02] *** echelog has joined #openal
[21:38:04] *** ChanServ sets mode: +v echelog
[21:42:09] *** echelog has joined #openal
[21:42:09] *** ChanServ sets mode: +v echelog
[21:46:16] *** echelog has joined #openal
[21:46:18] *** ChanServ sets mode: +v echelog
[21:50:24] *** echelog has joined #openal
[21:50:24] *** ChanServ sets mode: +v echelog
[21:54:31] *** echelog has joined #openal
[21:54:31] *** ChanServ sets mode: +v echelog
[21:54:37] <Mazon> sorry, for openal-soft
[22:07:38] *** echelog has joined #openal
[22:07:40] *** ChanServ sets mode: +v echelog
[22:11:13] *** echelog has joined #openal
[22:11:13] *** ChanServ sets mode: +v echelog
[22:15:16] *** echelog has joined #openal
[22:15:16] *** ChanServ sets mode: +v echelog
[22:19:22] *** echelog has joined #openal
[22:19:22] *** ChanServ sets mode: +v echelog
[22:26:47] *** echelog has joined #openal
[22:26:47] *** ChanServ sets mode: +v echelog
[22:31:03] *** echelog has joined #openal
[22:31:03] *** ChanServ sets mode: +v echelog
[22:59:17] *** echelog has joined #openal
[22:59:17] *** ChanServ sets mode: +v echelog
[23:12:36] *** echelog has joined #openal
[23:12:37] *** ChanServ sets mode: +v echelog
[23:13:25] *** Walt has joined #openal
[23:13:25] *** ChanServ sets mode: +v Walt





top