void compositor_compositetexture_sensor_delete(GF_Node *composite_appear, GF_SensorHandler *hdl)
{
CompositeTextureStack *stack = gf_node_get_private(composite_appear);
gf_list_del_item(stack->previous_sensors, hdl);
gf_list_del_item(stack->sensors, hdl);
if (stack->temp_sensors)
gf_list_del_item(stack->temp_sensors, hdl);
if (stack->temp_previous_sensors)
gf_list_del_item(stack->temp_previous_sensors, hdl);
}
void DestroyKeySensor(GF_Node *node, void *rs, Bool is_destroy)
{
if (is_destroy) {
GF_Terminal *term = (GF_Terminal *) gf_node_get_private(node);
gf_list_del_item(term->x3d_sensors, node);
}
}
GF_EXPORT
void gf_sm_stream_del(GF_SceneManager *ctx, GF_StreamContext *sc)
{
if (gf_list_del_item(ctx->streams, sc)>=0) {
gf_sm_delete_stream(sc);
}
}
static void traverse_envtest(GF_Node *node, void *rs, Bool is_destroy)
{
if (is_destroy) {
GF_Compositor *compositor = gf_node_get_private(node);
gf_list_del_item(compositor->env_tests, node);
}
}
void gf_sg_route_unqueue(GF_SceneGraph *sg, GF_Route *r)
{
/*get the top level scene*/
while (sg->parent_scene) sg = sg->parent_scene;
/*remove route from queue list*/
gf_list_del_item(sg->routes_to_activate, r);
}
void gf_sr_register_extra_graph(GF_Renderer *sr, GF_SceneGraph *extra_scene, Bool do_remove)
{
gf_sr_lock(sr, 1);
if (do_remove) gf_list_del_item(sr->extra_scenes, extra_scene);
else if (gf_list_find(sr->extra_scenes, extra_scene)<0) gf_list_add(sr->extra_scenes, extra_scene);
gf_sr_lock(sr, 0);
}
/* when a timed element restarts, it needs to be removed and reinserted at its proper location */
static void gf_smil_reorder_timing(SMIL_Timing_RTI *rti)
{
GF_SceneGraph * sg = rti->timed_elt->sgprivate->scenegraph;
while (sg->parent_scene) sg = sg->parent_scene;
gf_list_del_item(sg->smil_timed_elements, rti);
gf_smil_timing_add_to_sg(sg, rti);
}
void gf_codec_del(GF_Codec *codec)
{
if (!codec || !codec->inChannels)
return;
if (gf_list_count(codec->inChannels)) return;
if (!(codec->flags & GF_ESM_CODEC_IS_USE)) {
switch (codec->type) {
/*input sensor streams are handled internally for now*/
#ifndef GPAC_DISABLE_VRML
case GF_STREAM_INTERACT:
gf_mx_p(codec->odm->term->net_mx);
gf_isdec_del(codec->decio);
gf_list_del_item(codec->odm->term->input_streams, codec);
gf_mx_v(codec->odm->term->net_mx);
break;
#endif
default:
gf_modules_close_interface((GF_BaseInterface *) codec->decio);
break;
}
}
if (codec->CB) gf_cm_del(codec->CB);
codec->CB = NULL;
if (codec->inChannels) gf_list_del(codec->inChannels);
codec->inChannels = NULL;
gf_free(codec);
}
void compositor_init_compositetexture2d(GF_Compositor *compositor, GF_Node *node)
{
M_CompositeTexture2D *c2d = (M_CompositeTexture2D *)node;
CompositeTextureStack *st;
GF_SAFEALLOC(st, CompositeTextureStack);
st->sensors = gf_list_new();
st->previous_sensors = gf_list_new();
gf_sc_texture_setup(&st->txh, compositor, node);
/*remove texture from compositor and add it at the end, so that any sub-textures are handled before*/
gf_list_del_item(compositor->textures, &st->txh);
gf_list_add(compositor->textures, &st->txh);
st->txh.update_texture_fcnt = composite_update;
if ((c2d->repeatSandT==1) || (c2d->repeatSandT==3) ) st->txh.flags |= GF_SR_TEXTURE_REPEAT_S;
if (c2d->repeatSandT>1) st->txh.flags |= GF_SR_TEXTURE_REPEAT_T;
/*create composite visual*/
st->visual = visual_new(compositor);
st->visual->offscreen = node;
st->visual->GetSurfaceAccess = composite_get_video_access;
st->visual->ReleaseSurfaceAccess = composite_release_video_access;
st->visual->raster_surface = compositor->rasterizer->surface_new(compositor->rasterizer, 1);
st->visual->DrawBitmap = composite2d_draw_bitmap;
st->first = 1;
st->visual->compositor = compositor;
gf_node_set_private(node, st);
gf_node_set_callback_function(node, composite_traverse);
gf_sc_visual_register(compositor, st->visual);
}
static JSBool SMJS_FUNCTION(upnp_service_set_action_listener)
{
PLT_ActionDesc *action;
PLT_ArgumentDesc *desc;
GPAC_ActionArgListener *argl = NULL;
char *name;
Bool script_callback = GF_FALSE;
u32 i;
SMJS_OBJ
SMJS_ARGS
GPAC_ServiceItem *service = (GPAC_ServiceItem *)SMJS_GET_PRIVATE(c, obj);
if (!service || (argc<2) || !JSVAL_IS_STRING(argv[0]) || !JSVAL_IS_OBJECT(argv[1])) return JS_FALSE;
name = SMJS_CHARS(c, argv[0]);
if (!name) return JS_FALSE;
action = service->m_service->FindActionDesc(name);
SMJS_FREE(c, name);
if (!action) return JS_FALSE;
desc = NULL;
if (argc==3) {
if (JSVAL_IS_BOOLEAN(argv[2])) {
script_callback = GF_TRUE;
} else {
if (!JSVAL_IS_STRING(argv[2]) ) return JS_FALSE;
name = SMJS_CHARS(c, argv[2]);
if (!name) return JS_FALSE;
desc = action->GetArgumentDesc(name);
SMJS_FREE(c, name);
if (!desc) return JS_FALSE;
}
}
/*action listener*/
i=0;
while ((argl = (GPAC_ActionArgListener *)gf_list_enum(service->m_ArgListeners, &i))) {
if (argl->arg == desc) break;
argl = NULL;
}
if (!argl) {
argl = new GPAC_ActionArgListener();
argl->arg = desc;
gf_list_add(service->m_ArgListeners, argl);
}
argl->action = action;
if (!JSVAL_IS_NULL(argl->on_event))
gf_js_remove_root(c, &argl->on_event, GF_JSGC_VAL);
if (JSVAL_IS_NULL(argv[1])) {
gf_list_del_item(service->m_ArgListeners, argl);
delete argl;
}
argl->on_event = argv[1];
argl->is_script = script_callback;
gf_js_add_root(c, &argl->on_event, GF_JSGC_VAL);
return JS_TRUE;
}
/*render : setup media sensor and update timing in case of inline scenes*/
void RenderMediaSensor(GF_Node *node, void *rs, Bool is_destroy)
{
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
GF_Clock *ck;
Bool do_update_clock = 1;
MediaSensorStack *st = (MediaSensorStack *)gf_node_get_private(node);
if (is_destroy) {
/*unlink from OD*/
if (st->stream && st->stream->odm)
gf_list_del_item(st->stream->odm->ms_stack, st);
gf_list_del(st->seg);
gf_free(st);
return;
}
//we need to disable culling otherwise we may never be called back again ...
tr_state->disable_cull = 1;
if (!st->stream) st->stream = gf_mo_register(node, &st->sensor->url, 0, 0);
if (!st->stream || !st->stream->odm) return;
if (!st->is_init) {
gf_list_add(st->stream->odm->ms_stack, st);
gf_odm_init_segments(st->stream->odm, st->seg, &st->sensor->url);
st->is_init = 1;
st->active_seg = 0;
}
/*media sensor bound to natural media (audio, video) is updated when fetching the stream
data for rendering.*/
ck = NULL;
/*check inline scenes - if the scene is set to restart DON'T MODIFY SENSOR: since we need a 2 render
passes to restart inline, scene is considered as not running*/
if (st->stream->odm->subscene && !st->stream->odm->subscene->needs_restart) {
if (st->stream->odm->subscene->scene_codec) ck = st->stream->odm->subscene->scene_codec->ck;
/*dynamic scene*/
else ck = st->stream->odm->subscene->dyn_ck;
if (st->stream->odm->subscene->is_dynamic_scene) do_update_clock = 0;
}
/*check anim streams*/
else if (st->stream->odm->codec && (st->stream->odm->codec->type==GF_STREAM_SCENE)) ck = st->stream->odm->codec->ck;
/*check OCR streams*/
else if (st->stream->odm->ocr_codec) ck = st->stream->odm->ocr_codec->ck;
if (ck && gf_clock_is_started(ck) ) {
if (do_update_clock)
st->stream->odm->media_current_time = gf_clock_media_time(ck);
mediasensor_update_timing(st->stream->odm, 0);
}
//if main addon is VoD and selected and clock is paused, fire a timeshift update
else if (st->stream->odm->subscene && st->stream->odm->subscene->sys_clock_at_main_activation) {
GF_Event evt;
memset(&evt, 0, sizeof(evt));
evt.type = GF_EVENT_TIMESHIFT_UPDATE;
gf_term_send_event(st->stream->odm->term, &evt);
}
}
static void log_del_thread(GF_Thread *t)
{
gf_list_del_item(thread_bank, t);
if (!gf_list_count(thread_bank)) {
gf_list_del(thread_bank);
thread_bank = NULL;
}
}
void DestroyStringSensor(GF_Node *node, void *rs, Bool is_destroy)
{
if (is_destroy) {
StringSensorStack *st = (StringSensorStack *) gf_node_get_private(node);
gf_list_del_item(st->term->x3d_sensors, node);
gf_free(st);
}
}
void TraverseKeyNavigator(GF_Node *node, void *rs, Bool is_destroy)
{
if (is_destroy) {
GF_Scene *scene = (GF_Scene *)gf_node_get_private(node);
gf_list_del_item(scene->keynavigators, node);
gf_sc_key_navigator_del(scene->root_od->term->compositor, node);
}
}
/*Animations are applied in their begin order. Whenever an anim (re)starts, it is placed at the end of the queue
(potentially after frozen animations)*/
static void gf_smil_reorder_anim(SMIL_Timing_RTI *rti)
{
SMIL_Anim_RTI *rai = (SMIL_Anim_RTI *) gf_smil_anim_get_anim_runtime_from_timing(rti);
if (rai) {
gf_list_del_item(rai->owner->anims, rai);
gf_list_add(rai->owner->anims, rai);
gf_smil_anim_reset_variables(rai);
}
}
GF_EXPORT
GF_Err gf_isom_set_meta_type(GF_ISOFile *file, Bool root_meta, u32 track_num, u32 metaType)
{
char szName[20];
GF_MetaBox *meta;
GF_Err e = CanAccessMovie(file, GF_ISOM_OPEN_WRITE);
if (e) return e;
meta = gf_isom_get_meta(file, root_meta, track_num);
if (!meta) {
if (!metaType) return GF_OK;
meta = (GF_MetaBox *) meta_New();
if (root_meta) {
file->meta = meta;
gf_list_add(file->TopBoxes, meta);
} else {
gf_isom_insert_moov(file);
if (!track_num) {
file->moov->meta = meta;
} else {
GF_TrackBox *tk = (GF_TrackBox *)gf_list_get(file->moov->trackList, track_num-1);
if (!tk) {
gf_isom_box_del((GF_Box *)meta);
return GF_BAD_PARAM;
}
tk->meta = meta;
}
}
} else if (!metaType) {
if (root_meta) {
gf_list_del_item(file->TopBoxes, meta);
gf_isom_box_del((GF_Box *)file->meta);
file->meta = NULL;
} else if (file->moov) {
if (!track_num) {
gf_isom_box_del((GF_Box *)file->moov->meta);
file->moov->meta = NULL;
} else {
GF_TrackBox *tk = (GF_TrackBox *)gf_list_get(file->moov->trackList, track_num-1);
if (!tk) return GF_BAD_PARAM;
gf_isom_box_del((GF_Box *)tk->meta);
tk->meta = NULL;
}
}
return GF_OK;
}
if (!meta->handler)
meta->handler = (GF_HandlerBox *)hdlr_New();
if (meta->handler->nameUTF8) gf_free(meta->handler->nameUTF8);
meta->handler->handlerType = metaType;
sprintf(szName, "GPAC %s Handler", gf_4cc_to_str(metaType));
meta->handler->nameUTF8 = gf_strdup(szName);
return GF_OK;
}
/* Animations are applied in their begin order first and then in document order.
Whenever an animation (re)starts, it is placed at the end of the queue (potentially after frozen animations) */
static void gf_smil_reorder_anim(SMIL_Timing_RTI *rti)
{
SMIL_Anim_RTI *rai = rti->rai;
if (rai) {
gf_list_del_item(rai->owner->anims, rai);
gf_list_add(rai->owner->anims, rai);
gf_smil_anim_reset_variables(rai);
}
}
void gf_svg_node_del(GF_Node *node)
{
SVG_Element *p = (SVG_Element *)node;
if (p->sgprivate->interact && p->sgprivate->interact->animations) {
gf_smil_anim_delete_animations((GF_Node *)p);
}
if (p->sgprivate->tag==TAG_SVG_listener) {
/*remove from target's listener list*/
GF_DOMEventTarget *evt = node->sgprivate->UserPrivate;
node->sgprivate->UserPrivate = NULL;
if (evt)
gf_list_del_item(evt->evt_list, p);
#if 0
if (evt && (gf_node_get_attribute_by_tag(p, TAG_XMLEV_ATT_event, 0, 0, &info) == GF_OK)) {
u32 type = ((XMLEV_Event *)info.far_ptr)->type;
gf_sg_unregister_event_type(p->sgprivate->scenegraph, gf_dom_event_get_category(type));
}
#endif
}
/*if this is a handler with a UserPrivate, this is a handler with an implicit listener
(eg handler with ev:event=""). Destroy the associated listener*/
if (p->sgprivate->tag==TAG_SVG_handler) {
GF_Node *listener = p->sgprivate->UserPrivate;
if (listener && (listener->sgprivate->tag==TAG_SVG_listener)) {
gf_node_unregister(listener, NULL);
// gf_svg_node_del(listener);
}
}
/*remove this node from associated listeners*/
if (node->sgprivate->interact && node->sgprivate->interact->dom_evt) {
u32 i, count;
count = gf_dom_listener_count(node);
for (i=0; i<count; i++) {
GF_Node *listener = gf_list_get(node->sgprivate->interact->dom_evt->evt_list, i);
listener->sgprivate->UserPrivate = NULL;
}
}
if (gf_svg_is_timing_tag(node->sgprivate->tag)) {
SVGTimedAnimBaseElement *tap = (SVGTimedAnimBaseElement *)node;
if (tap->animp) {
gf_free(tap->animp);
gf_smil_anim_remove_from_target((GF_Node *)tap, (GF_Node *)tap->xlinkp->href->target);
}
if (tap->timingp) {
gf_smil_timing_delete_runtime_info((GF_Node *)tap, tap->timingp->runtime);
gf_free(tap->timingp);
}
if (tap->xlinkp) gf_free(tap->xlinkp);
}
gf_node_delete_attributes(node);
gf_sg_parent_reset(node);
gf_node_free(node);
}
static void mpeg4_sensor_deleted(GF_Node *node, GF_SensorHandler *hdl)
{
GF_Compositor *compositor = gf_sc_get_compositor(node);
if (compositor) {
GF_VisualManager *visual;
u32 i=0;
gf_list_del_item(compositor->sensors, hdl);
gf_list_del_item(compositor->previous_sensors, hdl);
if (compositor->interaction_sensors) compositor->interaction_sensors--;
while ( (visual=gf_list_enum(compositor->visuals, &i)) ) {
if (visual->offscreen)
compositor_compositetexture_sensor_delete(visual->offscreen, hdl);
}
#ifndef GPAC_DISABLE_SVG
gf_sg_unregister_event_type(gf_node_get_graph(node), GF_DOM_EVENT_MOUSE|GF_DOM_EVENT_KEY);
#endif
}
}
/* when a timed element restarts, since the list of timed elements in the scene graph,
to which scene time is notified at each rendering cycle, is sorted, we need to remove
and reinsert this timed element as if it was a new one, to make sure the sorting is correct */
static void gf_smil_mark_modified(SMIL_Timing_RTI *rti, Bool remove)
{
GF_SceneGraph * sg = rti->timed_elt->sgprivate->scenegraph;
while (sg->parent_scene) sg = sg->parent_scene;
if (remove) {
gf_list_del_item(sg->modified_smil_timed_elements, rti);
} else {
gf_list_add(sg->modified_smil_timed_elements, rti);
}
}
static JSBool SMJS_FUNCTION(upnp_service_set_listener)
{
GPAC_StateVariableListener *svl = NULL;
char *name=NULL;
u32 i;
SMJS_OBJ
SMJS_ARGS
GPAC_ServiceItem *service = (GPAC_ServiceItem *)SMJS_GET_PRIVATE(c, obj);
if (!service || !argc || !JSVAL_IS_OBJECT(argv[0])) return JS_FALSE;
if (argc<1) {
if (!JSVAL_IS_NULL(service->on_event))
gf_js_remove_root(c, &service->on_event, GF_JSGC_VAL);
service->on_event = JSVAL_NULL;
if (!JSVAL_IS_NULL(argv[0])) {
service->on_event = argv[0];
gf_js_add_root(c, &service->on_event, GF_JSGC_VAL);
if (!service->subscribed) {
service->m_device->m_pUPnP->m_pGenericController->m_CtrlPoint->Subscribe(service->m_service);
service->subscribed = GF_TRUE;
}
}
return JS_TRUE;
}
if (!JSVAL_IS_STRING(argv[1])) return JS_FALSE;
name = SMJS_CHARS(c, argv[1]);
if (!name) return JS_FALSE;
/*variable state listener*/
i=0;
while ((svl = (GPAC_StateVariableListener *)gf_list_enum(service->m_StateListeners, &i))) {
if (svl->name == (const char *) name) break;
}
if (!svl) {
svl = new GPAC_StateVariableListener();
svl->name = name;
svl->var = service->m_service->FindStateVariable(name);
gf_list_add(service->m_StateListeners, svl);
}
if (!JSVAL_IS_NULL(svl->on_event))
gf_js_remove_root(c, &svl->on_event, GF_JSGC_VAL);
if (JSVAL_IS_NULL(argv[0])) {
gf_list_del_item(service->m_StateListeners, svl);
delete svl;
}
svl->on_event = argv[0];
gf_js_add_root(c, &svl->on_event, GF_JSGC_VAL);
if (!service->subscribed) {
service->m_device->m_pUPnP->m_pGenericController->m_CtrlPoint->Subscribe(service->m_service);
service->subscribed = GF_TRUE;
}
SMJS_FREE(c, name);
return JS_TRUE;
}
GF_Err gf_isom_add_subsample_info(GF_SubSampleInformationBox *sub_samples, u32 sampleNumber, u32 subSampleSize, u8 priority, u32 reserved, Bool discardable)
{
u32 i, count, last_sample;
GF_SubSampleInfoEntry *pSamp;
GF_SubSampleEntry *pSubSamp;
pSamp = NULL;
last_sample = 0;
count = gf_list_count(sub_samples->Samples);
for (i=0; i<count; i++) {
pSamp = (GF_SubSampleInfoEntry*) gf_list_get(sub_samples->Samples, i);
/*TODO - do we need to support insertion of subsample info ?*/
if (last_sample + pSamp->sample_delta > sampleNumber) return GF_NOT_SUPPORTED;
if (last_sample + pSamp->sample_delta == sampleNumber) break;
last_sample += pSamp->sample_delta;
pSamp = NULL;
}
if (!pSamp) {
GF_SAFEALLOC(pSamp, GF_SubSampleInfoEntry);
if (!pSamp) return GF_OUT_OF_MEM;
pSamp->SubSamples = gf_list_new();
if (!pSamp->SubSamples ) {
gf_free(pSamp);
return GF_OUT_OF_MEM;
}
pSamp->sample_delta = sampleNumber - last_sample;
gf_list_add(sub_samples->Samples, pSamp);
}
if ((subSampleSize>0xFFFF) && !sub_samples->version) {
sub_samples->version = 1;
}
/*remove last subsample info*/
if (!subSampleSize) {
pSubSamp = gf_list_last(pSamp->SubSamples);
gf_list_rem_last(pSamp->SubSamples);
gf_free(pSubSamp);
if (!gf_list_count(pSamp->SubSamples)) {
gf_list_del_item(sub_samples->Samples, pSamp);
gf_list_del(pSamp->SubSamples);
gf_free(pSamp);
}
return GF_OK;
}
/*add subsample*/
GF_SAFEALLOC(pSubSamp, GF_SubSampleEntry);
if (!pSubSamp) return GF_OUT_OF_MEM;
pSubSamp->subsample_size = subSampleSize;
pSubSamp->subsample_priority = priority;
pSubSamp->reserved = reserved;
pSubSamp->discardable = discardable;
return gf_list_add(pSamp->SubSamples, pSubSamp);
}
void gf_odm_remove_mediacontrol(GF_ObjectManager *odm, MediaControlStack *ctrl)
{
gf_list_del_item(odm->mc_stack, ctrl);
/*removed. Note the spec doesn't say what to do in this case...*/
if (odm->media_ctrl == ctrl) {
/*we're about to release the media control from this object - if paused, force a resume (as if no MC was set)*/
if (ctrl->paused)
mediacontrol_resume(odm, 0);
gf_odm_set_mediacontrol(odm, NULL);
}
}
GF_EXPORT
void gf_sc_texture_destroy(GF_TextureHandler *txh)
{
GF_Compositor *compositor = txh->compositor;
Bool lock = gf_mx_try_lock(compositor->mx);
gf_sc_texture_release(txh);
if (txh->is_open) gf_sc_texture_stop(txh);
gf_list_del_item(txh->compositor->textures, txh);
if (lock) gf_mx_v(compositor->mx);
}
GF_EXPORT
GF_Err gf_cfg_set_key(GF_Config *iniFile, const char *secName, const char *keyName, const char *keyValue)
{
u32 i;
Bool has_changed = GF_TRUE;
IniSection *sec;
IniKey *key;
if (!iniFile || !secName || !keyName) return GF_BAD_PARAM;
if (!strnicmp(secName, "temp", 4)) has_changed = GF_FALSE;
i = 0;
while ((sec = (IniSection *)gf_list_enum(iniFile->sections, &i))) {
if (!strcmp(secName, sec->section_name)) goto get_key;
}
/* need a new key */
sec = (IniSection *)gf_malloc(sizeof(IniSection));
sec->section_name = gf_strdup(secName);
sec->keys = gf_list_new();
if (has_changed) iniFile->hasChanged = GF_TRUE;
gf_list_add(iniFile->sections, sec);
get_key:
i = 0;
while ((key = (IniKey *)gf_list_enum(sec->keys, &i))) {
if (!strcmp(key->name, keyName)) goto set_value;
}
if (!keyValue) return GF_OK;
/* need a new key */
key = (IniKey *)gf_malloc(sizeof(IniKey));
key->name = gf_strdup(keyName);
key->value = gf_strdup("");
if (has_changed) iniFile->hasChanged = GF_TRUE;
gf_list_add(sec->keys, key);
set_value:
if (!keyValue) {
gf_list_del_item(sec->keys, key);
if (key->name) gf_free(key->name);
if (key->value) gf_free(key->value);
gf_free(key);
if (has_changed) iniFile->hasChanged = GF_TRUE;
return GF_OK;
}
/* same value, don't update */
if (!strcmp(key->value, keyValue)) return GF_OK;
if (key->value) gf_free(key->value);
key->value = gf_strdup(keyValue);
if (has_changed) iniFile->hasChanged = GF_TRUE;
return GF_OK;
}
void gf_smil_timing_delete_runtime_info(GF_Node *timed_elt, SMIL_Timing_RTI *rti)
{
GF_SceneGraph *sg;
if (!rti || !timed_elt) return;
GF_LOG(GF_LOG_DEBUG, GF_LOG_SMIL, ("[SMIL Timing ] Time %f - Timed element %s - Destruction\n", gf_node_get_scene_time((GF_Node *)rti->timed_elt), gf_node_get_log_name((GF_Node *)rti->timed_elt)));
gf_free(rti->current_interval);
gf_free(rti->next_interval);
/* we inform the rootmost scene graph that this node will not need notification of the scene time anymore */
sg = timed_elt->sgprivate->scenegraph;
while (sg->parent_scene) sg = sg->parent_scene;
gf_list_del_item(sg->smil_timed_elements, rti);
gf_list_del_item(sg->modified_smil_timed_elements, rti);
/*remove all associated listeners*/
if (rti->timingp->begin) gf_smil_timing_reset_time_list(* rti->timingp->begin);
if (rti->timingp->end) gf_smil_timing_reset_time_list(* rti->timingp->end);
gf_free(rti);
}
void Playlist::OnPlRemFile()
{
if (!m_FileList.GetSelectedCount()) return;
POSITION pos = m_FileList.GetFirstSelectedItemPosition();
while (pos != NULL) {
int nItem = m_FileList.GetNextSelectedItem(pos);
PLEntry *ple = (PLEntry *) m_FileList.GetItemData(nItem);
gf_list_del_item(m_entries, ple);
delete ple;
}
m_all_dead_entries=-1;
RefreshList();
}
static void gf_storage_traverse(GF_Node *n, void *rs, Bool is_destroy)
{
if (is_destroy) {
GF_Scene *scene = gf_node_get_private(n);
GF_ClientService *net_service = scene->root_od->net_service;
while (scene->root_od->parentscene) {
if (scene->root_od->parentscene->root_od->net_service != net_service)
break;
scene = scene->root_od->parentscene;
}
gf_list_del_item(scene->storages, n);
}
}
static Bool gf_cache_remove_entry(GF_Compositor *compositor, GF_Node *node, GroupingNode2D *group)
{
u32 bytes_remove = 0;
GF_List *cache_candidates = compositor->cached_groups;
/*auto mode*/
if (!group) {
group = gf_list_get(cache_candidates, 0);
if (!group) return 0;
/*remove entry*/
gf_list_rem(cache_candidates, 0);
node = NULL;
} else {
/*remove entry if present*/
if (gf_list_del_item(cache_candidates, group)<0)
return 0;
}
/*disable the caching flag of the group if it was marked as such*/
if(group->flags & GROUP_IS_CACHABLE) {
group->flags &= ~GROUP_IS_CACHABLE;
/*the discarded bytes*/
bytes_remove = group->cached_size;
}
/*indicates cache destruction for next frame*/
if (group->cache && (group->flags & GROUP_IS_CACHED)) {
group->flags &= ~GROUP_IS_CACHED;
/*the discarded bytes*/
bytes_remove = group->cached_size;
}
if (bytes_remove == 0) return 0;
assert(compositor->video_cache_current_size >= bytes_remove);
compositor->video_cache_current_size -= bytes_remove;
GF_LOG(GF_LOG_DEBUG, GF_LOG_CACHE, ("[CACHE] Removing cache %s:\t Objects: %d\tSlope: %g\tBytes: %d\tTime: %d\n",
gf_node_get_log_name(node),
group->nb_objects,
FIX2FLT(group->priority),
group->cached_size,
FIX2FLT(group->traverse_time)));
GF_LOG(GF_LOG_DEBUG, GF_LOG_CACHE, ("[CACHE] Status (B): Max: %d\tUsed: %d\tNb Groups: %d\n",
compositor->video_cache_max_size,
compositor->video_cache_current_size,
gf_list_count(compositor->cached_groups)
));
return 1;
}
void wxPlaylist::OnRemFile(wxCommandEvent &WXUNUSED(event))
{
if (!m_FileList->GetSelectedItemCount()) return;
long item = -1;
for (;;) {
item = m_FileList->GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
if (item == -1) break;
PLEntry *ple = (PLEntry *) m_FileList->GetItemData(item);
gf_list_del_item(m_entries, ple);
delete ple;
}
RefreshList();
}
