static RemixCount
remix_track_process (RemixEnv * env, RemixBase * base, RemixCount count,
RemixStream * input, RemixStream * output)
{
RemixTrack * track = (RemixTrack *)base;
CDList * l;
RemixBase * layer;
RemixStream * si, * so, * swap_stream;
RemixCount remaining = count, processed = 0, n = 0;
RemixCount mixlength = _remix_base_get_mixlength (env, track);
remix_dprintf ("PROCESS TRACK (%p, +%ld, %p -> %p) @ %ld\n",
track, count, input, output, remix_tell (env, base));
if (track->layers == RemixNone) {
remix_set_error (env, REMIX_ERROR_NOOP);
return 0;
}
while (remaining > 0) {
l = track->layers;
si = input;
so = track->_mixstream_a;
n = MIN (remaining, mixlength);
while (l) {
layer = (RemixBase *)l->data.s_pointer;
if (si == input) {
swap_stream = track->_mixstream_b;
} else {
swap_stream = si;
remix_seek (env, (RemixBase *)si, 0, SEEK_SET);
}
if (l->next == RemixNone) {
so = output;
} else {
remix_seek (env, (RemixBase *)so, 0, SEEK_SET);
}
n = remix_process (env, layer, n, si, so);
l = l->next;
/* swap si, st using swap_stream as evaluated above */
si = so; so = swap_stream;
}
remaining -= n;
processed += n;
}
remix_dprintf ("[remix_track_process] processed %ld\n", processed);
return processed;
}
static RemixCount
remix_sndfile_write_from_chunk (RemixEnv * env, RemixChunk * chunk,
RemixCount offset, RemixCount count,
int channelname, void * data)
{
RemixBase * sndfile = (RemixBase *)data;
RemixPCM * d;
RemixCount remaining = count, read = 0, n;
RemixSndfileInstance * si = (RemixSndfileInstance *) sndfile->instance_data;
remix_dprintf ("[remix_sndfile_write_from_chunk] (%p, +%ld) @ %ld\n",
sndfile, count, remix_tell (env, sndfile));
d = &chunk->data[offset];
while (remaining > 0) {
n = MIN (remaining, BLOCK_FRAMES);
n = sf_write_float (si->file, d, n);
if (n == 0) { /* EOF */
n = remaining;
}
remaining -= n;
read += n;
d += n;
}
return read;
}
static CDList *
init_dynamic_plugins_dir (RemixEnv * env, char * dirname)
{
CDList * plugins = cd_list_new (env);
DIR * dir;
struct dirent * dirent;
char * name;
static char buf[BUFLEN];
struct stat statbuf;
dir = opendir (dirname);
if (!dir) {
/* fail silently */
return CD_EMPTY_LIST;
}
while ((dirent = readdir (dir)) != NULL) {
name = dirent->d_name;
remix_dprintf ("[init_dynamic_plugins_dir] trying %s ... ", name);
snprintf (buf, BUFLEN, "%s/%s", dirname, name);
if (stat (buf, &statbuf) == -1) {
remix_set_error (env, REMIX_ERROR_SYSTEM);
} else if (remix_stat_regular (statbuf.st_mode)) {
plugins = cd_list_join (env, plugins, remix_plugin_init (env, buf));
}
}
closedir (dir);
return plugins;
}
static CDList *
remix_plugin_init (RemixEnv * env, const char * path)
{
void * module;
CDList * l;
RemixPluginInitFunc init;
module = dlopen (path, RTLD_NOW);
if (!module) {
remix_dprintf ("[remix_plugin_init] Unable to open %s: %s\n", path,
dlerror ());
remix_set_error (env, REMIX_ERROR_SYSTEM);
return CD_EMPTY_LIST;
}
/* Check that this module has not already been loaded (eg. if it is
* a symlink etc.) */
for (l = modules_list; l; l = l->next) {
if (l->data.s_pointer == module) {
dlclose (module);
return CD_EMPTY_LIST;
}
}
modules_list = cd_list_append (env, modules_list, CD_POINTER(module));
if ((init = dlsym (module, "remix_load")) != NULL) {
return init (env);
}
return CD_EMPTY_LIST;
}
static RemixCount
remix_track_twolayer_process (RemixEnv * env, RemixBase * base,
RemixCount count, RemixStream * input,
RemixStream * output)
{
RemixTrack * track = (RemixTrack *)base;
CDList * l;
RemixBase * layer1, * layer2;
RemixCount remaining = count, processed = 0, n = 0;
RemixStream * mix = track->_mixstream_a;
RemixCount current_offset = remix_tell (env, base);
RemixCount mixlength = _remix_base_get_mixlength (env, track);
remix_dprintf ("PROCESS TRACK [twolayer] (%p, +%ld, %p -> %p) @ %ld\n",
track, count, input, output, current_offset);
l = track->layers;
layer1 = (RemixBase *)l->data.s_pointer;
remix_seek (env, (RemixBase *)layer1, current_offset, SEEK_SET);
l = l->next;
layer2 = (RemixBase *)l->data.s_pointer;
remix_seek (env, (RemixBase *)layer2, current_offset, SEEK_SET);
while (remaining > 0) {
n = MIN (remaining, mixlength);
remix_seek (env, (RemixBase *)mix, 0, SEEK_SET);
n = remix_process (env, layer1, n, input, mix);
remix_seek (env, (RemixBase *)mix, 0, SEEK_SET);
n = remix_process (env, layer2, n, mix, output);
remaining -= n;
processed += n;
}
remix_dprintf ("*** PRE-SEEK: track @ %ld\n", remix_tell (env, base));
/*remix_seek (env, base, current_offset + processed, SEEK_SET);*/
remix_dprintf ("*** POST-SEEK: track @ %ld\n", remix_tell (env, base));
remix_dprintf ("[remix_track_twolayer_process] processed %ld\n", processed);
return processed;
}
static RemixCount
remix_sndfile_read_into_chunk (RemixEnv * env, RemixChunk * chunk,
RemixCount offset, RemixCount count,
int channelname, void * data)
{
RemixBase * sndfile = (RemixBase *)data;
RemixPCM * d, * p;
RemixCount remaining = count, written = 0, n, i;
RemixSndfileInstance * si = (RemixSndfileInstance *)sndfile->instance_data;
remix_dprintf ("[remix_sndfile_read_into_chunk] (%p, +%ld) @ %ld\n",
sndfile, count, remix_tell (env, sndfile));
d = &chunk->data[offset];
n = MIN (remaining, BLOCK_FRAMES);
if (channelname == 0)
remix_sndfile_read_update (env, sndfile, n);
n = MIN (si->pcm_n, remaining);
p = si->pcm;
p += channelname;
for (i = 0; i < n; i++) {
*d++ = *p;
p += si->info.channels;
}
if (n == 0) { /* EOF */
n = _remix_pcm_set (d, 0.0, remaining);
}
remaining -= n;
written += n;
#if 0 /* mono only */
d = &chunk->data[offset];
while (remaining > 0) {
n = MIN (remaining, BLOCK_FRAMES);
n = sf_readf_float (si->file, d, n);
if (n == 0) { /* EOF */
n = _remix_pcm_set (d, 0.0, remaining);
}
remaining -= n;
written += n;
d += n;
}
#endif
return written;
}
static RemixCount
remix_gain_process (RemixEnv * env, RemixBase * base, RemixCount count,
RemixStream * input, RemixStream * output)
{
RemixCount remaining = count, processed = 0, n;
RemixCount output_offset;
RemixCount mixlength = remix_base_get_mixlength (env, base);
RemixBase * gain_envelope;
RemixGain * gi = remix_base_get_instance_data (env, base);
remix_dprintf ("PROCESS GAIN (%p, +%ld) @ %ld\n", base, count,
remix_tell (env, base));
gain_envelope =
(RemixBase *) (remix_get_parameter (env, base, GAIN_ENVELOPE_KEY)).s_pointer;
if (gain_envelope == RemixNone) {
remix_set_error (env, REMIX_ERROR_NOOP);
return -1;
}
while (remaining > 0) {
n = MIN (remaining, mixlength);
output_offset = remix_tell (env, (RemixBase *)output);
n = remix_stream_copy (env, input, output, n);
remix_seek (env, (RemixBase *)gi->_gain_envstream, 0, SEEK_SET);
n = remix_process (env, gain_envelope, n, RemixNone,
gi->_gain_envstream);
remix_seek (env, (RemixBase *)gi->_gain_envstream, 0, SEEK_SET);
remix_seek (env, (RemixBase *)output, output_offset, SEEK_SET);
n = remix_stream_mult (env, gi->_gain_envstream, output, n);
remaining -= n;
processed += n;
}
remix_dprintf ("[remix_gain_process] processed %ld\n", processed);
return processed;
}
static RemixCount
remix_track_onelayer_process (RemixEnv * env, RemixBase * base,
RemixCount count, RemixStream * input,
RemixStream * output)
{
RemixTrack * track = (RemixTrack *)base;
CDList * l = track->layers;
RemixBase * layer = (RemixBase *)l->data.s_pointer;
RemixCount n;
remix_dprintf ("PROCESS TRACK [onelayer] (%p, +%ld, %p -> %p) @ %ld\n",
track, count, input, output, remix_tell (env, base));
n = remix_process (env, layer, count, input, output);
remix_dprintf ("[remix_track_onelayer_process] processed %ld\n", n);
return n;
}
static RemixCount
remix_track_length (RemixEnv * env, RemixBase * base)
{
RemixTrack * track = (RemixTrack *)base;
RemixCount length, maxlength = 0;
CDList * l;
RemixLayer * layer;
for (l = track->layers; l; l = l->next) {
layer = (RemixLayer *)l->data.s_pointer;
length = remix_length (env, (RemixBase *)layer);
remix_dprintf ("[remix_track_length] found layer %p length %ld\n",
layer, length);
maxlength = MAX (maxlength, length);
}
return maxlength;
}