/*
* _remix_track_add_layer_above (env, track, layer, above)
*
* Adds 'layer' above 'above'. If above is RemixNone, adds 'layer' on top
* of 'track'.
*/
RemixLayer *
_remix_track_add_layer_above (RemixEnv * env, RemixTrack * track,
RemixLayer * layer, RemixLayer * above)
{
layer->track = track;
if (above == RemixNone)
above = (RemixLayer *)
(cd_list_last (env, track->layers, CD_TYPE_POINTER)).s_pointer;
track->layers = cd_list_add_after (env, track->layers, CD_TYPE_POINTER,
CD_POINTER(layer), CD_POINTER(above));
remix_track_optimise (env, track);
return layer;
}
/* module init function */
CDList *
__gain_init (RemixEnv * env)
{
CDList * plugins = cd_list_new (env);
gain_plugin.process_scheme =
cd_set_insert (env, gain_plugin.process_scheme, GAIN_ENVELOPE_KEY,
CD_POINTER(&gain_envelope_scheme));
plugins = cd_list_prepend (env, plugins, CD_POINTER(&gain_plugin));
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;
}
CDScalar
cd_set_find (void * ctx, CDSet * set, int key)
{
CDSet * s = cd_set_find_item (ctx, set, key);
if (s == NULL) return CD_POINTER(NULL);
return s->data;
}
RemixLayer *
_remix_track_remove_layer (RemixEnv * env, RemixTrack * track,
RemixLayer * layer)
{
track->layers = cd_list_remove (env, track->layers, CD_TYPE_POINTER,
CD_POINTER(layer));
remix_track_optimise (env, track);
return layer;
}
/* module init function */
CDList *
__sndfile_init (RemixEnv * env)
{
CDList * plugins = cd_list_new (env);
int i, count;
SF_FORMAT_INFO info;
RemixNamedParameter * param;
sndfile_reader_plugin.init_scheme =
cd_set_insert (env, sndfile_reader_plugin.init_scheme, PATH_KEY,
CD_POINTER(&path_scheme));
plugins = cd_list_prepend (env, plugins,
CD_POINTER(&sndfile_reader_plugin));
format_scheme.constraint.list = cd_list_new (env);
sf_command (NULL, SFC_GET_FORMAT_MAJOR_COUNT, &count, sizeof (int)) ;
for (i = 0; i < count ; i++) {
info.format = i ;
sf_command (NULL, SFC_GET_FORMAT_MAJOR, &info, sizeof (info)) ;
param = remix_malloc (sizeof(RemixNamedParameter));
param->name = strdup (info.name);
param->parameter = CD_INT(info.format);
format_scheme.constraint.list =
cd_list_append (env, format_scheme.constraint.list, CD_POINTER(param));
}
sndfile_writer_plugin.init_scheme =
cd_set_insert (env, sndfile_writer_plugin.init_scheme, PATH_KEY,
CD_POINTER(&path_scheme));
plugins = cd_list_prepend (env, plugins,
CD_POINTER(&sndfile_writer_plugin));
return plugins;
}
CDSet *
cd_set_clone (void * ctx, CDSet * set, CDCloneFunc clone)
{
CDSet * new_set = cd_set_new (ctx);
CDSet * s;
void * new_data;
for (s = set; s; s = s->next) {
new_data = clone (ctx, s->data.s_pointer);
new_set = cd_set_insert (ctx, new_set, s->key, CD_POINTER(new_data));
}
return new_set;
}
CDList *
cd_list_clone (void * ctx, CDList * list, CDCloneFunc clone)
{
CDList * new_list = cd_list_new (ctx);
CDList * l;
CDScalar new_data;
for (l = list; l; l = l->next) {
new_data = CD_POINTER (clone (ctx, l->data.s_pointer));
new_list = cd_list_append (ctx, new_list, new_data);
}
return new_list;
}
/*
* gets layer below 'below'. If below is RemixNone, returns lowest layer
*/
RemixLayer *
_remix_track_get_layer_below (RemixEnv * env, RemixTrack * track,
RemixLayer * below)
{
CDList * below_item;
RemixLayer * layer;
if (track->layers == NULL) return RemixNone;
if (below == RemixNone) {
layer = (RemixLayer *) track->layers->data.s_pointer;
} else {
below_item = cd_list_find (env, track->layers, CD_TYPE_POINTER,
CD_POINTER(below));
if (below_item == NULL) return RemixNone;
below_item = below_item->prev;
if (below_item == NULL) return RemixNone;
layer = (RemixLayer *) below_item->data.s_pointer;
}
return layer;
}
/*
* gets layer above 'above'. If above is RemixNone, returns topmost layer
*/
RemixLayer *
_remix_track_get_layer_above (RemixEnv * env, RemixTrack * track,
RemixLayer * above)
{
CDList * above_item;
RemixLayer * layer;
if (track->layers == NULL) return RemixNone;
if (above == RemixNone) {
layer = (RemixLayer *)
(cd_list_last (env, track->layers, CD_TYPE_POINTER)).s_pointer;
} else {
above_item = cd_list_find (env, track->layers, CD_TYPE_POINTER,
CD_POINTER(above));
if (above_item == NULL) return RemixNone;
above_item = above_item->next;
if (above_item == NULL) return RemixNone;
layer = (RemixLayer *) above_item->data.s_pointer;
}
return layer;
}
int
main (int argc, char ** argv)
{
CDList * list, * list2;
void * ctx;
int a=1, b=2, d=4, f=6, g=7, k=11;
int v=22, w=23;
int z=26;
ctx = NULL;
printf ("creating new list\n");
list = cd_list_new (ctx);
ildump (ctx, list);
printf ("appending %d\n", f);
list = cd_list_append (ctx, list, (CDScalar)(void *)(&f));
ildump (ctx, list);
printf ("appending %d\n", k);
list = cd_list_append (ctx, list, CD_POINTER(&k));
ildump (ctx, list);
printf ("inserting %d\n", g);
list = cd_list_insert (ctx, list, CD_TYPE_POINTER, CD_POINTER(&g), int_gt);
ildump (ctx, list);
printf ("inserting %d\n", w);
list = cd_list_insert (ctx, list, CD_TYPE_POINTER, CD_POINTER(&w), int_gt);
ildump (ctx, list);
printf ("inserting %d\n", z);
list = cd_list_insert (ctx, list, CD_TYPE_POINTER, CD_POINTER(&z), int_gt);
ildump (ctx, list);
printf ("inserting %d\n", b);
list = cd_list_insert (ctx, list, CD_TYPE_POINTER, CD_POINTER(&b), int_gt);
ildump (ctx, list);
printf ("prepending %d\n", a);
list = cd_list_prepend (ctx, list, CD_POINTER(&a));
ildump (ctx, list);
printf ("removing %d\n", g);
list = cd_list_remove (ctx, list, CD_TYPE_POINTER, CD_POINTER(&g));
ildump (ctx, list);
printf ("adding %d after %d\n", d, b);
list = cd_list_add_after (ctx, list, CD_TYPE_POINTER, CD_POINTER(&d),
CD_POINTER(&b));
ildump (ctx, list);
printf ("adding %d before %d\n", v, w);
list = cd_list_add_before (ctx, list, CD_TYPE_POINTER, CD_POINTER(&v),
CD_POINTER(&w));
ildump (ctx, list);
printf ("cloning list\n");
list2 = cd_list_clone (ctx, list, int_clone);
ildump (ctx, list2);
printf ("freeing cloned list\n");
list2 = cd_list_free_all (ctx, list2);
ildump (ctx, list2);
exit (0);
}
