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); } }
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); }
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); }
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); }
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(); }
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(); }
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); }
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; } }
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(); }
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(); }
// // 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; }
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); }
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; } } }
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); }
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(); }
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; }
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; }
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); } }
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; }
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); }
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; } }
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; }
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); } }
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")); }
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(); }
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; }
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; }
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; }
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); }
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); }