void BKE_sound_free(bSound *sound) { if (sound->packedfile) { freePackedFile(sound->packedfile); sound->packedfile = NULL; } #ifdef WITH_AUDASPACE if (sound->handle) { AUD_Sound_free(sound->handle); sound->handle = NULL; sound->playback_handle = NULL; } if (sound->cache) { AUD_Sound_free(sound->cache); sound->cache = NULL; } BKE_sound_free_waveform(sound); if (sound->spinlock) { BLI_spin_end(sound->spinlock); MEM_freeN(sound->spinlock); sound->spinlock = NULL; } #endif /* WITH_AUDASPACE */ }
void BLI_threadapi_exit(void) { if (task_scheduler) { BLI_task_scheduler_free(task_scheduler); } BLI_spin_end(&_malloc_lock); }
void tracks_map_free(TracksMap *map, void (*customdata_free)(void *customdata)) { int i = 0; BLI_ghash_free(map->hash, NULL, NULL); for (i = 0; i < map->num_tracks; i++) { if (map->customdata && customdata_free) customdata_free(&map->customdata[i * map->customdata_size]); BKE_tracking_track_free(&map->tracks[i]); } if (map->customdata) MEM_freeN(map->customdata); MEM_freeN(map->tracks); BLI_spin_end(&map->spin_lock); MEM_freeN(map); }
static void start_prefetch_threads(MovieClip *clip, int start_frame, int current_frame, int end_frame, short render_size, short render_flag, short *stop, short *do_update, float *progress) { PrefetchQueue queue; TaskScheduler *task_scheduler = BLI_task_scheduler_get(); TaskPool *task_pool; int i, tot_thread = BLI_task_scheduler_num_threads(task_scheduler); /* initialize queue */ BLI_spin_init(&queue.spin); queue.current_frame = current_frame; queue.initial_frame = current_frame; queue.start_frame = start_frame; queue.end_frame = end_frame; queue.render_size = render_size; queue.render_flag = render_flag; queue.forward = 1; queue.stop = stop; queue.do_update = do_update; queue.progress = progress; task_pool = BLI_task_pool_create(task_scheduler, &queue); for (i = 0; i < tot_thread; i++) { BLI_task_pool_push(task_pool, prefetch_task_func, clip, false, TASK_PRIORITY_LOW); } BLI_task_pool_work_and_wait(task_pool); BLI_task_pool_free(task_pool); BLI_spin_end(&queue.spin); }
void image_undo_end_locks(void) { BLI_spin_end(&undolock); }
void blf_font_exit(void) { FT_Done_FreeType(ft_lib); BLI_spin_end(&ft_lib_mutex); }
void imb_refcounter_lock_exit(void) { BLI_spin_end(&refcounter_spin); }
static void do_multires_bake(MultiresBakeRender *bkr, Image *ima, int require_tangent, MPassKnownData passKnownData, MInitBakeData initBakeData, MApplyBakeData applyBakeData, MFreeBakeData freeBakeData) { DerivedMesh *dm = bkr->lores_dm; const int lvl = bkr->lvl; const int tot_face = dm->getNumTessFaces(dm); if (tot_face > 0) { MultiresBakeThread *handles; MultiresBakeQueue queue; ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL); MVert *mvert = dm->getVertArray(dm); MFace *mface = dm->getTessFaceArray(dm); MTFace *mtface = dm->getTessFaceDataArray(dm, CD_MTFACE); float *precomputed_normals = dm->getTessFaceDataArray(dm, CD_NORMAL); float *pvtangent = NULL; ListBase threads; int i, tot_thread = bkr->threads > 0 ? bkr->threads : BLI_system_thread_count(); void *bake_data = NULL; if (require_tangent) { if (CustomData_get_layer_index(&dm->faceData, CD_TANGENT) == -1) DM_add_tangent_layer(dm); pvtangent = DM_get_tessface_data_layer(dm, CD_TANGENT); } /* all threads shares the same custom bake data */ if (initBakeData) bake_data = initBakeData(bkr, ima); if (tot_thread > 1) BLI_init_threads(&threads, do_multires_bake_thread, tot_thread); handles = MEM_callocN(tot_thread * sizeof(MultiresBakeThread), "do_multires_bake handles"); /* faces queue */ queue.cur_face = 0; queue.tot_face = tot_face; BLI_spin_init(&queue.spin); /* fill in threads handles */ for (i = 0; i < tot_thread; i++) { MultiresBakeThread *handle = &handles[i]; handle->bkr = bkr; handle->image = ima; handle->queue = &queue; handle->data.mface = mface; handle->data.mvert = mvert; handle->data.mtface = mtface; handle->data.pvtangent = pvtangent; handle->data.precomputed_normals = precomputed_normals; /* don't strictly need this */ handle->data.w = ibuf->x; handle->data.h = ibuf->y; handle->data.lores_dm = dm; handle->data.hires_dm = bkr->hires_dm; handle->data.lvl = lvl; handle->data.pass_data = passKnownData; handle->data.bake_data = bake_data; handle->data.ibuf = ibuf; init_bake_rast(&handle->bake_rast, ibuf, &handle->data, flush_pixel); if (tot_thread > 1) BLI_insert_thread(&threads, handle); } /* run threads */ if (tot_thread > 1) BLI_end_threads(&threads); else do_multires_bake_thread(&handles[0]); BLI_spin_end(&queue.spin); /* finalize baking */ if (applyBakeData) applyBakeData(bake_data); if (freeBakeData) freeBakeData(bake_data); BKE_image_release_ibuf(ima, ibuf, NULL); } }
void BKE_cachefiles_exit(void) { BLI_spin_end(&spin); }
void imb_mmap_lock_exit(void) { BLI_spin_end(&mmap_spin); }
static void do_sequence_proxy(void *pjv, int *build_sizes, int build_count, int *build_undistort_sizes, int build_undistort_count, short *stop, short *do_update, float *progress) { ProxyJob *pj = pjv; MovieClip *clip = pj->clip; Scene *scene = pj->scene; TaskScheduler *task_scheduler = BLI_task_scheduler_get(); TaskPool *task_pool; int sfra = SFRA, efra = EFRA; ProxyThread *handles; int i, tot_thread = BLI_task_scheduler_num_threads(task_scheduler); int width, height; ProxyQueue queue; if (build_undistort_count) { BKE_movieclip_get_size(clip, NULL, &width, &height); } BLI_spin_init(&queue.spin); queue.cfra = sfra; queue.sfra = sfra; queue.efra = efra; queue.stop = stop; queue.do_update = do_update; queue.progress = progress; task_pool = BLI_task_pool_create(task_scheduler, &queue); handles = MEM_callocN(sizeof(ProxyThread) * tot_thread, "proxy threaded handles"); for (i = 0; i < tot_thread; i++) { ProxyThread *handle = &handles[i]; handle->clip = clip; handle->build_count = build_count; handle->build_sizes = build_sizes; handle->build_undistort_count = build_undistort_count; handle->build_undistort_sizes = build_undistort_sizes; if (build_undistort_count) { handle->distortion = BKE_tracking_distortion_new(&clip->tracking, width, height); } BLI_task_pool_push(task_pool, proxy_task_func, handle, false, TASK_PRIORITY_LOW); } BLI_task_pool_work_and_wait(task_pool); BLI_task_pool_free(task_pool); if (build_undistort_count) { for (i = 0; i < tot_thread; i++) { ProxyThread *handle = &handles[i]; BKE_tracking_distortion_free(handle->distortion); } } BLI_spin_end(&queue.spin); MEM_freeN(handles); }
void BKE_main_free(Main *mainvar) { /* also call when reading a file, erase all, etc */ ListBase *lbarray[MAX_LIBARRAY]; int a; a = set_listbasepointers(mainvar, lbarray); while (a--) { ListBase *lb = lbarray[a]; ID *id; while ( (id = lb->first) ) { #if 1 BKE_libblock_free_ex(mainvar, id, false); #else /* errors freeing ID's can be hard to track down, * enable this so valgrind will give the line number in its error log */ switch (a) { case 0: BKE_libblock_free_ex(mainvar, id, false); break; case 1: BKE_libblock_free_ex(mainvar, id, false); break; case 2: BKE_libblock_free_ex(mainvar, id, false); break; case 3: BKE_libblock_free_ex(mainvar, id, false); break; case 4: BKE_libblock_free_ex(mainvar, id, false); break; case 5: BKE_libblock_free_ex(mainvar, id, false); break; case 6: BKE_libblock_free_ex(mainvar, id, false); break; case 7: BKE_libblock_free_ex(mainvar, id, false); break; case 8: BKE_libblock_free_ex(mainvar, id, false); break; case 9: BKE_libblock_free_ex(mainvar, id, false); break; case 10: BKE_libblock_free_ex(mainvar, id, false); break; case 11: BKE_libblock_free_ex(mainvar, id, false); break; case 12: BKE_libblock_free_ex(mainvar, id, false); break; case 13: BKE_libblock_free_ex(mainvar, id, false); break; case 14: BKE_libblock_free_ex(mainvar, id, false); break; case 15: BKE_libblock_free_ex(mainvar, id, false); break; case 16: BKE_libblock_free_ex(mainvar, id, false); break; case 17: BKE_libblock_free_ex(mainvar, id, false); break; case 18: BKE_libblock_free_ex(mainvar, id, false); break; case 19: BKE_libblock_free_ex(mainvar, id, false); break; case 20: BKE_libblock_free_ex(mainvar, id, false); break; case 21: BKE_libblock_free_ex(mainvar, id, false); break; case 22: BKE_libblock_free_ex(mainvar, id, false); break; case 23: BKE_libblock_free_ex(mainvar, id, false); break; case 24: BKE_libblock_free_ex(mainvar, id, false); break; case 25: BKE_libblock_free_ex(mainvar, id, false); break; case 26: BKE_libblock_free_ex(mainvar, id, false); break; case 27: BKE_libblock_free_ex(mainvar, id, false); break; case 28: BKE_libblock_free_ex(mainvar, id, false); break; case 29: BKE_libblock_free_ex(mainvar, id, false); break; case 30: BKE_libblock_free_ex(mainvar, id, false); break; case 31: BKE_libblock_free_ex(mainvar, id, false); break; case 32: BKE_libblock_free_ex(mainvar, id, false); break; default: BLI_assert(0); break; } #endif } } BLI_spin_end((SpinLock *)mainvar->lock); MEM_freeN(mainvar->lock); MEM_freeN(mainvar->eval_ctx); MEM_freeN(mainvar); }
void BKE_main_free(Main *mainvar) { /* also call when reading a file, erase all, etc */ ListBase *lbarray[MAX_LIBARRAY]; int a; /* Since we are removing whole main, no need to bother 'properly' * (and slowly) removing each ID from it. */ const int free_flag = (LIB_ID_FREE_NO_MAIN | LIB_ID_FREE_NO_UI_USER | LIB_ID_FREE_NO_USER_REFCOUNT | LIB_ID_FREE_NO_DEG_TAG); MEM_SAFE_FREE(mainvar->blen_thumb); a = set_listbasepointers(mainvar, lbarray); while (a--) { ListBase *lb = lbarray[a]; ID *id, *id_next; for (id = lb->first; id != NULL; id = id_next) { id_next = id->next; #if 1 BKE_id_free_ex(mainvar, id, free_flag, false); #else /* errors freeing ID's can be hard to track down, * enable this so valgrind will give the line number in its error log */ switch (a) { case 0: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 1: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 2: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 3: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 4: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 5: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 6: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 7: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 8: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 9: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 10: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 11: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 12: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 13: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 14: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 15: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 16: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 17: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 18: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 19: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 20: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 21: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 22: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 23: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 24: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 25: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 26: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 27: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 28: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 29: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 30: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 31: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 32: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 33: BKE_id_free_ex(mainvar, id, free_flag, false); break; case 34: BKE_id_free_ex(mainvar, id, free_flag, false); break; default: BLI_assert(0); break; } #endif } BLI_listbase_clear(lb); } if (mainvar->relations) { BKE_main_relations_free(mainvar); } BLI_spin_end((SpinLock *)mainvar->lock); MEM_freeN(mainvar->lock); MEM_freeN(mainvar); }
static void screen_opengl_render_end(bContext *C, OGLRender *oglrender) { Main *bmain = CTX_data_main(C); Scene *scene = oglrender->scene; int i; if (oglrender->is_animation) { BLI_task_pool_work_and_wait(oglrender->task_pool); BLI_task_pool_free(oglrender->task_pool); /* Depending on various things we might or might not use global scheduler. */ if (oglrender->task_scheduler != NULL) { BLI_task_scheduler_free(oglrender->task_scheduler); } BLI_spin_end(&oglrender->reports_lock); } BLI_mutex_end(&oglrender->task_mutex); BLI_condition_end(&oglrender->task_condition); #ifdef DEBUG_TIME printf("Total render time: %f\n", PIL_check_seconds_timer() - oglrender->time_start); #endif if (oglrender->mh) { if (BKE_imtype_is_movie(scene->r.im_format.imtype)) { for (i = 0; i < oglrender->totvideos; i++) { oglrender->mh->end_movie(oglrender->movie_ctx_arr[i]); oglrender->mh->context_free(oglrender->movie_ctx_arr[i]); } } if (oglrender->movie_ctx_arr) { MEM_freeN(oglrender->movie_ctx_arr); } } if (oglrender->timer) { /* exec will not have a timer */ scene->r.cfra = oglrender->cfrao; BKE_scene_update_for_newframe(bmain->eval_ctx, bmain, scene, screen_opengl_layers(oglrender)); WM_event_remove_timer(oglrender->wm, oglrender->win, oglrender->timer); } WM_cursor_modal_restore(oglrender->win); WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, oglrender->scene); if (oglrender->fx) GPU_fx_compositor_destroy(oglrender->fx); GPU_offscreen_free(oglrender->ofs); if (oglrender->is_sequencer) { MEM_freeN(oglrender->seq_data.ibufs_arr); } oglrender->scene->customdata_mask_modal = 0; CTX_wm_area_set(C, oglrender->prevsa); CTX_wm_region_set(C, oglrender->prevar); MEM_freeN(oglrender); }