8e64c02fbb38438700dd4eba8643a36a7d5f326c
[blender-staging.git] / source / blender / blenkernel / intern / movieclip.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2011 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <stdio.h>
25 #include <string.h>
26 #include <fcntl.h>
27
28 #ifndef WIN32
29 #  include <unistd.h>
30 #else
31 #  include <io.h>
32 #endif
33
34 #include <time.h>
35
36 #include "MEM_guardedalloc.h"
37
38 #include "DNA_constraint_types.h"
39 #include "DNA_screen_types.h"
40 #include "DNA_space_types.h"
41 #include "DNA_movieclip_types.h"
42 #include "DNA_node_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_scene_types.h"
45 #include "DNA_view3d_types.h"
46
47 #include "BLI_utildefines.h"
48
49 #include "BLI_blenlib.h"
50 #include "BLI_ghash.h"
51 #include "BLI_math.h"
52 #include "BLI_threads.h"
53
54 #include "BKE_animsys.h"
55 #include "BKE_colortools.h"
56 #include "BKE_global.h"
57 #include "BKE_lib_id.h"
58 #include "BKE_main.h"
59 #include "BKE_movieclip.h"
60 #include "BKE_node.h"
61 #include "BKE_image.h" /* openanim */
62 #include "BKE_tracking.h"
63
64 #include "IMB_imbuf_types.h"
65 #include "IMB_imbuf.h"
66 #include "IMB_moviecache.h"
67
68 #include "DEG_depsgraph.h"
69 #include "DEG_depsgraph_query.h"
70
71 #include "GPU_texture.h"
72
73 #ifdef WITH_OPENEXR
74 #  include "intern/openexr/openexr_multi.h"
75 #endif
76
77 /*********************** movieclip buffer loaders *************************/
78
79 static int sequence_guess_offset(const char *full_name, int head_len, unsigned short numlen)
80 {
81   char num[FILE_MAX] = {0};
82
83   BLI_strncpy(num, full_name + head_len, numlen + 1);
84
85   return atoi(num);
86 }
87
88 static int rendersize_to_proxy(const MovieClipUser *user, int flag)
89 {
90   if ((flag & MCLIP_USE_PROXY) == 0) {
91     return IMB_PROXY_NONE;
92   }
93
94   switch (user->render_size) {
95     case MCLIP_PROXY_RENDER_SIZE_25:
96       return IMB_PROXY_25;
97
98     case MCLIP_PROXY_RENDER_SIZE_50:
99       return IMB_PROXY_50;
100
101     case MCLIP_PROXY_RENDER_SIZE_75:
102       return IMB_PROXY_75;
103
104     case MCLIP_PROXY_RENDER_SIZE_100:
105       return IMB_PROXY_100;
106
107     case MCLIP_PROXY_RENDER_SIZE_FULL:
108       return IMB_PROXY_NONE;
109   }
110
111   return IMB_PROXY_NONE;
112 }
113
114 static int rendersize_to_number(int render_size)
115 {
116   switch (render_size) {
117     case MCLIP_PROXY_RENDER_SIZE_25:
118       return 25;
119
120     case MCLIP_PROXY_RENDER_SIZE_50:
121       return 50;
122
123     case MCLIP_PROXY_RENDER_SIZE_75:
124       return 75;
125
126     case MCLIP_PROXY_RENDER_SIZE_100:
127       return 100;
128
129     case MCLIP_PROXY_RENDER_SIZE_FULL:
130       return 100;
131   }
132
133   return 100;
134 }
135
136 static int get_timecode(MovieClip *clip, int flag)
137 {
138   if ((flag & MCLIP_USE_PROXY) == 0) {
139     return IMB_TC_NONE;
140   }
141
142   return clip->proxy.tc;
143 }
144
145 static void get_sequence_fname(const MovieClip *clip, const int framenr, char *name)
146 {
147   unsigned short numlen;
148   char head[FILE_MAX], tail[FILE_MAX];
149   int offset;
150
151   BLI_strncpy(name, clip->name, sizeof(clip->name));
152   BLI_stringdec(name, head, tail, &numlen);
153
154   /* Movie-clips always points to first image from sequence, auto-guess offset for now.
155    * Could be something smarter in the future. */
156   offset = sequence_guess_offset(clip->name, strlen(head), numlen);
157
158   if (numlen) {
159     BLI_stringenc(
160         name, head, tail, numlen, offset + framenr - clip->start_frame + clip->frame_offset);
161   }
162   else {
163     BLI_strncpy(name, clip->name, sizeof(clip->name));
164   }
165
166   BLI_path_abs(name, ID_BLEND_PATH_FROM_GLOBAL(&clip->id));
167 }
168
169 /* supposed to work with sequences only */
170 static void get_proxy_fname(
171     const MovieClip *clip, int proxy_render_size, bool undistorted, int framenr, char *name)
172 {
173   int size = rendersize_to_number(proxy_render_size);
174   char dir[FILE_MAX], clipdir[FILE_MAX], clipfile[FILE_MAX];
175   int proxynr = framenr - clip->start_frame + 1 + clip->frame_offset;
176
177   BLI_split_dirfile(clip->name, clipdir, clipfile, FILE_MAX, FILE_MAX);
178
179   if (clip->flag & MCLIP_USE_PROXY_CUSTOM_DIR) {
180     BLI_strncpy(dir, clip->proxy.dir, sizeof(dir));
181   }
182   else {
183     BLI_snprintf(dir, FILE_MAX, "%s/BL_proxy", clipdir);
184   }
185
186   if (undistorted) {
187     BLI_snprintf(name, FILE_MAX, "%s/%s/proxy_%d_undistorted/%08d", dir, clipfile, size, proxynr);
188   }
189   else {
190     BLI_snprintf(name, FILE_MAX, "%s/%s/proxy_%d/%08d", dir, clipfile, size, proxynr);
191   }
192
193   BLI_path_abs(name, BKE_main_blendfile_path_from_global());
194   BLI_path_frame(name, 1, 0);
195
196   strcat(name, ".jpg");
197 }
198
199 #ifdef WITH_OPENEXR
200
201 typedef struct MultilayerConvertContext {
202   float *combined_pass;
203   int num_combined_channels;
204 } MultilayerConvertContext;
205
206 static void *movieclip_convert_multilayer_add_view(void *UNUSED(ctx_v),
207                                                    const char *UNUSED(view_name))
208 {
209   return NULL;
210 }
211
212 static void *movieclip_convert_multilayer_add_layer(void *ctx_v, const char *UNUSED(layer_name))
213 {
214   /* Return dummy non-NULL value, we don't use layer handle but need to return
215    * something, so render API invokes the add_pass() callbacks. */
216   return ctx_v;
217 }
218
219 static void movieclip_convert_multilayer_add_pass(void *UNUSED(layer),
220                                                   void *ctx_v,
221                                                   const char *pass_name,
222                                                   float *rect,
223                                                   int num_channels,
224                                                   const char *chan_id,
225                                                   const char *UNUSED(view_name))
226 {
227   /* NOTE: This function must free pass pixels data if it is not used, this
228    * is how IMB_exr_multilayer_convert() is working. */
229   MultilayerConvertContext *ctx = ctx_v;
230   /* If we've found a first combined pass, skip all the rest ones. */
231   if (ctx->combined_pass != NULL) {
232     MEM_freeN(rect);
233     return;
234   }
235   if (STREQ(pass_name, RE_PASSNAME_COMBINED) || STREQ(chan_id, "RGBA") || STREQ(chan_id, "RGB")) {
236     ctx->combined_pass = rect;
237     ctx->num_combined_channels = num_channels;
238   }
239   else {
240     MEM_freeN(rect);
241   }
242 }
243
244 #endif /* WITH_OPENEXR */
245
246 /* Will try to make image buffer usable when originating from the multi-layer
247  * source.
248  * Internally finds a first combined pass and uses that as a buffer. Not ideal,
249  * but is better than a complete empty buffer. */
250 void BKE_movieclip_convert_multilayer_ibuf(struct ImBuf *ibuf)
251 {
252   if (ibuf == NULL) {
253     return;
254   }
255 #ifdef WITH_OPENEXR
256   if (ibuf->ftype != IMB_FTYPE_OPENEXR || ibuf->userdata == NULL) {
257     return;
258   }
259   MultilayerConvertContext ctx;
260   ctx.combined_pass = NULL;
261   ctx.num_combined_channels = 0;
262   IMB_exr_multilayer_convert(ibuf->userdata,
263                              &ctx,
264                              movieclip_convert_multilayer_add_view,
265                              movieclip_convert_multilayer_add_layer,
266                              movieclip_convert_multilayer_add_pass);
267   if (ctx.combined_pass != NULL) {
268     BLI_assert(ibuf->rect_float == NULL);
269     ibuf->rect_float = ctx.combined_pass;
270     ibuf->channels = ctx.num_combined_channels;
271     ibuf->flags |= IB_rectfloat;
272     ibuf->mall |= IB_rectfloat;
273   }
274   IMB_exr_close(ibuf->userdata);
275   ibuf->userdata = NULL;
276 #endif
277 }
278
279 static ImBuf *movieclip_load_sequence_file(MovieClip *clip,
280                                            const MovieClipUser *user,
281                                            int framenr,
282                                            int flag)
283 {
284   struct ImBuf *ibuf;
285   char name[FILE_MAX];
286   int loadflag;
287   bool use_proxy = false;
288   char *colorspace;
289
290   use_proxy = (flag & MCLIP_USE_PROXY) && user->render_size != MCLIP_PROXY_RENDER_SIZE_FULL;
291   if (use_proxy) {
292     int undistort = user->render_flag & MCLIP_PROXY_RENDER_UNDISTORT;
293     get_proxy_fname(clip, user->render_size, undistort, framenr, name);
294
295     /* Well, this is a bit weird, but proxies for movie sources
296      * are built in the same exact color space as the input,
297      *
298      * But image sequences are built in the display space.
299      */
300     if (clip->source == MCLIP_SRC_MOVIE) {
301       colorspace = clip->colorspace_settings.name;
302     }
303     else {
304       colorspace = NULL;
305     }
306   }
307   else {
308     get_sequence_fname(clip, framenr, name);
309     colorspace = clip->colorspace_settings.name;
310   }
311
312   loadflag = IB_rect | IB_multilayer | IB_alphamode_detect | IB_metadata;
313
314   /* read ibuf */
315   ibuf = IMB_loadiffname(name, loadflag, colorspace);
316   BKE_movieclip_convert_multilayer_ibuf(ibuf);
317
318   return ibuf;
319 }
320
321 static void movieclip_open_anim_file(MovieClip *clip)
322 {
323   char str[FILE_MAX];
324
325   if (!clip->anim) {
326     BLI_strncpy(str, clip->name, FILE_MAX);
327     BLI_path_abs(str, ID_BLEND_PATH_FROM_GLOBAL(&clip->id));
328
329     /* FIXME: make several stream accessible in image editor, too */
330     clip->anim = openanim(str, IB_rect, 0, clip->colorspace_settings.name);
331
332     if (clip->anim) {
333       if (clip->flag & MCLIP_USE_PROXY_CUSTOM_DIR) {
334         char dir[FILE_MAX];
335         BLI_strncpy(dir, clip->proxy.dir, sizeof(dir));
336         BLI_path_abs(dir, BKE_main_blendfile_path_from_global());
337         IMB_anim_set_index_dir(clip->anim, dir);
338       }
339     }
340   }
341 }
342
343 static ImBuf *movieclip_load_movie_file(MovieClip *clip,
344                                         const MovieClipUser *user,
345                                         int framenr,
346                                         int flag)
347 {
348   ImBuf *ibuf = NULL;
349   int tc = get_timecode(clip, flag);
350   int proxy = rendersize_to_proxy(user, flag);
351
352   movieclip_open_anim_file(clip);
353
354   if (clip->anim) {
355     int fra = framenr - clip->start_frame + clip->frame_offset;
356
357     ibuf = IMB_anim_absolute(clip->anim, fra, tc, proxy);
358   }
359
360   return ibuf;
361 }
362
363 static void movieclip_calc_length(MovieClip *clip)
364 {
365   if (clip->source == MCLIP_SRC_MOVIE) {
366     movieclip_open_anim_file(clip);
367
368     if (clip->anim) {
369       clip->len = IMB_anim_get_duration(clip->anim, clip->proxy.tc);
370     }
371   }
372   else if (clip->source == MCLIP_SRC_SEQUENCE) {
373     unsigned short numlen;
374     char name[FILE_MAX], head[FILE_MAX], tail[FILE_MAX];
375
376     BLI_stringdec(clip->name, head, tail, &numlen);
377
378     if (numlen == 0) {
379       /* there's no number group in file name, assume it's single framed sequence */
380       clip->len = 1;
381     }
382     else {
383       clip->len = 0;
384       for (;;) {
385         get_sequence_fname(clip, clip->len + clip->start_frame, name);
386
387         if (BLI_exists(name)) {
388           clip->len++;
389         }
390         else {
391           break;
392         }
393       }
394     }
395   }
396 }
397
398 /*********************** image buffer cache *************************/
399
400 typedef struct MovieClipCache {
401   /* regular movie cache */
402   struct MovieCache *moviecache;
403
404   /* cached postprocessed shot */
405   struct {
406     ImBuf *ibuf;
407     int framenr;
408     int flag;
409
410     /* cache for undistorted shot */
411     float principal[2];
412     float polynomial_k1;
413     float division_k1;
414     short distortion_model;
415     bool undistortion_used;
416
417     int proxy;
418     short render_flag;
419   } postprocessed;
420
421   /* cache for stable shot */
422   struct {
423     ImBuf *reference_ibuf;
424
425     ImBuf *ibuf;
426     int framenr;
427     int postprocess_flag;
428
429     float loc[2], scale, angle, aspect;
430     int proxy, filter;
431     short render_flag;
432   } stabilized;
433
434   int sequence_offset;
435
436   bool is_still_sequence;
437 } MovieClipCache;
438
439 typedef struct MovieClipImBufCacheKey {
440   int framenr;
441   int proxy;
442   short render_flag;
443 } MovieClipImBufCacheKey;
444
445 typedef struct MovieClipCachePriorityData {
446   int framenr;
447 } MovieClipCachePriorityData;
448
449 static int user_frame_to_cache_frame(MovieClip *clip, int framenr)
450 {
451   int index;
452
453   index = framenr - clip->start_frame + clip->frame_offset;
454
455   if (clip->source == MCLIP_SRC_SEQUENCE) {
456     if (clip->cache->sequence_offset == -1) {
457       unsigned short numlen;
458       char head[FILE_MAX], tail[FILE_MAX];
459
460       BLI_stringdec(clip->name, head, tail, &numlen);
461
462       /* see comment in get_sequence_fname */
463       clip->cache->sequence_offset = sequence_guess_offset(clip->name, strlen(head), numlen);
464     }
465
466     index += clip->cache->sequence_offset;
467   }
468
469   if (index < 0) {
470     return framenr - index;
471   }
472
473   return framenr;
474 }
475
476 static void moviecache_keydata(void *userkey, int *framenr, int *proxy, int *render_flags)
477 {
478   const MovieClipImBufCacheKey *key = userkey;
479
480   *framenr = key->framenr;
481   *proxy = key->proxy;
482   *render_flags = key->render_flag;
483 }
484
485 static unsigned int moviecache_hashhash(const void *keyv)
486 {
487   const MovieClipImBufCacheKey *key = keyv;
488   int rval = key->framenr;
489
490   return rval;
491 }
492
493 static bool moviecache_hashcmp(const void *av, const void *bv)
494 {
495   const MovieClipImBufCacheKey *a = av;
496   const MovieClipImBufCacheKey *b = bv;
497
498   return ((a->framenr != b->framenr) || (a->proxy != b->proxy) ||
499           (a->render_flag != b->render_flag));
500 }
501
502 static void *moviecache_getprioritydata(void *key_v)
503 {
504   MovieClipImBufCacheKey *key = (MovieClipImBufCacheKey *)key_v;
505   MovieClipCachePriorityData *priority_data;
506
507   priority_data = MEM_callocN(sizeof(*priority_data), "movie cache clip priority data");
508   priority_data->framenr = key->framenr;
509
510   return priority_data;
511 }
512
513 static int moviecache_getitempriority(void *last_userkey_v, void *priority_data_v)
514 {
515   MovieClipImBufCacheKey *last_userkey = (MovieClipImBufCacheKey *)last_userkey_v;
516   MovieClipCachePriorityData *priority_data = (MovieClipCachePriorityData *)priority_data_v;
517
518   return -abs(last_userkey->framenr - priority_data->framenr);
519 }
520
521 static void moviecache_prioritydeleter(void *priority_data_v)
522 {
523   MovieClipCachePriorityData *priority_data = (MovieClipCachePriorityData *)priority_data_v;
524
525   MEM_freeN(priority_data);
526 }
527
528 static ImBuf *get_imbuf_cache(MovieClip *clip, const MovieClipUser *user, int flag)
529 {
530   if (clip->cache) {
531     MovieClipImBufCacheKey key;
532
533     if (!clip->cache->is_still_sequence) {
534       key.framenr = user_frame_to_cache_frame(clip, user->framenr);
535     }
536     else {
537       key.framenr = 1;
538     }
539
540     if (flag & MCLIP_USE_PROXY) {
541       key.proxy = rendersize_to_proxy(user, flag);
542       key.render_flag = user->render_flag;
543     }
544     else {
545       key.proxy = IMB_PROXY_NONE;
546       key.render_flag = 0;
547     }
548
549     return IMB_moviecache_get(clip->cache->moviecache, &key);
550   }
551
552   return NULL;
553 }
554
555 static bool has_imbuf_cache(MovieClip *clip, MovieClipUser *user, int flag)
556 {
557   if (clip->cache) {
558     MovieClipImBufCacheKey key;
559
560     key.framenr = user_frame_to_cache_frame(clip, user->framenr);
561
562     if (flag & MCLIP_USE_PROXY) {
563       key.proxy = rendersize_to_proxy(user, flag);
564       key.render_flag = user->render_flag;
565     }
566     else {
567       key.proxy = IMB_PROXY_NONE;
568       key.render_flag = 0;
569     }
570
571     return IMB_moviecache_has_frame(clip->cache->moviecache, &key);
572   }
573
574   return false;
575 }
576
577 static bool put_imbuf_cache(
578     MovieClip *clip, const MovieClipUser *user, ImBuf *ibuf, int flag, bool destructive)
579 {
580   MovieClipImBufCacheKey key;
581
582   if (clip->cache == NULL) {
583     struct MovieCache *moviecache;
584
585     // char cache_name[64];
586     // BLI_snprintf(cache_name, sizeof(cache_name), "movie %s", clip->id.name);
587
588     clip->cache = MEM_callocN(sizeof(MovieClipCache), "movieClipCache");
589
590     moviecache = IMB_moviecache_create(
591         "movieclip", sizeof(MovieClipImBufCacheKey), moviecache_hashhash, moviecache_hashcmp);
592
593     IMB_moviecache_set_getdata_callback(moviecache, moviecache_keydata);
594     IMB_moviecache_set_priority_callback(moviecache,
595                                          moviecache_getprioritydata,
596                                          moviecache_getitempriority,
597                                          moviecache_prioritydeleter);
598
599     clip->cache->moviecache = moviecache;
600     clip->cache->sequence_offset = -1;
601     if (clip->source == MCLIP_SRC_SEQUENCE) {
602       unsigned short numlen;
603       BLI_stringdec(clip->name, NULL, NULL, &numlen);
604       clip->cache->is_still_sequence = (numlen == 0);
605     }
606   }
607
608   if (!clip->cache->is_still_sequence) {
609     key.framenr = user_frame_to_cache_frame(clip, user->framenr);
610   }
611   else {
612     key.framenr = 1;
613   }
614
615   if (flag & MCLIP_USE_PROXY) {
616     key.proxy = rendersize_to_proxy(user, flag);
617     key.render_flag = user->render_flag;
618   }
619   else {
620     key.proxy = IMB_PROXY_NONE;
621     key.render_flag = 0;
622   }
623
624   if (destructive) {
625     IMB_moviecache_put(clip->cache->moviecache, &key, ibuf);
626     return true;
627   }
628   else {
629     return IMB_moviecache_put_if_possible(clip->cache->moviecache, &key, ibuf);
630   }
631 }
632
633 static bool moviecache_check_free_proxy(ImBuf *UNUSED(ibuf), void *userkey, void *UNUSED(userdata))
634 {
635   MovieClipImBufCacheKey *key = (MovieClipImBufCacheKey *)userkey;
636
637   return !(key->proxy == IMB_PROXY_NONE && key->render_flag == 0);
638 }
639
640 /*********************** common functions *************************/
641
642 /* only image block itself */
643 static MovieClip *movieclip_alloc(Main *bmain, const char *name)
644 {
645   MovieClip *clip;
646
647   clip = BKE_libblock_alloc(bmain, ID_MC, name, 0);
648
649   clip->aspx = clip->aspy = 1.0f;
650
651   BKE_tracking_settings_init(&clip->tracking);
652   BKE_color_managed_colorspace_settings_init(&clip->colorspace_settings);
653
654   clip->proxy.build_size_flag = IMB_PROXY_25;
655   clip->proxy.build_tc_flag = IMB_TC_RECORD_RUN | IMB_TC_FREE_RUN |
656                               IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN | IMB_TC_RECORD_RUN_NO_GAPS;
657   clip->proxy.quality = 90;
658
659   clip->start_frame = 1;
660   clip->frame_offset = 0;
661
662   return clip;
663 }
664
665 static void movieclip_load_get_size(MovieClip *clip)
666 {
667   int width, height;
668   MovieClipUser user = {0};
669
670   user.framenr = 1;
671   BKE_movieclip_get_size(clip, &user, &width, &height);
672
673   if (width && height) {
674     clip->tracking.camera.principal[0] = ((float)width) / 2.0f;
675     clip->tracking.camera.principal[1] = ((float)height) / 2.0f;
676   }
677   else {
678     clip->lastsize[0] = clip->lastsize[1] = IMG_SIZE_FALLBACK;
679   }
680 }
681
682 static void detect_clip_source(Main *bmain, MovieClip *clip)
683 {
684   ImBuf *ibuf;
685   char name[FILE_MAX];
686
687   BLI_strncpy(name, clip->name, sizeof(name));
688   BLI_path_abs(name, BKE_main_blendfile_path(bmain));
689
690   ibuf = IMB_testiffname(name, IB_rect | IB_multilayer);
691   if (ibuf) {
692     clip->source = MCLIP_SRC_SEQUENCE;
693     IMB_freeImBuf(ibuf);
694   }
695   else {
696     clip->source = MCLIP_SRC_MOVIE;
697   }
698 }
699
700 /* checks if image was already loaded, then returns same image
701  * otherwise creates new.
702  * does not load ibuf itself
703  * pass on optional frame for #name images */
704 MovieClip *BKE_movieclip_file_add(Main *bmain, const char *name)
705 {
706   MovieClip *clip;
707   int file;
708   char str[FILE_MAX];
709
710   BLI_strncpy(str, name, sizeof(str));
711   BLI_path_abs(str, BKE_main_blendfile_path(bmain));
712
713   /* exists? */
714   file = BLI_open(str, O_BINARY | O_RDONLY, 0);
715   if (file == -1) {
716     return NULL;
717   }
718   close(file);
719
720   /* ** add new movieclip ** */
721
722   /* create a short library name */
723   clip = movieclip_alloc(bmain, BLI_path_basename(name));
724   BLI_strncpy(clip->name, name, sizeof(clip->name));
725
726   detect_clip_source(bmain, clip);
727
728   movieclip_load_get_size(clip);
729   if (clip->lastsize[0]) {
730     int width = clip->lastsize[0];
731
732     clip->tracking.camera.focal = 24.0f * width / clip->tracking.camera.sensor_width;
733   }
734
735   movieclip_calc_length(clip);
736
737   return clip;
738 }
739
740 MovieClip *BKE_movieclip_file_add_exists_ex(Main *bmain, const char *filepath, bool *r_exists)
741 {
742   MovieClip *clip;
743   char str[FILE_MAX], strtest[FILE_MAX];
744
745   BLI_strncpy(str, filepath, sizeof(str));
746   BLI_path_abs(str, BKE_main_blendfile_path(bmain));
747
748   /* first search an identical filepath */
749   for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
750     BLI_strncpy(strtest, clip->name, sizeof(clip->name));
751     BLI_path_abs(strtest, ID_BLEND_PATH(bmain, &clip->id));
752
753     if (BLI_path_cmp(strtest, str) == 0) {
754       id_us_plus(&clip->id); /* officially should not, it doesn't link here! */
755       if (r_exists) {
756         *r_exists = true;
757       }
758       return clip;
759     }
760   }
761
762   if (r_exists) {
763     *r_exists = false;
764   }
765   return BKE_movieclip_file_add(bmain, filepath);
766 }
767
768 MovieClip *BKE_movieclip_file_add_exists(Main *bmain, const char *filepath)
769 {
770   return BKE_movieclip_file_add_exists_ex(bmain, filepath, NULL);
771 }
772
773 static void real_ibuf_size(
774     const MovieClip *clip, const MovieClipUser *user, const ImBuf *ibuf, int *width, int *height)
775 {
776   *width = ibuf->x;
777   *height = ibuf->y;
778
779   if (clip->flag & MCLIP_USE_PROXY) {
780     switch (user->render_size) {
781       case MCLIP_PROXY_RENDER_SIZE_25:
782         (*width) *= 4;
783         (*height) *= 4;
784         break;
785
786       case MCLIP_PROXY_RENDER_SIZE_50:
787         (*width) *= 2.0f;
788         (*height) *= 2.0f;
789         break;
790
791       case MCLIP_PROXY_RENDER_SIZE_75:
792         *width = ((float)*width) * 4.0f / 3.0f;
793         *height = ((float)*height) * 4.0f / 3.0f;
794         break;
795     }
796   }
797 }
798
799 static ImBuf *get_undistorted_ibuf(MovieClip *clip,
800                                    struct MovieDistortion *distortion,
801                                    ImBuf *ibuf)
802 {
803   ImBuf *undistibuf;
804
805   if (distortion) {
806     undistibuf = BKE_tracking_distortion_exec(
807         distortion, &clip->tracking, ibuf, ibuf->x, ibuf->y, 0.0f, 1);
808   }
809   else {
810     undistibuf = BKE_tracking_undistort_frame(&clip->tracking, ibuf, ibuf->x, ibuf->y, 0.0f);
811   }
812
813   IMB_scaleImBuf(undistibuf, ibuf->x, ibuf->y);
814
815   return undistibuf;
816 }
817
818 static bool need_undistortion_postprocess(const MovieClipUser *user, int clip_flag)
819 {
820   bool result = 0;
821   const bool uses_full_frame = ((clip_flag & MCLIP_USE_PROXY) == 0) ||
822                                (user->render_size == MCLIP_PROXY_RENDER_SIZE_FULL);
823   /* Only full undistorted render can be used as on-fly undistorting image. */
824   result |= uses_full_frame && (user->render_flag & MCLIP_PROXY_RENDER_UNDISTORT) != 0;
825   return result;
826 }
827
828 static bool need_postprocessed_frame(const MovieClipUser *user,
829                                      int clip_flag,
830                                      int postprocess_flag)
831 {
832   bool result = (postprocess_flag != 0);
833   result |= need_undistortion_postprocess(user, clip_flag);
834   return result;
835 }
836
837 static bool check_undistortion_cache_flags(const MovieClip *clip)
838 {
839   const MovieClipCache *cache = clip->cache;
840   const MovieTrackingCamera *camera = &clip->tracking.camera;
841
842   /* check for distortion model changes */
843   if (!equals_v2v2(camera->principal, cache->postprocessed.principal)) {
844     return false;
845   }
846
847   if (camera->distortion_model != cache->postprocessed.distortion_model) {
848     return false;
849   }
850
851   if (!equals_v3v3(&camera->k1, &cache->postprocessed.polynomial_k1)) {
852     return false;
853   }
854
855   if (!equals_v2v2(&camera->division_k1, &cache->postprocessed.division_k1)) {
856     return false;
857   }
858
859   return true;
860 }
861
862 static ImBuf *get_postprocessed_cached_frame(const MovieClip *clip,
863                                              const MovieClipUser *user,
864                                              int flag,
865                                              int postprocess_flag)
866 {
867   const MovieClipCache *cache = clip->cache;
868   int framenr = user->framenr;
869   short proxy = IMB_PROXY_NONE;
870   int render_flag = 0;
871
872   if (flag & MCLIP_USE_PROXY) {
873     proxy = rendersize_to_proxy(user, flag);
874     render_flag = user->render_flag;
875   }
876
877   /* no cache or no cached postprocessed image */
878   if (!clip->cache || !clip->cache->postprocessed.ibuf) {
879     return NULL;
880   }
881
882   /* postprocessing happened for other frame */
883   if (cache->postprocessed.framenr != framenr) {
884     return NULL;
885   }
886
887   /* cached ibuf used different proxy settings */
888   if (cache->postprocessed.render_flag != render_flag || cache->postprocessed.proxy != proxy) {
889     return NULL;
890   }
891
892   if (cache->postprocessed.flag != postprocess_flag) {
893     return NULL;
894   }
895
896   if (need_undistortion_postprocess(user, flag)) {
897     if (!check_undistortion_cache_flags(clip)) {
898       return NULL;
899     }
900   }
901   else if (cache->postprocessed.undistortion_used) {
902     return NULL;
903   }
904
905   IMB_refImBuf(cache->postprocessed.ibuf);
906
907   return cache->postprocessed.ibuf;
908 }
909
910 static ImBuf *postprocess_frame(
911     MovieClip *clip, const MovieClipUser *user, ImBuf *ibuf, int flag, int postprocess_flag)
912 {
913   ImBuf *postproc_ibuf = NULL;
914
915   if (need_undistortion_postprocess(user, flag)) {
916     postproc_ibuf = get_undistorted_ibuf(clip, NULL, ibuf);
917   }
918   else {
919     postproc_ibuf = IMB_dupImBuf(ibuf);
920   }
921
922   if (postprocess_flag) {
923     bool disable_red = (postprocess_flag & MOVIECLIP_DISABLE_RED) != 0;
924     bool disable_green = (postprocess_flag & MOVIECLIP_DISABLE_GREEN) != 0;
925     bool disable_blue = (postprocess_flag & MOVIECLIP_DISABLE_BLUE) != 0;
926     bool grayscale = (postprocess_flag & MOVIECLIP_PREVIEW_GRAYSCALE) != 0;
927
928     if (disable_red || disable_green || disable_blue || grayscale) {
929       BKE_tracking_disable_channels(postproc_ibuf, disable_red, disable_green, disable_blue, 1);
930     }
931   }
932
933   return postproc_ibuf;
934 }
935
936 static void put_postprocessed_frame_to_cache(
937     MovieClip *clip, const MovieClipUser *user, ImBuf *ibuf, int flag, int postprocess_flag)
938 {
939   MovieClipCache *cache = clip->cache;
940   MovieTrackingCamera *camera = &clip->tracking.camera;
941
942   cache->postprocessed.framenr = user->framenr;
943   cache->postprocessed.flag = postprocess_flag;
944
945   if (flag & MCLIP_USE_PROXY) {
946     cache->postprocessed.proxy = rendersize_to_proxy(user, flag);
947     cache->postprocessed.render_flag = user->render_flag;
948   }
949   else {
950     cache->postprocessed.proxy = IMB_PROXY_NONE;
951     cache->postprocessed.render_flag = 0;
952   }
953
954   if (need_undistortion_postprocess(user, flag)) {
955     cache->postprocessed.distortion_model = camera->distortion_model;
956     copy_v2_v2(cache->postprocessed.principal, camera->principal);
957     copy_v3_v3(&cache->postprocessed.polynomial_k1, &camera->k1);
958     copy_v2_v2(&cache->postprocessed.division_k1, &camera->division_k1);
959     cache->postprocessed.undistortion_used = true;
960   }
961   else {
962     cache->postprocessed.undistortion_used = false;
963   }
964
965   IMB_refImBuf(ibuf);
966
967   if (cache->postprocessed.ibuf) {
968     IMB_freeImBuf(cache->postprocessed.ibuf);
969   }
970
971   cache->postprocessed.ibuf = ibuf;
972 }
973
974 static ImBuf *movieclip_get_postprocessed_ibuf(
975     MovieClip *clip, const MovieClipUser *user, int flag, int postprocess_flag, int cache_flag)
976 {
977   ImBuf *ibuf = NULL;
978   int framenr = user->framenr;
979   bool need_postprocess = false;
980
981   /* cache isn't threadsafe itself and also loading of movies
982    * can't happen from concurrent threads that's why we use lock here */
983   BLI_thread_lock(LOCK_MOVIECLIP);
984
985   /* try to obtain cached postprocessed frame first */
986   if (need_postprocessed_frame(user, flag, postprocess_flag)) {
987     ibuf = get_postprocessed_cached_frame(clip, user, flag, postprocess_flag);
988
989     if (!ibuf) {
990       need_postprocess = true;
991     }
992   }
993
994   if (!ibuf) {
995     ibuf = get_imbuf_cache(clip, user, flag);
996   }
997
998   if (!ibuf) {
999     bool use_sequence = false;
1000
1001     /* undistorted proxies for movies should be read as image sequence */
1002     use_sequence = (user->render_flag & MCLIP_PROXY_RENDER_UNDISTORT) &&
1003                    (user->render_size != MCLIP_PROXY_RENDER_SIZE_FULL);
1004
1005     if (clip->source == MCLIP_SRC_SEQUENCE || use_sequence) {
1006       ibuf = movieclip_load_sequence_file(clip, user, framenr, flag);
1007     }
1008     else {
1009       ibuf = movieclip_load_movie_file(clip, user, framenr, flag);
1010     }
1011
1012     if (ibuf && (cache_flag & MOVIECLIP_CACHE_SKIP) == 0) {
1013       put_imbuf_cache(clip, user, ibuf, flag, true);
1014     }
1015   }
1016
1017   if (ibuf) {
1018     clip->lastframe = framenr;
1019     real_ibuf_size(clip, user, ibuf, &clip->lastsize[0], &clip->lastsize[1]);
1020
1021     /* postprocess frame and put to cache if needed*/
1022     if (need_postprocess) {
1023       ImBuf *tmpibuf = ibuf;
1024       ibuf = postprocess_frame(clip, user, tmpibuf, flag, postprocess_flag);
1025       IMB_freeImBuf(tmpibuf);
1026       if (ibuf && (cache_flag & MOVIECLIP_CACHE_SKIP) == 0) {
1027         put_postprocessed_frame_to_cache(clip, user, ibuf, flag, postprocess_flag);
1028       }
1029     }
1030   }
1031
1032   BLI_thread_unlock(LOCK_MOVIECLIP);
1033
1034   /* Fallback render in case proxies are not enabled or built */
1035   if (!ibuf && user->render_flag & MCLIP_PROXY_RENDER_USE_FALLBACK_RENDER &&
1036       user->render_size != MCLIP_PROXY_RENDER_SIZE_FULL) {
1037     MovieClipUser user_fallback = *user;
1038     user_fallback.render_size = MCLIP_PROXY_RENDER_SIZE_FULL;
1039
1040     ibuf = movieclip_get_postprocessed_ibuf(
1041         clip, &user_fallback, flag, postprocess_flag, cache_flag);
1042   }
1043
1044   return ibuf;
1045 }
1046
1047 ImBuf *BKE_movieclip_get_ibuf(MovieClip *clip, MovieClipUser *user)
1048 {
1049   return BKE_movieclip_get_ibuf_flag(clip, user, clip->flag, 0);
1050 }
1051
1052 ImBuf *BKE_movieclip_get_ibuf_flag(MovieClip *clip, MovieClipUser *user, int flag, int cache_flag)
1053 {
1054   return movieclip_get_postprocessed_ibuf(clip, user, flag, 0, cache_flag);
1055 }
1056
1057 ImBuf *BKE_movieclip_get_postprocessed_ibuf(MovieClip *clip,
1058                                             MovieClipUser *user,
1059                                             int postprocess_flag)
1060 {
1061   return movieclip_get_postprocessed_ibuf(clip, user, clip->flag, postprocess_flag, 0);
1062 }
1063
1064 static ImBuf *get_stable_cached_frame(
1065     MovieClip *clip, MovieClipUser *user, ImBuf *reference_ibuf, int framenr, int postprocess_flag)
1066 {
1067   MovieClipCache *cache = clip->cache;
1068   MovieTracking *tracking = &clip->tracking;
1069   ImBuf *stableibuf;
1070   float tloc[2], tscale, tangle;
1071   short proxy = IMB_PROXY_NONE;
1072   int render_flag = 0;
1073   int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, framenr);
1074
1075   if (clip->flag & MCLIP_USE_PROXY) {
1076     proxy = rendersize_to_proxy(user, clip->flag);
1077     render_flag = user->render_flag;
1078   }
1079
1080   /* there's no cached frame or it was calculated for another frame */
1081   if (!cache->stabilized.ibuf || cache->stabilized.framenr != framenr) {
1082     return NULL;
1083   }
1084
1085   if (cache->stabilized.reference_ibuf != reference_ibuf) {
1086     return NULL;
1087   }
1088
1089   /* cached ibuf used different proxy settings */
1090   if (cache->stabilized.render_flag != render_flag || cache->stabilized.proxy != proxy) {
1091     return NULL;
1092   }
1093
1094   if (cache->stabilized.postprocess_flag != postprocess_flag) {
1095     return NULL;
1096   }
1097
1098   /* stabilization also depends on pixel aspect ratio */
1099   if (cache->stabilized.aspect != tracking->camera.pixel_aspect) {
1100     return NULL;
1101   }
1102
1103   if (cache->stabilized.filter != tracking->stabilization.filter) {
1104     return NULL;
1105   }
1106
1107   stableibuf = cache->stabilized.ibuf;
1108
1109   BKE_tracking_stabilization_data_get(
1110       clip, clip_framenr, stableibuf->x, stableibuf->y, tloc, &tscale, &tangle);
1111
1112   /* check for stabilization parameters */
1113   if (tscale != cache->stabilized.scale || tangle != cache->stabilized.angle ||
1114       !equals_v2v2(tloc, cache->stabilized.loc)) {
1115     return NULL;
1116   }
1117
1118   IMB_refImBuf(stableibuf);
1119
1120   return stableibuf;
1121 }
1122
1123 static ImBuf *put_stabilized_frame_to_cache(
1124     MovieClip *clip, MovieClipUser *user, ImBuf *ibuf, int framenr, int postprocess_flag)
1125 {
1126   MovieClipCache *cache = clip->cache;
1127   MovieTracking *tracking = &clip->tracking;
1128   ImBuf *stableibuf;
1129   float tloc[2], tscale, tangle;
1130   int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, framenr);
1131
1132   stableibuf = BKE_tracking_stabilize_frame(clip, clip_framenr, ibuf, tloc, &tscale, &tangle);
1133
1134   copy_v2_v2(cache->stabilized.loc, tloc);
1135
1136   cache->stabilized.reference_ibuf = ibuf;
1137   cache->stabilized.scale = tscale;
1138   cache->stabilized.angle = tangle;
1139   cache->stabilized.framenr = framenr;
1140   cache->stabilized.aspect = tracking->camera.pixel_aspect;
1141   cache->stabilized.filter = tracking->stabilization.filter;
1142
1143   if (clip->flag & MCLIP_USE_PROXY) {
1144     cache->stabilized.proxy = rendersize_to_proxy(user, clip->flag);
1145     cache->stabilized.render_flag = user->render_flag;
1146   }
1147   else {
1148     cache->stabilized.proxy = IMB_PROXY_NONE;
1149     cache->stabilized.render_flag = 0;
1150   }
1151
1152   cache->stabilized.postprocess_flag = postprocess_flag;
1153
1154   if (cache->stabilized.ibuf) {
1155     IMB_freeImBuf(cache->stabilized.ibuf);
1156   }
1157
1158   cache->stabilized.ibuf = stableibuf;
1159
1160   IMB_refImBuf(stableibuf);
1161
1162   return stableibuf;
1163 }
1164
1165 ImBuf *BKE_movieclip_get_stable_ibuf(MovieClip *clip,
1166                                      MovieClipUser *user,
1167                                      float loc[2],
1168                                      float *scale,
1169                                      float *angle,
1170                                      int postprocess_flag)
1171 {
1172   ImBuf *ibuf, *stableibuf = NULL;
1173   int framenr = user->framenr;
1174
1175   ibuf = BKE_movieclip_get_postprocessed_ibuf(clip, user, postprocess_flag);
1176
1177   if (!ibuf) {
1178     return NULL;
1179   }
1180
1181   if (clip->tracking.stabilization.flag & TRACKING_2D_STABILIZATION) {
1182     MovieClipCache *cache = clip->cache;
1183
1184     stableibuf = get_stable_cached_frame(clip, user, ibuf, framenr, postprocess_flag);
1185
1186     if (!stableibuf) {
1187       stableibuf = put_stabilized_frame_to_cache(clip, user, ibuf, framenr, postprocess_flag);
1188     }
1189
1190     if (loc) {
1191       copy_v2_v2(loc, cache->stabilized.loc);
1192     }
1193
1194     if (scale) {
1195       *scale = cache->stabilized.scale;
1196     }
1197
1198     if (angle) {
1199       *angle = cache->stabilized.angle;
1200     }
1201   }
1202   else {
1203     if (loc) {
1204       zero_v2(loc);
1205     }
1206
1207     if (scale) {
1208       *scale = 1.0f;
1209     }
1210
1211     if (angle) {
1212       *angle = 0.0f;
1213     }
1214
1215     stableibuf = ibuf;
1216   }
1217
1218   if (stableibuf != ibuf) {
1219     IMB_freeImBuf(ibuf);
1220     ibuf = stableibuf;
1221   }
1222
1223   return ibuf;
1224 }
1225
1226 bool BKE_movieclip_has_frame(MovieClip *clip, MovieClipUser *user)
1227 {
1228   ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
1229
1230   if (ibuf) {
1231     IMB_freeImBuf(ibuf);
1232     return true;
1233   }
1234
1235   return false;
1236 }
1237
1238 void BKE_movieclip_get_size(MovieClip *clip, MovieClipUser *user, int *width, int *height)
1239 {
1240 #if 0
1241   /* originally was needed to support image sequences with different image dimensions,
1242    * which might be useful for such things as reconstruction of unordered image sequence,
1243    * or painting/rotoscoping of non-equal-sized images, but this ended up in unneeded
1244    * cache lookups and even unwanted non-proxied files loading when doing mask parenting,
1245    * so let's disable this for now and assume image sequence consists of images with
1246    * equal sizes (sergey)
1247    * TODO(sergey): Support reading sequences of different resolution.
1248    */
1249   if (user->framenr == clip->lastframe) {
1250 #endif
1251   if (clip->lastsize[0] != 0 && clip->lastsize[1] != 0) {
1252     *width = clip->lastsize[0];
1253     *height = clip->lastsize[1];
1254   }
1255   else {
1256     ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
1257
1258     if (ibuf && ibuf->x && ibuf->y) {
1259       real_ibuf_size(clip, user, ibuf, width, height);
1260     }
1261     else {
1262       *width = clip->lastsize[0];
1263       *height = clip->lastsize[1];
1264     }
1265
1266     if (ibuf) {
1267       IMB_freeImBuf(ibuf);
1268     }
1269   }
1270 }
1271 void BKE_movieclip_get_size_fl(MovieClip *clip, MovieClipUser *user, float size[2])
1272 {
1273   int width, height;
1274   BKE_movieclip_get_size(clip, user, &width, &height);
1275
1276   size[0] = (float)width;
1277   size[1] = (float)height;
1278 }
1279
1280 int BKE_movieclip_get_duration(MovieClip *clip)
1281 {
1282   if (!clip->len) {
1283     movieclip_calc_length(clip);
1284   }
1285
1286   return clip->len;
1287 }
1288
1289 float BKE_movieclip_get_fps(MovieClip *clip)
1290 {
1291   if (clip->source != MCLIP_SRC_MOVIE) {
1292     return 0.0f;
1293   }
1294   movieclip_open_anim_file(clip);
1295   if (clip->anim == NULL) {
1296     return 0.0f;
1297   }
1298   short frs_sec;
1299   float frs_sec_base;
1300   if (IMB_anim_get_fps(clip->anim, &frs_sec, &frs_sec_base, true)) {
1301     return (float)frs_sec / frs_sec_base;
1302   }
1303   return 0.0f;
1304 }
1305
1306 void BKE_movieclip_get_aspect(MovieClip *clip, float *aspx, float *aspy)
1307 {
1308   *aspx = 1.0;
1309
1310   /* x is always 1 */
1311   *aspy = clip->aspy / clip->aspx / clip->tracking.camera.pixel_aspect;
1312 }
1313
1314 /* get segments of cached frames. useful for debugging cache policies */
1315 void BKE_movieclip_get_cache_segments(MovieClip *clip,
1316                                       MovieClipUser *user,
1317                                       int *r_totseg,
1318                                       int **r_points)
1319 {
1320   *r_totseg = 0;
1321   *r_points = NULL;
1322
1323   if (clip->cache) {
1324     int proxy = rendersize_to_proxy(user, clip->flag);
1325
1326     IMB_moviecache_get_cache_segments(
1327         clip->cache->moviecache, proxy, user->render_flag, r_totseg, r_points);
1328   }
1329 }
1330
1331 void BKE_movieclip_user_set_frame(MovieClipUser *iuser, int framenr)
1332 {
1333   /* TODO: clamp framenr here? */
1334
1335   iuser->framenr = framenr;
1336 }
1337
1338 static void free_buffers(MovieClip *clip)
1339 {
1340   if (clip->cache) {
1341     IMB_moviecache_free(clip->cache->moviecache);
1342
1343     if (clip->cache->postprocessed.ibuf) {
1344       IMB_freeImBuf(clip->cache->postprocessed.ibuf);
1345     }
1346
1347     if (clip->cache->stabilized.ibuf) {
1348       IMB_freeImBuf(clip->cache->stabilized.ibuf);
1349     }
1350
1351     MEM_freeN(clip->cache);
1352     clip->cache = NULL;
1353   }
1354
1355   if (clip->anim) {
1356     IMB_free_anim(clip->anim);
1357     clip->anim = NULL;
1358   }
1359
1360   MovieClip_RuntimeGPUTexture *tex;
1361   for (tex = clip->runtime.gputextures.first; tex; tex = tex->next) {
1362     for (int i = 0; i < TEXTARGET_COUNT; i++) {
1363       if (tex->gputexture[i] != NULL) {
1364         GPU_texture_free(tex->gputexture[i]);
1365         tex->gputexture[i] = NULL;
1366       }
1367     }
1368   }
1369   BLI_freelistN(&clip->runtime.gputextures);
1370 }
1371
1372 void BKE_movieclip_clear_cache(MovieClip *clip)
1373 {
1374   free_buffers(clip);
1375 }
1376
1377 void BKE_movieclip_clear_proxy_cache(MovieClip *clip)
1378 {
1379   if (clip->cache && clip->cache->moviecache) {
1380     IMB_moviecache_cleanup(clip->cache->moviecache, moviecache_check_free_proxy, NULL);
1381   }
1382 }
1383
1384 void BKE_movieclip_reload(Main *bmain, MovieClip *clip)
1385 {
1386   /* clear cache */
1387   free_buffers(clip);
1388
1389   /* update clip source */
1390   detect_clip_source(bmain, clip);
1391
1392   clip->lastsize[0] = clip->lastsize[1] = 0;
1393   movieclip_load_get_size(clip);
1394
1395   movieclip_calc_length(clip);
1396
1397   /* same as for image update -- don't use notifiers because they are not 100% sure to succeeded
1398    * (node trees which are not currently visible wouldn't be refreshed)
1399    */
1400   {
1401     Scene *scene;
1402     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1403       if (scene->nodetree) {
1404         nodeUpdateID(scene->nodetree, &clip->id);
1405       }
1406     }
1407   }
1408 }
1409
1410 void BKE_movieclip_update_scopes(MovieClip *clip, MovieClipUser *user, MovieClipScopes *scopes)
1411 {
1412   if (scopes->ok) {
1413     return;
1414   }
1415
1416   if (scopes->track_preview) {
1417     IMB_freeImBuf(scopes->track_preview);
1418     scopes->track_preview = NULL;
1419   }
1420
1421   if (scopes->track_search) {
1422     IMB_freeImBuf(scopes->track_search);
1423     scopes->track_search = NULL;
1424   }
1425
1426   scopes->marker = NULL;
1427   scopes->track = NULL;
1428   scopes->track_locked = true;
1429
1430   if (clip) {
1431     MovieTrackingTrack *act_track = BKE_tracking_track_get_active(&clip->tracking);
1432
1433     if (act_track) {
1434       MovieTrackingTrack *track = act_track;
1435       int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
1436       MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
1437
1438       scopes->marker = marker;
1439       scopes->track = track;
1440
1441       if (marker->flag & MARKER_DISABLED) {
1442         scopes->track_disabled = true;
1443       }
1444       else {
1445         ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
1446
1447         scopes->track_disabled = false;
1448
1449         if (ibuf && (ibuf->rect || ibuf->rect_float)) {
1450           MovieTrackingMarker undist_marker = *marker;
1451
1452           if (user->render_flag & MCLIP_PROXY_RENDER_UNDISTORT) {
1453             int width, height;
1454             float aspy = 1.0f / clip->tracking.camera.pixel_aspect;
1455
1456             BKE_movieclip_get_size(clip, user, &width, &height);
1457
1458             undist_marker.pos[0] *= width;
1459             undist_marker.pos[1] *= height * aspy;
1460
1461             BKE_tracking_undistort_v2(&clip->tracking, undist_marker.pos, undist_marker.pos);
1462
1463             undist_marker.pos[0] /= width;
1464             undist_marker.pos[1] /= height * aspy;
1465           }
1466
1467           scopes->track_search = BKE_tracking_get_search_imbuf(
1468               ibuf, track, &undist_marker, true, true);
1469
1470           scopes->undist_marker = undist_marker;
1471
1472           scopes->frame_width = ibuf->x;
1473           scopes->frame_height = ibuf->y;
1474
1475           scopes->use_track_mask = (track->flag & TRACK_PREVIEW_ALPHA) != 0;
1476         }
1477
1478         IMB_freeImBuf(ibuf);
1479       }
1480
1481       if ((track->flag & TRACK_LOCKED) == 0) {
1482         float pat_min[2], pat_max[2];
1483
1484         scopes->track_locked = false;
1485
1486         /* XXX: would work fine with non-transformed patterns, but would likely fail
1487          *      with transformed patterns, but that would be easier to debug when
1488          *      we'll have real pattern sampling (at least to test) */
1489         BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
1490
1491         scopes->slide_scale[0] = pat_max[0] - pat_min[0];
1492         scopes->slide_scale[1] = pat_max[1] - pat_min[1];
1493       }
1494     }
1495   }
1496
1497   scopes->framenr = user->framenr;
1498   scopes->ok = true;
1499 }
1500
1501 static void movieclip_build_proxy_ibuf(
1502     MovieClip *clip, ImBuf *ibuf, int cfra, int proxy_render_size, bool undistorted, bool threaded)
1503 {
1504   char name[FILE_MAX];
1505   int quality, rectx, recty;
1506   int size = rendersize_to_number(proxy_render_size);
1507   ImBuf *scaleibuf;
1508
1509   get_proxy_fname(clip, proxy_render_size, undistorted, cfra, name);
1510
1511   rectx = ibuf->x * size / 100.0f;
1512   recty = ibuf->y * size / 100.0f;
1513
1514   scaleibuf = IMB_dupImBuf(ibuf);
1515
1516   if (threaded) {
1517     IMB_scaleImBuf_threaded(scaleibuf, (short)rectx, (short)recty);
1518   }
1519   else {
1520     IMB_scaleImBuf(scaleibuf, (short)rectx, (short)recty);
1521   }
1522
1523   quality = clip->proxy.quality;
1524   scaleibuf->ftype = IMB_FTYPE_JPG;
1525   scaleibuf->foptions.quality = quality;
1526   /* unsupported feature only confuses other s/w */
1527   if (scaleibuf->planes == 32) {
1528     scaleibuf->planes = 24;
1529   }
1530
1531   /* TODO: currently the most weak part of multi-threaded proxies,
1532    *       could be solved in a way that thread only prepares memory
1533    *       buffer and write to disk happens separately
1534    */
1535   BLI_thread_lock(LOCK_MOVIECLIP);
1536
1537   BLI_make_existing_file(name);
1538   if (IMB_saveiff(scaleibuf, name, IB_rect) == 0) {
1539     perror(name);
1540   }
1541
1542   BLI_thread_unlock(LOCK_MOVIECLIP);
1543
1544   IMB_freeImBuf(scaleibuf);
1545 }
1546
1547 /* note: currently used by proxy job for movies, threading happens within single frame
1548  * (meaning scaling shall be threaded)
1549  */
1550 void BKE_movieclip_build_proxy_frame(MovieClip *clip,
1551                                      int clip_flag,
1552                                      struct MovieDistortion *distortion,
1553                                      int cfra,
1554                                      int *build_sizes,
1555                                      int build_count,
1556                                      bool undistorted)
1557 {
1558   ImBuf *ibuf;
1559   MovieClipUser user;
1560
1561   if (!build_count) {
1562     return;
1563   }
1564
1565   user.framenr = cfra;
1566   user.render_flag = 0;
1567   user.render_size = MCLIP_PROXY_RENDER_SIZE_FULL;
1568
1569   ibuf = BKE_movieclip_get_ibuf_flag(clip, &user, clip_flag, MOVIECLIP_CACHE_SKIP);
1570
1571   if (ibuf) {
1572     ImBuf *tmpibuf = ibuf;
1573     int i;
1574
1575     if (undistorted) {
1576       tmpibuf = get_undistorted_ibuf(clip, distortion, ibuf);
1577     }
1578
1579     for (i = 0; i < build_count; i++) {
1580       movieclip_build_proxy_ibuf(clip, tmpibuf, cfra, build_sizes[i], undistorted, true);
1581     }
1582
1583     IMB_freeImBuf(ibuf);
1584
1585     if (tmpibuf != ibuf) {
1586       IMB_freeImBuf(tmpibuf);
1587     }
1588   }
1589 }
1590
1591 /* note: currently used by proxy job for sequences, threading happens within sequence
1592  * (different threads handles different frames, no threading within frame is needed)
1593  */
1594 void BKE_movieclip_build_proxy_frame_for_ibuf(MovieClip *clip,
1595                                               ImBuf *ibuf,
1596                                               struct MovieDistortion *distortion,
1597                                               int cfra,
1598                                               int *build_sizes,
1599                                               int build_count,
1600                                               bool undistorted)
1601 {
1602   if (!build_count) {
1603     return;
1604   }
1605
1606   if (ibuf) {
1607     ImBuf *tmpibuf = ibuf;
1608     int i;
1609
1610     if (undistorted) {
1611       tmpibuf = get_undistorted_ibuf(clip, distortion, ibuf);
1612     }
1613
1614     for (i = 0; i < build_count; i++) {
1615       movieclip_build_proxy_ibuf(clip, tmpibuf, cfra, build_sizes[i], undistorted, false);
1616     }
1617
1618     if (tmpibuf != ibuf) {
1619       IMB_freeImBuf(tmpibuf);
1620     }
1621   }
1622 }
1623
1624 /** Free (or release) any data used by this movie clip (does not free the clip itself). */
1625 void BKE_movieclip_free(MovieClip *clip)
1626 {
1627   /* Also frees animdata. */
1628   free_buffers(clip);
1629
1630   BKE_tracking_free(&clip->tracking);
1631   BKE_animdata_free((ID *)clip, false);
1632 }
1633
1634 /**
1635  * Only copy internal data of MovieClip ID from source
1636  * to already allocated/initialized destination.
1637  * You probably never want to use that directly,
1638  * use #BKE_id_copy or #BKE_id_copy_ex for typical needs.
1639  *
1640  * WARNING! This function will not handle ID user count!
1641  *
1642  * \param flag: Copying options (see BKE_lib_id.h's LIB_ID_COPY_... flags for more).
1643  */
1644 void BKE_movieclip_copy_data(Main *UNUSED(bmain),
1645                              MovieClip *clip_dst,
1646                              const MovieClip *clip_src,
1647                              const int flag)
1648 {
1649   /* We never handle usercount here for own data. */
1650   const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
1651
1652   clip_dst->anim = NULL;
1653   clip_dst->cache = NULL;
1654
1655   BKE_tracking_copy(&clip_dst->tracking, &clip_src->tracking, flag_subdata);
1656   clip_dst->tracking_context = NULL;
1657
1658   BKE_color_managed_colorspace_settings_copy(&clip_dst->colorspace_settings,
1659                                              &clip_src->colorspace_settings);
1660 }
1661
1662 MovieClip *BKE_movieclip_copy(Main *bmain, const MovieClip *clip)
1663 {
1664   MovieClip *clip_copy;
1665   BKE_id_copy(bmain, &clip->id, (ID **)&clip_copy);
1666   return clip_copy;
1667 }
1668
1669 void BKE_movieclip_make_local(Main *bmain, MovieClip *clip, const int flags)
1670 {
1671   BKE_lib_id_make_local_generic(bmain, &clip->id, flags);
1672 }
1673
1674 float BKE_movieclip_remap_scene_to_clip_frame(const MovieClip *clip, float framenr)
1675 {
1676   return framenr - (float)clip->start_frame + 1.0f;
1677 }
1678
1679 float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
1680 {
1681   return framenr + (float)clip->start_frame - 1.0f;
1682 }
1683
1684 void BKE_movieclip_filename_for_frame(MovieClip *clip, MovieClipUser *user, char *name)
1685 {
1686   if (clip->source == MCLIP_SRC_SEQUENCE) {
1687     int use_proxy;
1688
1689     use_proxy = (clip->flag & MCLIP_USE_PROXY) &&
1690                 user->render_size != MCLIP_PROXY_RENDER_SIZE_FULL;
1691
1692     if (use_proxy) {
1693       int undistort = user->render_flag & MCLIP_PROXY_RENDER_UNDISTORT;
1694       get_proxy_fname(clip, user->render_size, undistort, user->framenr, name);
1695     }
1696     else {
1697       get_sequence_fname(clip, user->framenr, name);
1698     }
1699   }
1700   else {
1701     BLI_strncpy(name, clip->name, FILE_MAX);
1702     BLI_path_abs(name, ID_BLEND_PATH_FROM_GLOBAL(&clip->id));
1703   }
1704 }
1705
1706 ImBuf *BKE_movieclip_anim_ibuf_for_frame(MovieClip *clip, MovieClipUser *user)
1707 {
1708   ImBuf *ibuf = NULL;
1709
1710   if (clip->source == MCLIP_SRC_MOVIE) {
1711     BLI_thread_lock(LOCK_MOVIECLIP);
1712     ibuf = movieclip_load_movie_file(clip, user, user->framenr, clip->flag);
1713     BLI_thread_unlock(LOCK_MOVIECLIP);
1714   }
1715
1716   return ibuf;
1717 }
1718
1719 bool BKE_movieclip_has_cached_frame(MovieClip *clip, MovieClipUser *user)
1720 {
1721   bool has_frame = false;
1722
1723   BLI_thread_lock(LOCK_MOVIECLIP);
1724   has_frame = has_imbuf_cache(clip, user, clip->flag);
1725   BLI_thread_unlock(LOCK_MOVIECLIP);
1726
1727   return has_frame;
1728 }
1729
1730 bool BKE_movieclip_put_frame_if_possible(MovieClip *clip, MovieClipUser *user, ImBuf *ibuf)
1731 {
1732   bool result;
1733
1734   BLI_thread_lock(LOCK_MOVIECLIP);
1735   result = put_imbuf_cache(clip, user, ibuf, clip->flag, false);
1736   BLI_thread_unlock(LOCK_MOVIECLIP);
1737
1738   return result;
1739 }
1740
1741 static void movieclip_selection_synchronize(MovieClip *clip_dst, const MovieClip *clip_src)
1742 {
1743   BLI_assert(clip_dst != clip_src);
1744   MovieTracking *tracking_dst = &clip_dst->tracking, tracking_src = clip_src->tracking;
1745   /* Syncs the active object, track and plane track. */
1746   tracking_dst->objectnr = tracking_src.objectnr;
1747   const int active_track_index = BLI_findindex(&tracking_src.tracks, tracking_src.act_track);
1748   const int active_plane_track_index = BLI_findindex(&tracking_src.plane_tracks,
1749                                                      tracking_src.act_plane_track);
1750   tracking_dst->act_track = BLI_findlink(&tracking_dst->tracks, active_track_index);
1751   tracking_dst->act_plane_track = BLI_findlink(&tracking_dst->plane_tracks,
1752                                                active_plane_track_index);
1753
1754   /* Syncs the tracking selection flag. */
1755   MovieTrackingObject *tracking_object_dst, *tracking_object_src;
1756   tracking_object_src = tracking_src.objects.first;
1757
1758   for (tracking_object_dst = tracking_dst->objects.first; tracking_object_dst != NULL;
1759        tracking_object_dst = tracking_object_dst->next,
1760       tracking_object_src = tracking_object_src->next) {
1761     ListBase *tracksbase_dst, *tracksbase_src;
1762     tracksbase_dst = BKE_tracking_object_get_tracks(tracking_dst, tracking_object_dst);
1763     tracksbase_src = BKE_tracking_object_get_tracks(&tracking_src, tracking_object_src);
1764
1765     MovieTrackingTrack *track_dst, *track_src;
1766     track_src = tracksbase_src->first;
1767     for (track_dst = tracksbase_dst->first; track_dst != NULL;
1768          track_dst = track_dst->next, track_src = track_src->next) {
1769       track_dst->flag = track_src->flag;
1770       track_dst->pat_flag = track_src->pat_flag;
1771       track_dst->search_flag = track_src->search_flag;
1772     }
1773   }
1774 }
1775
1776 static void movieclip_eval_update_reload(struct Depsgraph *depsgraph, Main *bmain, MovieClip *clip)
1777 {
1778   BKE_movieclip_reload(bmain, clip);
1779   if (DEG_is_active(depsgraph)) {
1780     MovieClip *clip_orig = (MovieClip *)DEG_get_original_id(&clip->id);
1781     BKE_movieclip_reload(bmain, clip_orig);
1782   }
1783 }
1784
1785 static void movieclip_eval_update_generic(struct Depsgraph *depsgraph, MovieClip *clip)
1786 {
1787   BKE_tracking_dopesheet_tag_update(&clip->tracking);
1788   if (DEG_is_active(depsgraph)) {
1789     MovieClip *clip_orig = (MovieClip *)DEG_get_original_id(&clip->id);
1790     BKE_tracking_dopesheet_tag_update(&clip_orig->tracking);
1791   }
1792 }
1793
1794 void BKE_movieclip_eval_update(struct Depsgraph *depsgraph, Main *bmain, MovieClip *clip)
1795 {
1796   DEG_debug_print_eval(depsgraph, __func__, clip->id.name, clip);
1797   if (clip->id.recalc & ID_RECALC_SOURCE) {
1798     movieclip_eval_update_reload(depsgraph, bmain, clip);
1799   }
1800   else {
1801     movieclip_eval_update_generic(depsgraph, clip);
1802   }
1803 }
1804
1805 void BKE_movieclip_eval_selection_update(struct Depsgraph *depsgraph, MovieClip *clip)
1806 {
1807   DEG_debug_print_eval(depsgraph, __func__, clip->id.name, clip);
1808   movieclip_selection_synchronize(clip, (MovieClip *)clip->id.orig_id);
1809 }