10 Nov
2008
10 Nov
'08
4:34 a.m.
For a new audio application I need to code a JACK client with C++. So
far I did it only with C and have a problem with giving the pointer to
the callback process function, which is a method now. So what is the
best performing solution? Is a delegate function a good idea, being
static and triggering the method in the objectinstance?
Cheers,
Malte
--
----
media art + development
http://www.block4.com
current events:
exhibition spame-moi La Motte-Servolex, France 17.10.-20.12.2008
10 Nov
10 Nov
4:56 a.m.
Es geschah am Monday 10 November 2008 als Malte Steiner schrieb:
For a new audio application I need to code a JACK
client with C++. So
far I did it only with C and have a problem with giving the pointer to
the callback process function, which is a method now. So what is the
best performing solution? Is a delegate function a good idea, being
static and triggering the method in the objectinstance?
You don't really have options here. Since Jack only accepts function pointers
of the exact given prototype for callbacks. So you can either create a) as
usual a C style function in your .cpp file or b) a static class method, where
in both solutions you would then call the respective method of the object
instance.
CU
Christian
5:10 a.m.
Malte Steiner wrote:
For a new audio application I need to code a JACK
client with C++. So
far I did it only with C and have a problem with giving the pointer to
the callback process function, which is a method now. So what is the
best performing solution? Is a delegate function a good idea, being
static and triggering the method in the objectinstance?
No idea what the best solution might be, but here's an approach I've used...
class AudioOutputJACK
{
public:
[ ... ]
private:
static int ProcessJackCallback(jack_nframes_t nframes, void* arg);
}
And in the class initialisation,
if ((chk = jack_set_process_callback(jack_client, ProcessJackCallback,
this)))
{ ... }
And the callback function ...
int AudioOutputJACK::ProcessJackCallback(jack_nframes_t nframes, void* arg)
{
AudioOutputJACK* audJ = static_cast<AudioOutputJACK*>(arg);
// then stuff like ...
size_t bytes_requested = nframes * audJ->jack_frame_bytes;
size_t bytes_read = jack_ringbuffer_read(audJ->ringbuffJ,
(char*)audJ->jack_tfer_buf,
bytes_requested);
etc ...
}
cheers, Cal
5:26 a.m.
On Mon, 2008-11-10 at 20:10 +1100, cal wrote:
Malte Steiner wrote:
i like to add
static int _process_callback (jack_nframes_t nframes, void*
arg) {
ThisObjectType* foo = (ThisObjectType*) arg;
return foo->process_callback (nframes);
}
int process_callback (jack_nframes_t nframes) {
/* the real thing, as a normal member function */
}
the code is a bit cleaner that way.
For a new audio application I need to code a JACK
client with C++. So
far I did it only with C and have a problem with giving the pointer to
the callback process function, which is a method now. So what is the
best performing solution? Is a delegate function a good idea, being
static and triggering the method in the objectinstance?
No idea what the best solution might be, but here's an approach I've used...
class AudioOutputJACK
{
public:
[ ... ]
private:
static int ProcessJackCallback(jack_nframes_t nframes, void* arg);
} 
5:51 a.m.
Why don't you take it one step further, and call a method of audJ
right away, so you don't have use audJ-> all the time?
class AudioOutputJACK
{
[...]
static int sProcessJackCallback(jack_nframes_t nframes, void* arg)
{
AudioOutputJACK* audJ = static_cast<AudioOutputJACK*>(arg);
return audJ->ProcessJackCallback(nframes)
}
int ProcessJackCallback(jack_nframes_t nframes)
{
[...]
}
};
On Nov 10, 2008, at 10:10 AM, cal wrote:
Malte Steiner wrote:
For a new audio application I need to code a JACK
client with C++. So
far I did it only with C and have a problem with giving the pointer
to
the callback process function, which is a method now. So what is the
best performing solution? Is a delegate function a good idea, being
static and triggering the method in the objectinstance?
No idea what the best solution might be, but here's an approach I've
used...
class AudioOutputJACK
{
public:
[ ... ]
private:
static int ProcessJackCallback(jack_nframes_t nframes, void*
arg);
}
And in the class initialisation,
if ((chk = jack_set_process_callback(jack_client,
ProcessJackCallback,
this)))
{ ... }
And the callback function ...
int AudioOutputJACK::ProcessJackCallback(jack_nframes_t nframes,
void* arg)
{
AudioOutputJACK* audJ = static_cast<AudioOutputJACK*>(arg);
// then stuff like ...
size_t bytes_requested = nframes * audJ->jack_frame_bytes;
size_t bytes_read = jack_ringbuffer_read(audJ->ringbuffJ,
(char*)audJ->jack_tfer_buf,
bytes_requested);
etc ...
}
cheers, Cal
_______________________________________________
Linux-audio-dev mailing list
Linux-audio-dev(a)lists.linuxaudio.org
http://lists.linuxaudio.org/mailman/listinfo/linux-audio-dev
5:56 a.m.
Maarten de Boer wrote:
Why don't you take it one step further, and call a
method of audJ
right away, so you don't have use audJ-> all the time?
class AudioOutputJACK
{
[...]
static int sProcessJackCallback(jack_nframes_t nframes, void* arg)
{
AudioOutputJACK* audJ = static_cast<AudioOutputJACK*>(arg);
return audJ->ProcessJackCallback(nframes)
}
int ProcessJackCallback(jack_nframes_t nframes)
{
[...]
}
};
That's where I originally started, but I came to the conclusion it was just
extra verbosity and complexity for no real benefit. For the amount of work
that gets done in the callback, audJ-> is fine for my needs.
cheers, Cal
1:05 p.m.
Malte Steiner wrote:
For a new audio application I need to code a JACK
client with C++. So
far I did it only with C and have a problem with giving the pointer to
the callback process function, which is a method now. So what is the
This is what I use and one way (of many) to do it:
http://libjackmm.cvs.sourceforge.net/viewvc/libjackmm/libJackMM/
Release tarball is outdated (I should remember to release a new one),
but the repository version should be OK.
BR,
- Jussi
5:56 p.m.
thanks for the help, going to check out tonight. The software is going
to be a synth/sequencer/visual combo, mainly for live performance. Its
mainly for me but it will be free and open source anyway. The synth is
going to have dynamic wavetables, like the old PPG synthesizers, which
are created from the pixelinformation of images. I use that project also
as a study on userinterfaces because I am not that happy with simulated
knobs and mouse interaction.
Next year I will get back to AMS and Minicomputer and provide some
updates and perhaps a new, all purpose wavetable synth. I keep you
informed...
Cheers,
Malte
--
----
media art + development
http://www.block4.com
current events:
exhibition spame-moi La Motte-Servolex, France 17.10.-20.12.2008
5805
days inactive
5805
days old
linux-audio-dev@lists.linuxaudio.org
7 comments
6 participants
participants (6)
-
cal -
Christian Schoenebeck -
Jussi Laako -
Maarten de Boer -
Malte Steiner -
Paul Davis