void VideoFFmpeg::stopCache()
{
if (m_cacheStarted)
{
m_stopThread = true;
BLI_end_threads(&m_thread);
// now delete the cache
CacheFrame *frame;
CachePacket *packet;
while ((frame = (CacheFrame *)m_frameCacheBase.first) != NULL)
{
BLI_remlink(&m_frameCacheBase, frame);
MEM_freeN(frame->frame->data[0]);
av_free(frame->frame);
delete frame;
}
while ((frame = (CacheFrame *)m_frameCacheFree.first) != NULL)
{
BLI_remlink(&m_frameCacheFree, frame);
MEM_freeN(frame->frame->data[0]);
av_free(frame->frame);
delete frame;
}
while ((packet = (CachePacket *)m_packetCacheBase.first) != NULL)
{
BLI_remlink(&m_packetCacheBase, packet);
av_free_packet(&packet->packet);
delete packet;
}
while ((packet = (CachePacket *)m_packetCacheFree.first) != NULL)
{
BLI_remlink(&m_packetCacheFree, packet);
delete packet;
}
m_cacheStarted = false;
}
}
/* this is event from ghost, or exit-blender op */
void wm_window_close(bContext *C, wmWindowManager *wm, wmWindow *win)
{
wmWindow *tmpwin;
bScreen *screen = win->screen;
/* first check if we have any non-temp remaining windows */
if ((U.uiflag & USER_QUIT_PROMPT) && !wm->file_saved) {
if (wm->windows.first) {
for (tmpwin = wm->windows.first; tmpwin; tmpwin = tmpwin->next) {
if (tmpwin == win)
continue;
if (tmpwin->screen->temp == 0)
break;
}
if (tmpwin == NULL) {
if (!GHOST_confirmQuit(win->ghostwin))
return;
}
}
}
BLI_remlink(&wm->windows, win);
wm_draw_window_clear(win);
CTX_wm_window_set(C, win); /* needed by handlers */
WM_event_remove_handlers(C, &win->handlers);
WM_event_remove_handlers(C, &win->modalhandlers);
ED_screen_exit(C, win, win->screen);
wm_window_free(C, wm, win);
/* if temp screen, delete it after window free (it stops jobs that can access it) */
if (screen->temp) {
Main *bmain = CTX_data_main(C);
BKE_libblock_free(&bmain->screen, screen);
}
/* check remaining windows */
if (wm->windows.first) {
for (win = wm->windows.first; win; win = win->next)
if (win->screen->temp == 0)
break;
/* in this case we close all */
if (win == NULL)
WM_exit(C);
}
else
WM_exit(C);
}
void VideoFFmpeg::releaseFrame(AVFrame *frame)
{
if (frame == m_frameRGB)
{
// this is not a frame from the cache, ignore
return;
}
// this frame MUST be the first one of the queue
pthread_mutex_lock(&m_cacheMutex);
CacheFrame *cacheFrame = (CacheFrame *)m_frameCacheBase.first;
assert (cacheFrame != NULL && cacheFrame->frame == frame);
BLI_remlink(&m_frameCacheBase, cacheFrame);
BLI_addtail(&m_frameCacheFree, cacheFrame);
pthread_mutex_unlock(&m_cacheMutex);
}
static int sensor_remove_exec(bContext *C, wmOperator *op)
{
Object *ob = NULL;
bSensor *sens = edit_sensor_property_get(C, op, &ob);
if (!sens)
return OPERATOR_CANCELLED;
BLI_remlink(&(ob->sensors), sens);
free_sensor(sens);
WM_event_add_notifier(C, NC_LOGIC, NULL);
return OPERATOR_FINISHED;
}
static void pop_propagate_stack(SmoothEdge **edge, SmoothVert **vert, SmoothMesh *mesh)
{
PropagateEdge *pedge = mesh->propagatestack.first;
if(pedge) {
*edge = pedge->edge;
*vert = pedge->vert;
BLI_remlink(&mesh->propagatestack, pedge);
BLI_addhead(&mesh->reusestack, pedge);
}
else {
*edge = NULL;
*vert = NULL;
}
}
/* this is event from ghost, or exit-blender op */
void wm_window_close(bContext *C, wmWindowManager *wm, wmWindow *win)
{
wmWindow *tmpwin;
bool do_exit = false;
/* first check if we have to quit (there are non-temp remaining windows) */
for (tmpwin = wm->windows.first; tmpwin; tmpwin = tmpwin->next) {
if (tmpwin == win)
continue;
if (tmpwin->screen->temp == 0)
break;
}
if (tmpwin == NULL)
do_exit = 1;
if ((U.uiflag & USER_QUIT_PROMPT) && !wm->file_saved) {
if (do_exit) {
if (!GHOST_confirmQuit(win->ghostwin))
return;
}
}
/* let WM_exit do all freeing, for correct quit.blend save */
if (do_exit) {
WM_exit(C);
}
else {
bScreen *screen = win->screen;
BLI_remlink(&wm->windows, win);
wm_draw_window_clear(win);
CTX_wm_window_set(C, win); /* needed by handlers */
WM_event_remove_handlers(C, &win->handlers);
WM_event_remove_handlers(C, &win->modalhandlers);
ED_screen_exit(C, win, win->screen);
wm_window_free(C, wm, win);
/* if temp screen, delete it after window free (it stops jobs that can access it) */
if (screen->temp) {
Main *bmain = CTX_data_main(C);
BKE_libblock_free(bmain, screen);
}
}
}
static int controller_remove_exec(bContext *C, wmOperator *op)
{
Object *ob = NULL;
bController *cont = edit_controller_property_get(C, op, &ob);
if (!cont)
return OPERATOR_CANCELLED;
BLI_remlink(&(ob->controllers), cont);
unlink_controller(cont);
free_controller(cont);
WM_event_add_notifier(C, NC_LOGIC, NULL);
return OPERATOR_FINISHED;
}
static int actuator_remove_exec(bContext *C, wmOperator *op)
{
Object *ob = NULL;
bActuator *act = edit_actuator_property_get(C, op, &ob);
if (!act)
return OPERATOR_CANCELLED;
BLI_remlink(&(ob->actuators), act);
unlink_actuator(act);
free_actuator(act);
WM_event_add_notifier(C, NC_LOGIC, NULL);
return OPERATOR_FINISHED;
}
/* call on application exit */
void BLI_callback_global_finalize(void)
{
eCbEvent evt;
for (evt = 0; evt < BLI_CB_EVT_TOT; evt++) {
ListBase *lb = &callback_slots[evt];
bCallbackFuncStore *funcstore;
bCallbackFuncStore *funcstore_next;
for (funcstore = (bCallbackFuncStore *)lb->first; funcstore; funcstore = funcstore_next) {
funcstore_next = (bCallbackFuncStore *)funcstore->next;
BLI_remlink(lb, funcstore);
if (funcstore->alloc) {
MEM_freeN(funcstore);
}
}
}
}
/* free all MetaElems from ListBase */
static void freeMetaElemlist(ListBase *lb)
{
MetaElem *ml, *next;
if (lb == NULL) return;
ml = lb->first;
while (ml) {
next = ml->next;
BLI_remlink(lb, ml);
MEM_freeN(ml);
ml = next;
}
lb->first = lb->last = NULL;
}
int unpackImage(ReportList *reports, Image *ima, int how)
{
int ret_value = RET_ERROR;
if (ima != NULL) {
while (ima->packedfiles.last) {
char localname[FILE_MAX], absname[FILE_MAX];
char *newname;
ImagePackedFile *imapf = ima->packedfiles.last;
unpack_generate_paths(imapf->filepath, (ID *)ima, absname, localname, sizeof(absname), sizeof(localname));
newname = unpackFile(reports, absname, localname, imapf->packedfile, how);
if (newname != NULL) {
ImageView *iv;
ret_value = ret_value == RET_ERROR ? RET_ERROR : RET_OK;
freePackedFile(imapf->packedfile);
imapf->packedfile = NULL;
/* update the new corresponding view filepath */
iv = BLI_findstring(&ima->views, imapf->filepath, offsetof(ImageView, filepath));
if (iv) {
BLI_strncpy(iv->filepath, newname, sizeof(imapf->filepath));
}
/* keep the new name in the image for non-pack specific reasons */
if (how != PF_REMOVE) {
BLI_strncpy(ima->name, newname, sizeof(imapf->filepath));
}
MEM_freeN(newname);
}
else {
ret_value = RET_ERROR;
}
BLI_remlink(&ima->packedfiles, imapf);
MEM_freeN(imapf);
}
}
if (ret_value == RET_OK) {
BKE_image_signal(ima, NULL, IMA_SIGNAL_RELOAD);
}
return(ret_value);
}
void RE_engines_exit(void)
{
RenderEngineType *type, *next;
for (type = R_engines.first; type; type = next) {
next = type->next;
BLI_remlink(&R_engines, type);
if (!(type->flag & RE_INTERNAL)) {
if (type->ext.free)
type->ext.free(type->ext.data);
MEM_freeN(type);
}
}
}
int WM_keyconfig_remove(wmWindowManager *wm, wmKeyConfig *keyconf)
{
if (BLI_findindex(&wm->keyconfigs, keyconf) != -1) {
if (strncmp(U.keyconfigstr, keyconf->idname, sizeof(U.keyconfigstr)) == 0) {
BLI_strncpy(U.keyconfigstr, wm->defaultconf->idname, sizeof(U.keyconfigstr));
WM_keyconfig_update_tag(NULL, NULL);
}
BLI_remlink(&wm->keyconfigs, keyconf);
WM_keyconfig_free(keyconf);
return TRUE;
}
else {
return FALSE;
}
}
/* To be able to read files without windows closing, opening, moving
* we try to prepare for worst case:
* - active window gets active screen from file
* - restoring the screens from non-active windows
* Best case is all screens match, in that case they get assigned to proper window
*/
static void wm_window_match_init(bContext *C, ListBase *wmlist)
{
wmWindowManager *wm;
wmWindow *win, *active_win;
*wmlist = G.main->wm;
BLI_listbase_clear(&G.main->wm);
active_win = CTX_wm_window(C);
/* first wrap up running stuff */
/* code copied from wm_init_exit.c */
for (wm = wmlist->first; wm; wm = wm->id.next) {
WM_jobs_kill_all(wm);
for (win = wm->windows.first; win; win = win->next) {
CTX_wm_window_set(C, win); /* needed by operator close callbacks */
WM_event_remove_handlers(C, &win->handlers);
WM_event_remove_handlers(C, &win->modalhandlers);
ED_screen_exit(C, win, win->screen);
}
}
/* reset active window */
CTX_wm_window_set(C, active_win);
ED_editors_exit(C);
/* just had return; here from r12991, this code could just get removed?*/
#if 0
if (wm == NULL) return;
if (G.fileflags & G_FILE_NO_UI) return;
/* we take apart the used screens from non-active window */
for (win = wm->windows.first; win; win = win->next) {
BLI_strncpy(win->screenname, win->screen->id.name, MAX_ID_NAME);
if (win != wm->winactive) {
BLI_remlink(&G.main->screen, win->screen);
//BLI_addtail(screenbase, win->screen);
}
}
#endif
}
void blf_font_free(FontBLF *font)
{
GlyphCacheBLF *gc;
font->glyph_cache = NULL;
while (font->cache.first) {
gc = font->cache.first;
BLI_remlink(&font->cache, gc);
blf_glyph_cache_free(gc);
}
FT_Done_Face(font->face);
if (font->filename)
MEM_freeN(font->filename);
if (font->name)
MEM_freeN(font->name);
MEM_freeN(font);
}
void blf_glyph_cache_clear(FontBLF *font)
{
GlyphCacheBLF *gc;
GlyphBLF *g;
int i;
for (gc = font->cache.first; gc; gc = gc->next) {
for (i = 0; i < 257; i++) {
while (gc->bucket[i].first) {
g = gc->bucket[i].first;
BLI_remlink(&(gc->bucket[i]), g);
blf_glyph_free(g);
}
}
memset(gc->glyph_ascii_table, 0, sizeof(gc->glyph_ascii_table));
}
}
void blf_glyph_cache_free(GlyphCacheBLF *gc)
{
GlyphBLF *g;
int i;
for (i = 0; i < 257; i++) {
while (gc->bucket[i].first) {
g = gc->bucket[i].first;
BLI_remlink(&(gc->bucket[i]), g);
blf_glyph_free(g);
}
}
if (gc->cur_tex+1 > 0)
glDeleteTextures(gc->cur_tex+1, gc->textures);
free((void *)gc->textures);
MEM_freeN(gc);
}
static void render_result_views_free(RenderResult *res)
{
while (res->views.first) {
RenderView *rv = res->views.first;
BLI_remlink(&res->views, rv);
if (rv->rect32)
MEM_freeN(rv->rect32);
if (rv->rectz)
MEM_freeN(rv->rectz);
if (rv->rectf)
MEM_freeN(rv->rectf);
MEM_freeN(rv);
}
}
void WM_event_remove_timer(wmWindowManager *wm, wmWindow *UNUSED(win), wmTimer *timer)
{
wmTimer *wt;
/* extra security check */
for (wt = wm->timers.first; wt; wt = wt->next)
if (wt == timer)
break;
if (wt) {
if (wm->reports.reporttimer == wt)
wm->reports.reporttimer = NULL;
BLI_remlink(&wm->timers, wt);
if (wt->customdata)
MEM_freeN(wt->customdata);
MEM_freeN(wt);
}
}
/* also used for ob==NULL */
int rem_from_group(Group *group, Object *ob)
{
GroupObject *go, *gon;
int removed = 0;
if(group==NULL) return 0;
go= group->gobject.first;
while(go) {
gon= go->next;
if(go->ob==ob) {
BLI_remlink(&group->gobject, go);
free_group_object(go);
removed = 1;
/* should break here since an object being in a group twice cant happen? */
}
go= gon;
}
return removed;
}
/* called on event handling by event_system.c */
void wm_operator_register(bContext *C, wmOperator *op)
{
wmWindowManager *wm= CTX_wm_manager(C);
int tot;
BLI_addtail(&wm->operators, op);
tot= BLI_countlist(&wm->operators);
while(tot>MAX_OP_REGISTERED) {
wmOperator *opt= wm->operators.first;
BLI_remlink(&wm->operators, opt);
WM_operator_free(opt);
tot--;
}
/* so the console is redrawn */
WM_event_add_notifier(C, NC_SPACE|ND_SPACE_INFO_REPORT, NULL);
WM_event_add_notifier(C, NC_WM|ND_HISTORY, NULL);
}
void RE_engine_end_result(RenderEngine *engine, RenderResult *result, int cancel, int merge_results)
{
Render *re = engine->re;
if (!result) {
return;
}
/* merge. on break, don't merge in result for preview renders, looks nicer */
if (!cancel) {
/* for exr tile render, detect tiles that are done */
RenderPart *pa = get_part_from_result(re, result);
if (pa) {
pa->status = PART_STATUS_READY;
}
else if (re->result->do_exr_tile) {
/* if written result does not match any tile and we are using save
* buffers, we are going to get openexr save errors */
fprintf(stderr, "RenderEngine.end_result: dimensions do not match any OpenEXR tile.\n");
}
}
if (!cancel || merge_results) {
if (re->result->do_exr_tile) {
if (!cancel) {
render_result_exr_file_merge(re->result, result);
}
}
else if (!(re->test_break(re->tbh) && (re->r.scemode & R_BUTS_PREVIEW)))
render_result_merge(re->result, result);
/* draw */
if (!re->test_break(re->tbh)) {
result->renlay = result->layers.first; /* weak, draws first layer always */
re->display_update(re->duh, result, NULL);
}
}
/* free */
BLI_remlink(&engine->fullresult, result);
render_result_free(result);
}
static bool task_scheduler_thread_wait_pop(TaskScheduler *scheduler, Task **task)
{
BLI_mutex_lock(&scheduler->queue_mutex);
while (!scheduler->queue.first && !scheduler->do_exit)
BLI_condition_wait(&scheduler->queue_cond, &scheduler->queue_mutex);
if (!scheduler->queue.first) {
BLI_mutex_unlock(&scheduler->queue_mutex);
BLI_assert(scheduler->do_exit);
return false;
}
*task = scheduler->queue.first;
BLI_remlink(&scheduler->queue, *task);
BLI_mutex_unlock(&scheduler->queue_mutex);
return true;
}
static bool gpencil_object_modifier_remove(Main *bmain,
Object *ob,
GpencilModifierData *md,
bool *UNUSED(r_sort_depsgraph))
{
/* It seems on rapid delete it is possible to
* get called twice on same modifier, so make
* sure it is in list. */
if (BLI_findindex(&ob->greasepencil_modifiers, md) == -1) {
return 0;
}
DEG_relations_tag_update(bmain);
BLI_remlink(&ob->greasepencil_modifiers, md);
BKE_gpencil_modifier_free(md);
BKE_object_free_derived_caches(ob);
return 1;
}
static wmKeyMapItem *rna_KeyMap_item_new_from_item(wmKeyMap *km,
ReportList *reports,
wmKeyMapItem *kmi_src,
bool head)
{
/* wmWindowManager *wm = CTX_wm_manager(C); */
if ((km->flag & KEYMAP_MODAL) == (kmi_src->idname[0] != '\0')) {
BKE_report(reports, RPT_ERROR, "Can not mix modal/non-modal items");
return NULL;
}
/* create keymap item */
wmKeyMapItem *kmi = WM_keymap_add_item_copy(km, kmi_src);
if (head) {
BLI_remlink(&km->items, kmi);
BLI_addhead(&km->items, kmi);
}
return kmi;
}
int ED_object_modifier_move_down(ReportList *reports, Object *ob, ModifierData *md)
{
if(md->next) {
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
if(mti->flags&eModifierTypeFlag_RequiresOriginalData) {
ModifierTypeInfo *nmti = modifierType_getInfo(md->next->type);
if(nmti->type!=eModifierTypeType_OnlyDeform) {
BKE_report(reports, RPT_WARNING, "Cannot move beyond a non-deforming modifier");
return 0;
}
}
BLI_remlink(&ob->modifiers, md);
BLI_insertlink(&ob->modifiers, md->next, md);
}
return 1;
}
int ED_object_modifier_move_up(ReportList *reports, Object *ob, ModifierData *md)
{
if(md->prev) {
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
if(mti->type!=eModifierTypeType_OnlyDeform) {
ModifierTypeInfo *nmti = modifierType_getInfo(md->prev->type);
if(nmti->flags&eModifierTypeFlag_RequiresOriginalData) {
BKE_report(reports, RPT_WARNING, "Cannot move above a modifier requiring original data");
return 0;
}
}
BLI_remlink(&ob->modifiers, md);
BLI_insertlink(&ob->modifiers, md->prev->prev, md);
}
return 1;
}
static void push_propagate_stack(SmoothEdge *edge, SmoothVert *vert, SmoothMesh *mesh)
{
PropagateEdge *pedge = mesh->reusestack.first;
if(pedge) {
BLI_remlink(&mesh->reusestack, pedge);
}
else {
if(!mesh->arena) {
mesh->arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "edgesplit arena");
BLI_memarena_use_calloc(mesh->arena);
}
pedge = BLI_memarena_alloc(mesh->arena, sizeof(PropagateEdge));
}
pedge->edge = edge;
pedge->vert = vert;
BLI_addhead(&mesh->propagatestack, pedge);
}
static int state_del_exec(bContext *C, wmOperator *UNUSED(op))
{
Main *bmain = CTX_data_main(C);
Scene *scene = CTX_data_scene(C);
PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
ParticleSystem *psys= ptr.data;
Object *ob = ptr.id.data;
ParticleSettings *part;
BoidState *state;
if(!psys || !psys->part || psys->part->phystype != PART_PHYS_BOIDS)
return OPERATOR_CANCELLED;
part = psys->part;
for(state=part->boids->states.first; state; state=state->next) {
if(state->flag & BOIDSTATE_CURRENT) {
BLI_remlink(&part->boids->states, state);
MEM_freeN(state);
break;
}
}
/* there must be at least one state */
if(!part->boids->states.first) {
state = boid_new_state(part->boids);
BLI_addtail(&part->boids->states, state);
}
else
state = part->boids->states.first;
state->flag |= BOIDSTATE_CURRENT;
DAG_scene_sort(bmain, scene);
DAG_id_tag_update(&psys->part->id, OB_RECALC_DATA|PSYS_RECALC_RESET);
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
return OPERATOR_FINISHED;
}
void BLI_sortlist_r(ListBase *listbase, void *thunk, int (*cmp)(void *, void *, void *))
{
Link *current = NULL;
Link *previous = NULL;
Link *next = NULL;
if (listbase->first != listbase->last) {
for (previous = listbase->first, current = previous->next; current; current = next) {
next = current->next;
previous = current->prev;
BLI_remlink(listbase, current);
while (previous && cmp(thunk, previous, current) == 1) {
previous = previous->prev;
}
BLI_insertlinkafter(listbase, previous, current);
}
}
}
