void compositor_audioclip_modified(GF_Node *node)
{
M_AudioClip *ac = (M_AudioClip *)node;
AudioClipStack *st = (AudioClipStack *) gf_node_get_private(node);
if (!st) return;
st->failure = 0;
/*MPEG4 spec is not clear about that , so this is not forbidden*/
if (st->input.is_open && st->input.is_open) {
if (gf_sc_audio_check_url(&st->input, &ac->url)) {
gf_sc_audio_stop(&st->input);
gf_sc_audio_open(&st->input, &ac->url, 0, -1);
/*force unregister to resetup audio cfg*/
gf_sc_audio_unregister(&st->input);
gf_sc_invalidate(st->input.compositor, NULL);
}
}
//update state if we're active
if (ac->isActive) {
audioclip_update_time(&st->time_handle);
/*we're no longer active fon't check for reactivation*/
if (!ac->isActive) return;
}
/*make sure we are still registered*/
if (!st->time_handle.is_registered && !st->time_handle.needs_unregister)
gf_sc_register_time_node(st->input.compositor, &st->time_handle);
else
st->time_handle.needs_unregister = 0;
}
void compositor_audiosource_modified(GF_Node *node)
{
M_AudioSource *as = (M_AudioSource *)node;
AudioSourceStack *st = (AudioSourceStack *) gf_node_get_private(node);
if (!st) return;
/*MPEG4 spec is not clear about that , so this is not forbidden*/
if (gf_sc_audio_check_url(&st->input, &as->url)) {
if (st->input.is_open) gf_sc_audio_stop(&st->input);
/*force unregister to resetup audio cfg*/
gf_sc_audio_unregister(&st->input);
gf_sc_invalidate(st->input.compositor, NULL);
if (st->is_active) gf_sc_audio_open(&st->input, &as->url, 0, -1);
}
//update state if we're active
if (st->is_active) {
audiosource_update_time(&st->time_handle);
if (!st->is_active) return;
}
/*make sure we are still registered*/
if (!st->time_handle.is_registered && !st->time_handle.needs_unregister)
gf_sc_register_time_node(st->input.compositor, &st->time_handle);
else
st->time_handle.needs_unregister = 0;
}
void compositor_init_audiosource(GF_Compositor *compositor, GF_Node *node)
{
AudioSourceStack *st;
GF_SAFEALLOC(st, AudioSourceStack);
gf_sc_audio_setup(&st->input, compositor, node);
st->time_handle.UpdateTimeNode = audiosource_update_time;
st->time_handle.udta = node;
gf_node_set_private(node, st);
gf_node_set_callback_function(node, audiosource_traverse);
gf_sc_register_time_node(compositor, &st->time_handle);
}
void compositor_init_animationstream(GF_Compositor *compositor, GF_Node *node)
{
AnimationStreamStack *st;
GF_SAFEALLOC(st, AnimationStreamStack);
st->compositor = compositor;
st->time_handle.UpdateTimeNode = animationstream_update_time;
st->time_handle.udta = node;
gf_node_set_private(node, st);
gf_node_set_callback_function(node, animationstream_destroy);
gf_sc_register_time_node(compositor, &st->time_handle);
}
void compositor_audiobuffer_modified(GF_Node *node)
{
M_AudioBuffer *ab = (M_AudioBuffer *)node;
AudioBufferStack *st = (AudioBufferStack *) gf_node_get_private(node);
if (!st) return;
//update state if we're active
if (ab->isActive)
audiobuffer_update_time(&st->time_handle);
/*make sure we are still registered*/
if (!st->time_handle.is_registered && !st->time_handle.needs_unregister)
gf_sc_register_time_node(st->output.compositor, &st->time_handle);
else
st->time_handle.needs_unregister = 0;
}
void compositor_timesensor_modified(GF_Node *t)
{
M_TimeSensor *ts = (M_TimeSensor *)t;
TimeSensorStack *stack = (TimeSensorStack *) gf_node_get_private(t);
if (!stack) return;
if (ts->isActive) timesensor_update_time(&stack->time_handle);
if (!ts->isActive) stack->store_info = 1;
if (ts->enabled) {
stack->time_handle.needs_unregister = 0;
if (!stack->time_handle.is_registered) {
gf_sc_register_time_node(stack->compositor, &stack->time_handle);
}
}
}
void compositor_init_timesensor(GF_Compositor *compositor, GF_Node *node)
{
TimeSensorStack *st;
GF_SAFEALLOC(st, TimeSensorStack);
st->time_handle.UpdateTimeNode = timesensor_update_time;
st->time_handle.udta = node;
st->store_info = 1;
st->compositor = compositor;
#ifndef GPAC_DISABLE_X3D
st->is_x3d = (gf_node_get_tag(node)==TAG_X3D_TimeSensor) ? 1 : 0;
#endif
gf_node_set_private(node, st);
gf_node_set_callback_function(node, timesensor_destroy);
/*time sensor needs to be run only if def'ed, otherwise it doesn't impact scene*/
//if (gf_node_get_id(node))
gf_sc_register_time_node(compositor, &st->time_handle);
}
void compositor_animationstream_modified(GF_Node *node)
{
M_AnimationStream *as = (M_AnimationStream *)node;
AnimationStreamStack *st = (AnimationStreamStack *) gf_node_get_private(node);
if (!st) return;
/*update state if we're active*/
if (as->isActive)
animationstream_update_time(&st->time_handle);
/*check URL change*/
animationstream_check_url(st, as);
if (!st->time_handle.is_registered && !st->time_handle.needs_unregister)
gf_sc_register_time_node(st->compositor, &st->time_handle);
else
st->time_handle.needs_unregister = 0;
}
void compositor_init_audiobuffer(GF_Compositor *compositor, GF_Node *node)
{
AudioBufferStack *st;
GF_SAFEALLOC(st, AudioBufferStack);
/*use our private input*/
setup_audiobufer(&st->output, compositor, node);
st->add_source = audiobuffer_add_source;
st->time_handle.UpdateTimeNode = audiobuffer_update_time;
st->time_handle.udta = node;
st->set_duration = 1;
st->am = gf_mixer_new(NULL);
st->new_inputs = gf_list_new();
gf_node_set_private(node, st);
gf_node_set_callback_function(node, audiobuffer_traverse);
gf_sc_register_time_node(compositor, &st->time_handle);
}
void compositor_movietexture_modified(GF_Node *node)
{
M_MovieTexture *mt = (M_MovieTexture *)node;
MovieTextureStack *st = (MovieTextureStack *) gf_node_get_private(node);
if (!st) return;
/*if open and changed, stop and play*/
if (gf_sc_texture_check_url_change(&st->txh, &mt->url)) {
if (st->txh.is_open) gf_sc_texture_stop(&st->txh);
if (mt->isActive) gf_sc_texture_play(&st->txh, &mt->url);
}
/*update state if we're active*/
else if (mt->isActive) {
movietexture_update_time(&st->time_handle);
if (!mt->isActive) return;
}
/*reregister if needed*/
st->time_handle.needs_unregister = 0;
if (!st->time_handle.is_registered) gf_sc_register_time_node(st->txh.compositor, &st->time_handle);
}
void compositor_init_movietexture(GF_Compositor *compositor, GF_Node *node)
{
MovieTextureStack *st;
GF_SAFEALLOC(st, MovieTextureStack);
gf_sc_texture_setup(&st->txh, compositor, node);
st->txh.update_texture_fcnt = movietexture_update;
st->time_handle.UpdateTimeNode = movietexture_update_time;
st->time_handle.udta = node;
st->fetch_first_frame = 1;
st->txh.flags = 0;
if (((M_MovieTexture*)node)->repeatS) st->txh.flags |= GF_SR_TEXTURE_REPEAT_S;
if (((M_MovieTexture*)node)->repeatT) st->txh.flags |= GF_SR_TEXTURE_REPEAT_T;
#ifndef GPAC_DISABLE_X3D
st->is_x3d = (gf_node_get_tag(node)==TAG_X3D_MovieTexture) ? 1 : 0;
#endif
gf_node_set_private(node, st);
gf_node_set_callback_function(node, movietexture_destroy);
gf_sc_register_time_node(compositor, &st->time_handle);
}
