コード例 #1
0
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);
}
コード例 #2
0
ファイル: input_sensor.c プロジェクト: Kurtnoise/gpac
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);
	}
}
コード例 #3
0
ファイル: scene_manager.c プロジェクト: Bevara/GPAC
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);
    }
}
コード例 #4
0
ファイル: mpeg4_sensors.c プロジェクト: JamesLinus/gpac
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);
	}
}
コード例 #5
0
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);
}
コード例 #6
0
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);
}
コード例 #7
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);
}
コード例 #8
0
ファイル: decoder.c プロジェクト: golgol7777/gpac
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);
}
コード例 #9
0
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);
}
コード例 #10
0
ファイル: GenericDevice.cpp プロジェクト: ARSekkat/gpac
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;
}
コード例 #11
0
ファイル: media_sensor.c プロジェクト: matthew-mahony/gpac
/*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);
	}
}
コード例 #12
0
ファイル: os_thread.c プロジェクト: fcsteagu/gpac-1
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;
	}
}
コード例 #13
0
ファイル: input_sensor.c プロジェクト: Kurtnoise/gpac
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);
	}
}
コード例 #14
0
ファイル: term_node_init.c プロジェクト: bigbensk/gpac
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);
	}
}
コード例 #15
0
/*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);
	}
}
コード例 #16
0
ファイル: meta.c プロジェクト: Brilon314/gpac
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;
}
コード例 #17
0
ファイル: smil_timing.c プロジェクト: noelove/GPAC-old
/* 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);
	}
}
コード例 #18
0
ファイル: svg_types.c プロジェクト: golgol7777/gpac
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);
}
コード例 #19
0
ファイル: mpeg4_sensors.c プロジェクト: JamesLinus/gpac
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
	}
}
コード例 #20
0
ファイル: smil_timing.c プロジェクト: noelove/GPAC-old
/* 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);
	}
}
コード例 #21
0
ファイル: GenericDevice.cpp プロジェクト: ARSekkat/gpac
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;
}
コード例 #22
0
ファイル: isom_intern.c プロジェクト: renanyoy/gpac
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);
}
コード例 #23
0
ファイル: media_control.c プロジェクト: bbshocking/gpac
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);
	}
}
コード例 #24
0
ファイル: texturing.c プロジェクト: bbshocking/gpac
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);
}
コード例 #25
0
ファイル: configfile.c プロジェクト: Abhinav95/ccextractor
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;
}
コード例 #26
0
ファイル: smil_timing.c プロジェクト: noelove/GPAC-old
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);
}
コード例 #27
0
ファイル: Playlist.cpp プロジェクト: Bevara/Access
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();
}
コード例 #28
0
ファイル: mpeg4_inline.c プロジェクト: golgol7777/gpac
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);
	}
}
コード例 #29
0
ファイル: offscreen_cache.c プロジェクト: erelh/gpac
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;
}
コード例 #30
0
ファイル: Playlist.cpp プロジェクト: ARSekkat/gpac
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();
}