Exemple #1
0
void CleanWriters(GF_List *writers)
{
	TrackWriter *writer;
	while (gf_list_count(writers)) {
		writer = (TrackWriter*)gf_list_get(writers, 0);
		gf_isom_box_del(writer->stco);
		gf_isom_box_del((GF_Box *)writer->stsc);
		gf_free(writer);
		gf_list_rem(writers, 0);
	}
}
Exemple #2
0
void piff_psec_del(GF_Box *s)
{
	GF_PIFFSampleEncryptionBox *ptr = (GF_PIFFSampleEncryptionBox *)s;
	while (gf_list_count(ptr->samp_aux_info)) {
		GF_CENCSampleAuxInfo *sai = (GF_CENCSampleAuxInfo *)gf_list_get(ptr->samp_aux_info, 0);
		if (sai) gf_isom_cenc_samp_aux_info_del(sai);
		gf_list_rem(ptr->samp_aux_info, 0);
	}
	if (ptr->samp_aux_info) gf_list_del(ptr->samp_aux_info);
	gf_free(s);
}
Exemple #3
0
GPAC_GenericController::~GPAC_GenericController()
{
    m_CtrlPoint->RemoveListener(this);
	gf_mx_del(m_ControlPointLock);
	while (gf_list_count(m_Devices)) {
		GPAC_DeviceItem*ms = (GPAC_DeviceItem*)gf_list_get(m_Devices, 0);
		gf_list_rem(m_Devices, 0);
		delete ms;
	}
	gf_list_del(m_Devices);
}
Exemple #4
0
GF_EXPORT
void gf_odf_hevc_cfg_del(GF_HEVCConfig *cfg)
{
	if (!cfg) return;
	while (gf_list_count(cfg->param_array)) {
		GF_HEVCParamArray *pa = (GF_HEVCParamArray*)gf_list_get(cfg->param_array, 0);
		gf_list_rem(cfg->param_array, 0);

		while (gf_list_count(pa->nalus)) {
			GF_AVCConfigSlot *n = (GF_AVCConfigSlot*)gf_list_get(pa->nalus, 0);
			gf_list_rem(pa->nalus, 0);
			if (n->data) gf_free(n->data);
			gf_free(n);
		}
		gf_list_del(pa->nalus);
		gf_free(pa);
	}
	gf_list_del(cfg->param_array);
	gf_free(cfg);
}
Exemple #5
0
void Playlist::OnPlRemDead()
{
	for (u32 i=0; i<gf_list_count(m_entries); i++) {
		PLEntry *ple = (PLEntry *) gf_list_get(m_entries, i);
		if (!ple->m_bIsDead) continue;
		gf_list_rem(m_entries, i);
		i--;
		delete ple;
	}
	m_all_dead_entries=-1;
	RefreshList();
}
Exemple #6
0
void Playlist::OnRandomize()
{
	GF_List *new_entries = gf_list_new();

	gf_rand_init(GF_FALSE);

	while (gf_list_count(m_entries)>1) {
		u32 pos = gf_rand() % (gf_list_count(m_entries)-1);
		PLEntry *ple = (PLEntry *)gf_list_get(m_entries, pos);
		gf_list_rem(m_entries, pos);
		gf_list_add(new_entries, ple);
	}
	PLEntry *ple = (PLEntry *)gf_list_get(m_entries, 0);
	gf_list_rem(m_entries, 0);
	gf_list_add(new_entries, ple);

	gf_list_del(m_entries);
	m_entries = new_entries;
	m_cur_entry = -1;
	RefreshList();
}
Exemple #7
0
static void MCDec_DelParamList(GF_List *list)
{
	while (gf_list_count(list)) {
		GF_AVCConfigSlot *slc = gf_list_get(list, 0);
		gf_free(slc->data);
		gf_free(slc);
		gf_list_rem(list, 0);
	}
	
	gf_list_del(list);
	
}
Exemple #8
0
void GPAC_DeviceItem::DetachJS() {
	if (obj) {
		gf_js_remove_root(js_ctx, &obj, GF_JSGC_OBJECT);
		SMJS_SET_PRIVATE(js_ctx, obj, NULL);
		obj = NULL;
	}
	while (gf_list_count(m_Services)) {
		GPAC_ServiceItem *item = (GPAC_ServiceItem*)gf_list_get(m_Services, 0);
		gf_list_rem(m_Services, 0);
		delete item;
	}
}
Exemple #9
0
void wxPlaylist::OnRemDead(wxCommandEvent &WXUNUSED(event))
{
	for (u32 i=0; i<gf_list_count(m_entries); i++) {
		PLEntry *ple = (PLEntry *) gf_list_get(m_entries, i);
		if (!ple->m_bIsDead) continue;
		gf_list_rem(m_entries, i);
		i--;
		delete ple;
	}
	m_all_dead_entries = gf_list_count(m_entries) ? 0 : 1;
	RefreshList();
}
Exemple #10
0
void wxPlaylist::OnRandomize(wxCommandEvent &WXUNUSED(event) )
{
	GF_List *new_entries = gf_list_new();

	gf_rand_init(0);

	while (gf_list_count(m_entries)>1) {
		u32 pos = gf_rand() % (gf_list_count(m_entries)-1);
		PLEntry *ple = (PLEntry *)gf_list_get(m_entries, pos);
		gf_list_rem(m_entries, pos);
		gf_list_add(new_entries, ple);
	}
	PLEntry *ple = (PLEntry *)gf_list_get(m_entries, 0);
	gf_list_rem(m_entries, 0);
	gf_list_add(new_entries, ple);

	gf_list_del(m_entries);
	m_entries = new_entries;
	m_cur_entry = -1;
	RefreshList();
}
Exemple #11
0
//
//	Desctructor
//
GF_Err gf_odf_del_qos(GF_QoS_Descriptor *qos)
{
	if (!qos) return GF_BAD_PARAM;

	while (gf_list_count(qos->QoS_Qualifiers)) {
		GF_QoS_Default *tmp = (GF_QoS_Default*)gf_list_get(qos->QoS_Qualifiers, 0);
		gf_odf_delete_qos_qual(tmp);
		gf_list_rem(qos->QoS_Qualifiers, 0);
	}
	gf_list_del(qos->QoS_Qualifiers);
	return GF_OK;
}
Exemple #12
0
void text_clean_paths(GF_Compositor *compositor, TextStack *stack)
{
	GF_TextSpan *span;
	/*delete all path objects*/
	while (gf_list_count(stack->spans)) {
		span = (GF_TextSpan*) gf_list_get(stack->spans, 0);
		gf_list_rem(stack->spans, 0);
		gf_font_manager_delete_span(compositor->font_manager, span);
	}
	stack->bounds.width = stack->bounds.height = 0;
	drawable_reset_path(stack->graph);
}
Exemple #13
0
static void isor_delete_channel(ISOMReader *reader, ISOMChannel *ch)
{
    u32 i=0;
    ISOMChannel *ch2;
    while ((ch2 = (ISOMChannel *)gf_list_enum(reader->channels, &i))) {
        if (ch2 == ch) {
            isor_reset_reader(ch);
            gf_free(ch);
            gf_list_rem(reader->channels, i-1);
            return;
        }
    }
}
Exemple #14
0
GF_EXPORT
void gf_sm_del(GF_SceneManager *ctx)
{
    u32 count;
    while ( (count = gf_list_count(ctx->streams)) ) {
        GF_StreamContext *sc = (GF_StreamContext *)gf_list_get(ctx->streams, count-1);
        gf_list_rem(ctx->streams, count-1);
        gf_sm_delete_stream(sc);
    }
    gf_list_del(ctx->streams);
    if (ctx->root_od) gf_odf_desc_del((GF_Descriptor *) ctx->root_od);
    gf_free(ctx);
}
Exemple #15
0
void Playlist::ClearButPlaying()
{
	PLEntry *p=NULL;
	if (m_cur_entry>=0) p = (PLEntry *) gf_list_get(m_entries, m_cur_entry);
	if (p) gf_list_rem(m_entries, m_cur_entry);

	Clear();
	if (p) {
		gf_list_add(m_entries, p);
		m_cur_entry = 0;
	}
	RefreshList();
}
Exemple #16
0
void ResetTextConfig(GF_TextConfig *desc)
{
	GF_List *bck;
	while (gf_list_count(desc->sample_descriptions)) {
		GF_TextSampleDescriptor *sd = (GF_TextSampleDescriptor *)gf_list_get(desc->sample_descriptions, 0);
		gf_list_rem(desc->sample_descriptions, 0);
		gf_odf_del_tx3g(sd);
	}
	bck = desc->sample_descriptions;
	memset(desc, 0, sizeof(GF_TextConfig));
	desc->tag = GF_ODF_TEXT_CFG_TAG;	
	desc->sample_descriptions = bck;
}
Exemple #17
0
GF_Err cleanup_list_of_elements(GF_List * list) {
	GF_Err result = GF_OK;
	if (list == NULL)
		return result;
	while (gf_list_count(list)) {
		PlaylistElement * pl = (PlaylistElement *) gf_list_get(list, 0);
		if (pl)
			result |= playlist_element_del(pl);
		gf_list_rem(list, 0);
	}
	gf_list_del(list);
	return result;
}
Exemple #18
0
static void CTXLoad_Reset(CTXLoadPriv *priv)
{
	if (priv->ctx) gf_sm_del(priv->ctx);
	priv->ctx = NULL;
	gf_sg_reset(priv->scene->graph);
	if (priv->load_flags != 3) priv->load_flags = 0;
	while (gf_list_count(priv->files_to_delete)) {
		char *fileName = (char*)gf_list_get(priv->files_to_delete, 0);
		gf_list_rem(priv->files_to_delete, 0);
		gf_delete_file(fileName);
		gf_free(fileName);
	}
}
Exemple #19
0
Bool DC_RemoveChannel(DCReader *read, LPNETCHANNEL ch)
{
	DummyChannel *dc;
	u32 i=0;
	while ((dc = (DummyChannel *)gf_list_enum(read->channels, &i))) {
		if (dc->ch && dc->ch==ch) {
			gf_list_rem(read->channels, i-1);
			gf_free(dc);
			return GF_TRUE;
		}
	}
	return GF_FALSE;
}
Exemple #20
0
void RP_RemoveStream(RTPClient *rtp, RTPStream *ch)
{
	u32 i=0;
	RTPStream *st;
	gf_mx_p(rtp->mx);
	while ((st = (RTPStream *)gf_list_enum(rtp->channels, &i))) {
		if (st == ch) {
			gf_list_rem(rtp->channels, i-1);
			break;
		}
	}
	gf_mx_v(rtp->mx);
}
Exemple #21
0
void gf_font_predestroy(GF_Font *font)
{
	if (font->spans) {
		while (gf_list_count(font->spans)) {
			GF_TextSpan *ts = gf_list_get(font->spans, 0);
			gf_list_rem(font->spans, 0);
			gf_node_dirty_set(ts->user, 0, 0);
			ts->user=NULL;
		}
		gf_list_del(font->spans);
		font->spans = NULL;
	}
}
Exemple #22
0
Bool V4Service::V4_RemoveChannel(V4Service *v4service, LPNETCHANNEL ch)
{
	u32 i;
	for (i=0; i<gf_list_count(v4service->channels); i++) {
		V4Channel *v4c = (V4Channel *)gf_list_get(v4service->channels, i);
		if (v4c->ch && v4c->ch==ch) {
			gf_list_rem(v4service->channels, i);
			free(v4c);
			return 1;
		}
	}
	return 0;
}
Exemple #23
0
static void clean_paths(FSStack *stack)
{
	/*delete all path objects*/
	while (gf_list_count(stack->items)) {
		FSItem *it = gf_list_get(stack->items, 0);
		gf_list_rem(stack->items, 0);
		if (it->path) gf_path_del(it->path);
#ifndef GPAC_DISABLE_3D
		if (it->mesh) mesh_free(it->mesh);
#endif
		gf_free(it);
	}
}
Exemple #24
0
void gf_sr_del(GF_Renderer *sr)
{
	if (!sr) return;

	GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Destroying Renderer\n"));
	gf_sr_lock(sr, 1);

	if (sr->VisualThread) {
		sr->video_th_state = 2;
		while (sr->video_th_state!=3) gf_sleep(10);
		gf_th_del(sr->VisualThread);
	}
	if (sr->video_out) {
		GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Closing video output\n"));
		sr->video_out->Shutdown(sr->video_out);
		gf_modules_close_interface((GF_BaseInterface *)sr->video_out);
	}
	GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Closing visual renderer\n"));
	sr->visual_renderer->UnloadRenderer(sr->visual_renderer);
	GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Unloading visual renderer module\n"));
	gf_modules_close_interface((GF_BaseInterface *)sr->visual_renderer);
	GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] visual renderer module unloaded\n"));

	if (sr->audio_renderer) gf_sr_ar_del(sr->audio_renderer);

#ifdef GF_SR_EVENT_QUEUE
	gf_mx_p(sr->ev_mx);
	while (gf_list_count(sr->events)) {
		GF_Event *ev = (GF_Event *)gf_list_get(sr->events, 0);
		gf_list_rem(sr->events, 0);
		free(ev);
	}
	gf_mx_v(sr->ev_mx);
	gf_mx_del(sr->ev_mx);
	gf_list_del(sr->events);
#endif


	if (sr->font_engine) {
		GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Closing font engine\n"));
		sr->font_engine->shutdown_font_engine(sr->font_engine);
		gf_modules_close_interface((GF_BaseInterface *)sr->font_engine);
	}
	gf_list_del(sr->textures);
	gf_list_del(sr->time_nodes);
	gf_list_del(sr->extra_scenes);
	gf_sr_lock(sr, 0);
	gf_mx_del(sr->mx);
	free(sr);
	GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Renderer destroyed\n"));
}
Exemple #25
0
void V4StudioTree::OnEndDrag(wxTreeEvent& event)
{
    wxTreeItemId itemSrc = m_draggedItem, itemDst = event.GetItem(), dstParentItem = GetItemParent(itemDst);
    m_draggedItem = (wxTreeItemId)0l;

	V4StudioTreeItemData *srcData = (V4StudioTreeItemData *)GetItemData(itemSrc);
	GF_FieldInfo srcField;
	srcData->GetField(&srcField);
	// Removal of the src item from its parent field
	switch (srcField.fieldType) {
	case GF_SG_VRML_SFNODE:
		if (* (GF_Node **) srcField.far_ptr) {}
		break;
	case GF_SG_VRML_MFNODE:
		{
			GF_List *nodes = (* (GF_List **) srcField.far_ptr);
			gf_list_rem(nodes, srcData->GetPosition());
		}
		break;
	default:
		break;
	}

	GF_Node *srcNode = srcData->GetNode();
	GF_FieldInfo dstField;
	V4StudioTreeItemData *dstData = (V4StudioTreeItemData *)GetItemData(itemDst);
	dstData->GetField(&dstField);
	// Addition of the src item prior to the dest item
	switch (dstField.fieldType) {
	case GF_SG_VRML_SFNODE:
		if (* (GF_Node **) dstField.far_ptr) {}
		break;
	case GF_SG_VRML_MFNODE:
		{
			GF_List *nodes = (* (GF_List **) dstField.far_ptr);
			gf_list_insert(nodes, srcNode, dstData->GetPosition());
			gf_node_dirty_set(dstData->GetNode(), 0, 1);
		}
		break;
	default:
		break;
	}

	GF_Node *dstParentNode = dstData->GetNodeParent();
	
	Delete(itemSrc);
	AddNodesToItem(dstParentItem, srcNode, dstData->GetFieldIndex(), dstData->GetPosition());
	V4StudioFrame *mainFrame = (V4StudioFrame *)GetParent();
	mainFrame->UpdateSelection(srcNode,dstData->GetNodeParent());
	mainFrame->Update();
}
Exemple #26
0
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;
}
Exemple #27
0
static GF_Err swf_svg_show_frame(SWFReader *read)
{
    u32     i;
    u32     len;
    GF_List *sdl = gf_list_new(); // sorted display list

    /* sorting the display list */
    while (gf_list_count(read->display_list))
    {
        Bool        inserted = 0;
        DispShape   *s;

        s = (DispShape *)gf_list_get(read->display_list, 0);
        gf_list_rem(read->display_list, 0);
        
        for (i = 0; i < gf_list_count(sdl); i++)
        {
            DispShape *s2 = (DispShape *)gf_list_get(sdl, i);
            if (s->depth < s2->depth) 
            {
                gf_list_insert(sdl, s, i);
                inserted = 1;
                break;
            }
        }
        if (!inserted)
        {
            gf_list_add(sdl, s);
        }
    }
    gf_list_del(read->display_list);
    read->display_list = sdl;

    /* dumping the display list */
    len = gf_list_count(read->display_list);
    for (i=0; i<len; i++)
    {
        DispShape   *s;
        s = (DispShape *)gf_list_get(read->display_list, i);
        fprintf(read->svg_output, "<use xlink:href=\"#S%d\" z-index=\"%d\" ", s->char_id, s->depth);
        swf_svg_print_matrix(read, &s->mat);
        fprintf(read->svg_output, "/>\n");
    }
    fprintf(read->svg_output, "</g>\n");

    fprintf(read->svg_output, "<g id=\"frame%d\" display=\"none\">\n",read->current_frame+1);
    fprintf(read->svg_output, "<animate attributeName=\"display\" to=\"inline\" begin=\"%f\" end=\"%f\" fill=\"%s\" restart=\"never\"/>\n", 
        1.0*(read->current_frame+1)/read->frame_rate, 1.0*(read->current_frame+2)/read->frame_rate,
        (((read->current_frame+1) <= (read->frame_count-1)) ? "remove" : "freeze"));
    return GF_OK;
}
Exemple #28
0
GF_Err gf_isom_remove_samp_group_box(GF_ISOFile *the_file, u32 trackNumber)
{
	u32 i;
	GF_SampleTableBox *stbl;
	GF_TrackBox *trak = gf_isom_get_track_from_file(the_file, trackNumber);
	if (!trak) return GF_BAD_PARAM;
	stbl = trak->Media->information->sampleTable;
	if (!stbl)
		return GF_BAD_PARAM;

	for (i = 0; i < gf_list_count(stbl->sampleGroupsDescription); i++) {
		GF_SampleGroupDescriptionBox *a = (GF_SampleGroupDescriptionBox *)gf_list_get(stbl->sampleGroupsDescription, i);
		if (a->grouping_type == GF_4CC( 's', 'e', 'i', 'g' )) {
			gf_list_rem(stbl->sampleGroupsDescription, i);
			sgpd_del((GF_Box *) a);
			i--;
		}
	}
	if (!gf_list_count(stbl->sampleGroupsDescription)) {
		gf_list_del(stbl->sampleGroupsDescription);
		stbl->sampleGroupsDescription = NULL;
	}

	for (i = 0; i < gf_list_count(stbl->sampleGroups); i++) {
		GF_SampleGroupBox *a = (GF_SampleGroupBox *)gf_list_get(stbl->sampleGroups, i);
		if (a->grouping_type == GF_4CC( 's', 'e', 'i', 'g' )) {
			gf_list_rem(stbl->sampleGroups, i);
			sbgp_del((GF_Box *) a);
			i--;
		}
	}
	if (!gf_list_count(stbl->sampleGroups)) {
		gf_list_del(stbl->sampleGroups);
		stbl->sampleGroups = NULL;
	}

	return GF_OK;
}
Exemple #29
0
GF_EXPORT
void gf_odf_codec_del(GF_ODCodec *codec)
{
	if (!codec) return;

	while (gf_list_count(codec->CommandList)) {
		GF_ODCom *com = (GF_ODCom *)gf_list_get(codec->CommandList, 0);
		gf_odf_delete_command(com);
		gf_list_rem(codec->CommandList, 0);
	}
	gf_list_del(codec->CommandList);
	if (codec->bs) gf_bs_del(codec->bs);
	gf_free(codec);
}
Exemple #30
0
GF_EXPORT
void gf_modules_del(GF_ModuleManager *pm)
{
	ModuleInstance *inst;
	if (!pm) return;
	/*unload all modules*/
	while (gf_list_count(pm->plug_list)) {
		inst = (ModuleInstance *) gf_list_get(pm->plug_list, 0);
		gf_modules_free_module(inst);
		gf_list_rem(pm->plug_list, 0);
	}
	gf_list_del(pm->plug_list);
	gf_free(pm);
}