Cleanup: rename 'name' to 'filepath' for DNA types
[blender.git] / source / blender / blenloader / intern / readfile.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) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup blenloader
22  */
23
24 #include "zlib.h"
25
26 #include <ctype.h> /* for isdigit. */
27 #include <fcntl.h> /* for open flags (O_BINARY, O_RDONLY). */
28 #include <limits.h>
29 #include <stdarg.h> /* for va_start/end. */
30 #include <stddef.h> /* for offsetof. */
31 #include <stdlib.h> /* for atoi. */
32 #include <time.h>   /* for gmtime. */
33
34 #include "BLI_utildefines.h"
35 #ifndef WIN32
36 #  include <unistd.h>  // for read close
37 #else
38 #  include "BLI_winstuff.h"
39 #  include "winsock2.h"
40 #  include <io.h>  // for open close read
41 #endif
42
43 /* allow readfile to use deprecated functionality */
44 #define DNA_DEPRECATED_ALLOW
45
46 #include "DNA_anim_types.h"
47 #include "DNA_armature_types.h"
48 #include "DNA_brush_types.h"
49 #include "DNA_cachefile_types.h"
50 #include "DNA_camera_types.h"
51 #include "DNA_cloth_types.h"
52 #include "DNA_collection_types.h"
53 #include "DNA_constraint_types.h"
54 #include "DNA_curveprofile_types.h"
55 #include "DNA_dynamicpaint_types.h"
56 #include "DNA_effect_types.h"
57 #include "DNA_fileglobal_types.h"
58 #include "DNA_fluid_types.h"
59 #include "DNA_genfile.h"
60 #include "DNA_gpencil_modifier_types.h"
61 #include "DNA_gpencil_types.h"
62 #include "DNA_hair_types.h"
63 #include "DNA_ipo_types.h"
64 #include "DNA_key_types.h"
65 #include "DNA_lattice_types.h"
66 #include "DNA_layer_types.h"
67 #include "DNA_light_types.h"
68 #include "DNA_lightprobe_types.h"
69 #include "DNA_linestyle_types.h"
70 #include "DNA_mask_types.h"
71 #include "DNA_material_types.h"
72 #include "DNA_mesh_types.h"
73 #include "DNA_meshdata_types.h"
74 #include "DNA_meta_types.h"
75 #include "DNA_movieclip_types.h"
76 #include "DNA_nla_types.h"
77 #include "DNA_node_types.h"
78 #include "DNA_object_fluidsim_types.h"
79 #include "DNA_object_types.h"
80 #include "DNA_packedFile_types.h"
81 #include "DNA_particle_types.h"
82 #include "DNA_pointcache_types.h"
83 #include "DNA_pointcloud_types.h"
84 #include "DNA_rigidbody_types.h"
85 #include "DNA_scene_types.h"
86 #include "DNA_screen_types.h"
87 #include "DNA_sdna_types.h"
88 #include "DNA_sequence_types.h"
89 #include "DNA_shader_fx_types.h"
90 #include "DNA_simulation_types.h"
91 #include "DNA_sound_types.h"
92 #include "DNA_space_types.h"
93 #include "DNA_speaker_types.h"
94 #include "DNA_text_types.h"
95 #include "DNA_vfont_types.h"
96 #include "DNA_view3d_types.h"
97 #include "DNA_volume_types.h"
98 #include "DNA_workspace_types.h"
99 #include "DNA_world_types.h"
100
101 #include "MEM_guardedalloc.h"
102
103 #include "BLI_blenlib.h"
104 #include "BLI_endian_switch.h"
105 #include "BLI_ghash.h"
106 #include "BLI_linklist.h"
107 #include "BLI_math.h"
108 #include "BLI_mempool.h"
109 #include "BLI_threads.h"
110
111 #include "BLT_translation.h"
112
113 #include "BKE_action.h"
114 #include "BKE_anim_data.h"
115 #include "BKE_armature.h"
116 #include "BKE_brush.h"
117 #include "BKE_collection.h"
118 #include "BKE_colortools.h"
119 #include "BKE_constraint.h"
120 #include "BKE_curve.h"
121 #include "BKE_effect.h"
122 #include "BKE_fcurve_driver.h"
123 #include "BKE_fluid.h"
124 #include "BKE_global.h"  // for G
125 #include "BKE_gpencil_modifier.h"
126 #include "BKE_hair.h"
127 #include "BKE_idprop.h"
128 #include "BKE_idtype.h"
129 #include "BKE_layer.h"
130 #include "BKE_lib_id.h"
131 #include "BKE_lib_override.h"
132 #include "BKE_lib_query.h"
133 #include "BKE_main.h"  // for Main
134 #include "BKE_main_idmap.h"
135 #include "BKE_material.h"
136 #include "BKE_mesh.h"  // for ME_ defines (patching)
137 #include "BKE_mesh_runtime.h"
138 #include "BKE_modifier.h"
139 #include "BKE_multires.h"
140 #include "BKE_node.h"  // for tree type defines
141 #include "BKE_object.h"
142 #include "BKE_paint.h"
143 #include "BKE_particle.h"
144 #include "BKE_pointcache.h"
145 #include "BKE_pointcloud.h"
146 #include "BKE_report.h"
147 #include "BKE_scene.h"
148 #include "BKE_screen.h"
149 #include "BKE_sequencer.h"
150 #include "BKE_shader_fx.h"
151 #include "BKE_simulation.h"
152 #include "BKE_sound.h"
153 #include "BKE_volume.h"
154 #include "BKE_workspace.h"
155
156 #include "DRW_engine.h"
157
158 #include "DEG_depsgraph.h"
159
160 #include "NOD_socket.h"
161
162 #include "BLO_blend_defs.h"
163 #include "BLO_blend_validate.h"
164 #include "BLO_read_write.h"
165 #include "BLO_readfile.h"
166 #include "BLO_undofile.h"
167
168 #include "RE_engine.h"
169
170 #include "engines/eevee/eevee_lightcache.h"
171
172 #include "readfile.h"
173
174 #include <errno.h>
175
176 /* Make preferences read-only. */
177 #define U (*((const UserDef *)&U))
178
179 /**
180  * READ
181  * ====
182  *
183  * - Existing Library (#Main) push or free
184  * - allocate new #Main
185  * - load file
186  * - read #SDNA
187  * - for each LibBlock
188  *   - read LibBlock
189  *   - if a Library
190  *     - make a new #Main
191  *     - attach ID's to it
192  *   - else
193  *     - read associated 'direct data'
194  *     - link direct data (internal and to LibBlock)
195  * - read #FileGlobal
196  * - read #USER data, only when indicated (file is `~/.config/blender/X.XX/config/userpref.blend`)
197  * - free file
198  * - per Library (per #Main)
199  *   - read file
200  *   - read #SDNA
201  *   - find LibBlocks and attach #ID's to #Main
202  *     - if external LibBlock
203  *       - search all #Main's
204  *         - or it's already read,
205  *         - or not read yet
206  *         - or make new #Main
207  *   - per LibBlock
208  *     - read recursive
209  *     - read associated direct data
210  *     - link direct data (internal and to LibBlock)
211  *   - free file
212  * - per Library with unread LibBlocks
213  *   - read file
214  *   - read #SDNA
215  *   - per LibBlock
216  *     - read recursive
217  *     - read associated direct data
218  *     - link direct data (internal and to LibBlock)
219  *   - free file
220  * - join all #Main's
221  * - link all LibBlocks and indirect pointers to libblocks
222  * - initialize #FileGlobal and copy pointers to #Global
223  *
224  * \note Still a weak point is the new-address function, that doesn't solve reading from
225  * multiple files at the same time.
226  * (added remark: oh, i thought that was solved? will look at that... (ton).
227  */
228
229 /**
230  * Delay reading blocks we might not use (especially applies to library linking).
231  * which keeps large arrays in memory from data-blocks we may not even use.
232  *
233  * \note This is disabled when using compression,
234  * while zlib supports seek it's unusably slow, see: T61880.
235  */
236 #define USE_BHEAD_READ_ON_DEMAND
237
238 /* use GHash for BHead name-based lookups (speeds up linking) */
239 #define USE_GHASH_BHEAD
240
241 /* Use GHash for restoring pointers by name */
242 #define USE_GHASH_RESTORE_POINTER
243
244 /* Define this to have verbose debug prints. */
245 //#define USE_DEBUG_PRINT
246
247 #ifdef USE_DEBUG_PRINT
248 #  define DEBUG_PRINTF(...) printf(__VA_ARGS__)
249 #else
250 #  define DEBUG_PRINTF(...)
251 #endif
252
253 /* local prototypes */
254 static void read_libraries(FileData *basefd, ListBase *mainlist);
255 static void *read_struct(FileData *fd, BHead *bh, const char *blockname);
256 static void direct_link_modifiers(BlendDataReader *reader, ListBase *lb, Object *ob);
257 static BHead *find_bhead_from_code_name(FileData *fd, const short idcode, const char *name);
258 static BHead *find_bhead_from_idname(FileData *fd, const char *idname);
259
260 #ifdef USE_COLLECTION_COMPAT_28
261 static void expand_scene_collection(FileData *fd, Main *mainvar, SceneCollection *sc);
262 #endif
263 static void direct_link_animdata(BlendDataReader *reader, AnimData *adt);
264 static void lib_link_animdata(FileData *fd, ID *id, AnimData *adt);
265
266 typedef struct BHeadN {
267   struct BHeadN *next, *prev;
268 #ifdef USE_BHEAD_READ_ON_DEMAND
269   /** Use to read the data from the file directly into memory as needed. */
270   off64_t file_offset;
271   /** When set, the remainder of this allocation is the data, otherwise it needs to be read. */
272   bool has_data;
273 #endif
274   bool is_memchunk_identical;
275   struct BHead bhead;
276 } BHeadN;
277
278 #define BHEADN_FROM_BHEAD(bh) ((BHeadN *)POINTER_OFFSET(bh, -offsetof(BHeadN, bhead)))
279
280 /* We could change this in the future, for now it's simplest if only data is delayed
281  * because ID names are used in lookup tables. */
282 #define BHEAD_USE_READ_ON_DEMAND(bhead) ((bhead)->code == DATA)
283
284 /**
285  * This function ensures that reports are printed,
286  * in the case of library linking errors this is important!
287  *
288  * bit kludge but better then doubling up on prints,
289  * we could alternatively have a versions of a report function which forces printing - campbell
290  */
291 void blo_reportf_wrap(ReportList *reports, ReportType type, const char *format, ...)
292 {
293   char fixed_buf[1024]; /* should be long enough */
294
295   va_list args;
296
297   va_start(args, format);
298   vsnprintf(fixed_buf, sizeof(fixed_buf), format, args);
299   va_end(args);
300
301   fixed_buf[sizeof(fixed_buf) - 1] = '\0';
302
303   BKE_report(reports, type, fixed_buf);
304
305   if (G.background == 0) {
306     printf("%s: %s\n", BKE_report_type_str(type), fixed_buf);
307   }
308 }
309
310 /* for reporting linking messages */
311 static const char *library_parent_filepath(Library *lib)
312 {
313   return lib->parent ? lib->parent->filepath_abs : "<direct>";
314 }
315
316 /* -------------------------------------------------------------------- */
317 /** \name OldNewMap API
318  * \{ */
319
320 typedef struct OldNew {
321   const void *oldp;
322   void *newp;
323   /* `nr` is "user count" for data, and ID code for libdata. */
324   int nr;
325 } OldNew;
326
327 typedef struct OldNewMap {
328   /* Array that stores the actual entries. */
329   OldNew *entries;
330   int nentries;
331   /* Hashmap that stores indices into the `entries` array. */
332   int32_t *map;
333
334   int capacity_exp;
335 } OldNewMap;
336
337 #define ENTRIES_CAPACITY(onm) (1ll << (onm)->capacity_exp)
338 #define MAP_CAPACITY(onm) (1ll << ((onm)->capacity_exp + 1))
339 #define SLOT_MASK(onm) (MAP_CAPACITY(onm) - 1)
340 #define DEFAULT_SIZE_EXP 6
341 #define PERTURB_SHIFT 5
342
343 /* based on the probing algorithm used in Python dicts. */
344 #define ITER_SLOTS(onm, KEY, SLOT_NAME, INDEX_NAME) \
345   uint32_t hash = BLI_ghashutil_ptrhash(KEY); \
346   uint32_t mask = SLOT_MASK(onm); \
347   uint perturb = hash; \
348   int SLOT_NAME = mask & hash; \
349   int INDEX_NAME = onm->map[SLOT_NAME]; \
350   for (;; SLOT_NAME = mask & ((5 * SLOT_NAME) + 1 + perturb), \
351           perturb >>= PERTURB_SHIFT, \
352           INDEX_NAME = onm->map[SLOT_NAME])
353
354 static void oldnewmap_insert_index_in_map(OldNewMap *onm, const void *ptr, int index)
355 {
356   ITER_SLOTS (onm, ptr, slot, stored_index) {
357     if (stored_index == -1) {
358       onm->map[slot] = index;
359       break;
360     }
361   }
362 }
363
364 static void oldnewmap_insert_or_replace(OldNewMap *onm, OldNew entry)
365 {
366   ITER_SLOTS (onm, entry.oldp, slot, index) {
367     if (index == -1) {
368       onm->entries[onm->nentries] = entry;
369       onm->map[slot] = onm->nentries;
370       onm->nentries++;
371       break;
372     }
373     else if (onm->entries[index].oldp == entry.oldp) {
374       onm->entries[index] = entry;
375       break;
376     }
377   }
378 }
379
380 static OldNew *oldnewmap_lookup_entry(const OldNewMap *onm, const void *addr)
381 {
382   ITER_SLOTS (onm, addr, slot, index) {
383     if (index >= 0) {
384       OldNew *entry = &onm->entries[index];
385       if (entry->oldp == addr) {
386         return entry;
387       }
388     }
389     else {
390       return NULL;
391     }
392   }
393 }
394
395 static void oldnewmap_clear_map(OldNewMap *onm)
396 {
397   memset(onm->map, 0xFF, MAP_CAPACITY(onm) * sizeof(*onm->map));
398 }
399
400 static void oldnewmap_increase_size(OldNewMap *onm)
401 {
402   onm->capacity_exp++;
403   onm->entries = MEM_reallocN(onm->entries, sizeof(*onm->entries) * ENTRIES_CAPACITY(onm));
404   onm->map = MEM_reallocN(onm->map, sizeof(*onm->map) * MAP_CAPACITY(onm));
405   oldnewmap_clear_map(onm);
406   for (int i = 0; i < onm->nentries; i++) {
407     oldnewmap_insert_index_in_map(onm, onm->entries[i].oldp, i);
408   }
409 }
410
411 /* Public OldNewMap API */
412
413 static OldNewMap *oldnewmap_new(void)
414 {
415   OldNewMap *onm = MEM_callocN(sizeof(*onm), "OldNewMap");
416
417   onm->capacity_exp = DEFAULT_SIZE_EXP;
418   onm->entries = MEM_malloc_arrayN(
419       ENTRIES_CAPACITY(onm), sizeof(*onm->entries), "OldNewMap.entries");
420   onm->map = MEM_malloc_arrayN(MAP_CAPACITY(onm), sizeof(*onm->map), "OldNewMap.map");
421   oldnewmap_clear_map(onm);
422
423   return onm;
424 }
425
426 static void oldnewmap_insert(OldNewMap *onm, const void *oldaddr, void *newaddr, int nr)
427 {
428   if (oldaddr == NULL || newaddr == NULL) {
429     return;
430   }
431
432   if (UNLIKELY(onm->nentries == ENTRIES_CAPACITY(onm))) {
433     oldnewmap_increase_size(onm);
434   }
435
436   OldNew entry;
437   entry.oldp = oldaddr;
438   entry.newp = newaddr;
439   entry.nr = nr;
440   oldnewmap_insert_or_replace(onm, entry);
441 }
442
443 void blo_do_versions_oldnewmap_insert(OldNewMap *onm, const void *oldaddr, void *newaddr, int nr)
444 {
445   oldnewmap_insert(onm, oldaddr, newaddr, nr);
446 }
447
448 static void *oldnewmap_lookup_and_inc(OldNewMap *onm, const void *addr, bool increase_users)
449 {
450   OldNew *entry = oldnewmap_lookup_entry(onm, addr);
451   if (entry == NULL) {
452     return NULL;
453   }
454   if (increase_users) {
455     entry->nr++;
456   }
457   return entry->newp;
458 }
459
460 /* for libdata, OldNew.nr has ID code, no increment */
461 static void *oldnewmap_liblookup(OldNewMap *onm, const void *addr, const void *lib)
462 {
463   if (addr == NULL) {
464     return NULL;
465   }
466
467   ID *id = oldnewmap_lookup_and_inc(onm, addr, false);
468   if (id == NULL) {
469     return NULL;
470   }
471   if (!lib || id->lib) {
472     return id;
473   }
474   return NULL;
475 }
476
477 static void oldnewmap_clear(OldNewMap *onm)
478 {
479   /* Free unused data. */
480   for (int i = 0; i < onm->nentries; i++) {
481     OldNew *entry = &onm->entries[i];
482     if (entry->nr == 0) {
483       MEM_freeN(entry->newp);
484       entry->newp = NULL;
485     }
486   }
487
488   onm->capacity_exp = DEFAULT_SIZE_EXP;
489   oldnewmap_clear_map(onm);
490   onm->nentries = 0;
491 }
492
493 static void oldnewmap_free(OldNewMap *onm)
494 {
495   MEM_freeN(onm->entries);
496   MEM_freeN(onm->map);
497   MEM_freeN(onm);
498 }
499
500 #undef ENTRIES_CAPACITY
501 #undef MAP_CAPACITY
502 #undef SLOT_MASK
503 #undef DEFAULT_SIZE_EXP
504 #undef PERTURB_SHIFT
505 #undef ITER_SLOTS
506
507 /** \} */
508
509 /* -------------------------------------------------------------------- */
510 /** \name Helper Functions
511  * \{ */
512
513 static void add_main_to_main(Main *mainvar, Main *from)
514 {
515   ListBase *lbarray[MAX_LIBARRAY], *fromarray[MAX_LIBARRAY];
516   int a;
517
518   set_listbasepointers(mainvar, lbarray);
519   a = set_listbasepointers(from, fromarray);
520   while (a--) {
521     BLI_movelisttolist(lbarray[a], fromarray[a]);
522   }
523 }
524
525 void blo_join_main(ListBase *mainlist)
526 {
527   Main *tojoin, *mainl;
528
529   mainl = mainlist->first;
530   while ((tojoin = mainl->next)) {
531     add_main_to_main(mainl, tojoin);
532     BLI_remlink(mainlist, tojoin);
533     BKE_main_free(tojoin);
534   }
535 }
536
537 static void split_libdata(ListBase *lb_src, Main **lib_main_array, const uint lib_main_array_len)
538 {
539   for (ID *id = lb_src->first, *idnext; id; id = idnext) {
540     idnext = id->next;
541
542     if (id->lib) {
543       if (((uint)id->lib->temp_index < lib_main_array_len) &&
544           /* this check should never fail, just in case 'id->lib' is a dangling pointer. */
545           (lib_main_array[id->lib->temp_index]->curlib == id->lib)) {
546         Main *mainvar = lib_main_array[id->lib->temp_index];
547         ListBase *lb_dst = which_libbase(mainvar, GS(id->name));
548         BLI_remlink(lb_src, id);
549         BLI_addtail(lb_dst, id);
550       }
551       else {
552         printf("%s: invalid library for '%s'\n", __func__, id->name);
553         BLI_assert(0);
554       }
555     }
556   }
557 }
558
559 void blo_split_main(ListBase *mainlist, Main *main)
560 {
561   mainlist->first = mainlist->last = main;
562   main->next = NULL;
563
564   if (BLI_listbase_is_empty(&main->libraries)) {
565     return;
566   }
567
568   /* (Library.temp_index -> Main), lookup table */
569   const uint lib_main_array_len = BLI_listbase_count(&main->libraries);
570   Main **lib_main_array = MEM_malloc_arrayN(lib_main_array_len, sizeof(*lib_main_array), __func__);
571
572   int i = 0;
573   for (Library *lib = main->libraries.first; lib; lib = lib->id.next, i++) {
574     Main *libmain = BKE_main_new();
575     libmain->curlib = lib;
576     libmain->versionfile = lib->versionfile;
577     libmain->subversionfile = lib->subversionfile;
578     BLI_addtail(mainlist, libmain);
579     lib->temp_index = i;
580     lib_main_array[i] = libmain;
581   }
582
583   ListBase *lbarray[MAX_LIBARRAY];
584   i = set_listbasepointers(main, lbarray);
585   while (i--) {
586     ID *id = lbarray[i]->first;
587     if (id == NULL || GS(id->name) == ID_LI) {
588       /* No ID_LI data-lock should ever be linked anyway, but just in case, better be explicit. */
589       continue;
590     }
591     split_libdata(lbarray[i], lib_main_array, lib_main_array_len);
592   }
593
594   MEM_freeN(lib_main_array);
595 }
596
597 static void read_file_version(FileData *fd, Main *main)
598 {
599   BHead *bhead;
600
601   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
602     if (bhead->code == GLOB) {
603       FileGlobal *fg = read_struct(fd, bhead, "Global");
604       if (fg) {
605         main->subversionfile = fg->subversion;
606         main->minversionfile = fg->minversion;
607         main->minsubversionfile = fg->minsubversion;
608         MEM_freeN(fg);
609       }
610       else if (bhead->code == ENDB) {
611         break;
612       }
613     }
614   }
615   if (main->curlib) {
616     main->curlib->versionfile = main->versionfile;
617     main->curlib->subversionfile = main->subversionfile;
618   }
619 }
620
621 #ifdef USE_GHASH_BHEAD
622 static void read_file_bhead_idname_map_create(FileData *fd)
623 {
624   BHead *bhead;
625
626   /* dummy values */
627   bool is_link = false;
628   int code_prev = ENDB;
629   uint reserve = 0;
630
631   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
632     if (code_prev != bhead->code) {
633       code_prev = bhead->code;
634       is_link = BKE_idtype_idcode_is_valid(code_prev) ? BKE_idtype_idcode_is_linkable(code_prev) :
635                                                         false;
636     }
637
638     if (is_link) {
639       reserve += 1;
640     }
641   }
642
643   BLI_assert(fd->bhead_idname_hash == NULL);
644
645   fd->bhead_idname_hash = BLI_ghash_str_new_ex(__func__, reserve);
646
647   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
648     if (code_prev != bhead->code) {
649       code_prev = bhead->code;
650       is_link = BKE_idtype_idcode_is_valid(code_prev) ? BKE_idtype_idcode_is_linkable(code_prev) :
651                                                         false;
652     }
653
654     if (is_link) {
655       BLI_ghash_insert(fd->bhead_idname_hash, (void *)blo_bhead_id_name(fd, bhead), bhead);
656     }
657   }
658 }
659 #endif
660
661 static Main *blo_find_main(FileData *fd, const char *filepath, const char *relabase)
662 {
663   ListBase *mainlist = fd->mainlist;
664   Main *m;
665   Library *lib;
666   char name1[FILE_MAX];
667
668   BLI_strncpy(name1, filepath, sizeof(name1));
669   BLI_path_normalize(relabase, name1);
670
671   //  printf("blo_find_main: relabase  %s\n", relabase);
672   //  printf("blo_find_main: original in  %s\n", filepath);
673   //  printf("blo_find_main: converted to %s\n", name1);
674
675   for (m = mainlist->first; m; m = m->next) {
676     const char *libname = (m->curlib) ? m->curlib->filepath_abs : m->name;
677
678     if (BLI_path_cmp(name1, libname) == 0) {
679       if (G.debug & G_DEBUG) {
680         printf("blo_find_main: found library %s\n", libname);
681       }
682       return m;
683     }
684   }
685
686   m = BKE_main_new();
687   BLI_addtail(mainlist, m);
688
689   /* Add library data-block itself to 'main' Main, since libraries are **never** linked data.
690    * Fixes bug where you could end with all ID_LI data-blocks having the same name... */
691   lib = BKE_libblock_alloc(mainlist->first, ID_LI, BLI_path_basename(filepath), 0);
692
693   /* Important, consistency with main ID reading code from read_libblock(). */
694   lib->id.us = ID_FAKE_USERS(lib);
695
696   /* Matches direct_link_library(). */
697   id_us_ensure_real(&lib->id);
698
699   BLI_strncpy(lib->filepath, filepath, sizeof(lib->filepath));
700   BLI_strncpy(lib->filepath_abs, name1, sizeof(lib->filepath_abs));
701
702   m->curlib = lib;
703
704   read_file_version(fd, m);
705
706   if (G.debug & G_DEBUG) {
707     printf("blo_find_main: added new lib %s\n", filepath);
708   }
709   return m;
710 }
711
712 /** \} */
713
714 /* -------------------------------------------------------------------- */
715 /** \name File Parsing
716  * \{ */
717
718 typedef struct BlendDataReader {
719   FileData *fd;
720 } BlendDataReader;
721
722 typedef struct BlendLibReader {
723   FileData *fd;
724   Main *main;
725 } BlendLibReader;
726
727 typedef struct BlendExpander {
728   FileData *fd;
729   Main *main;
730 } BlendExpander;
731
732 static void switch_endian_bh4(BHead4 *bhead)
733 {
734   /* the ID_.. codes */
735   if ((bhead->code & 0xFFFF) == 0) {
736     bhead->code >>= 16;
737   }
738
739   if (bhead->code != ENDB) {
740     BLI_endian_switch_int32(&bhead->len);
741     BLI_endian_switch_int32(&bhead->SDNAnr);
742     BLI_endian_switch_int32(&bhead->nr);
743   }
744 }
745
746 static void switch_endian_bh8(BHead8 *bhead)
747 {
748   /* the ID_.. codes */
749   if ((bhead->code & 0xFFFF) == 0) {
750     bhead->code >>= 16;
751   }
752
753   if (bhead->code != ENDB) {
754     BLI_endian_switch_int32(&bhead->len);
755     BLI_endian_switch_int32(&bhead->SDNAnr);
756     BLI_endian_switch_int32(&bhead->nr);
757   }
758 }
759
760 static void bh4_from_bh8(BHead *bhead, BHead8 *bhead8, int do_endian_swap)
761 {
762   BHead4 *bhead4 = (BHead4 *)bhead;
763   int64_t old;
764
765   bhead4->code = bhead8->code;
766   bhead4->len = bhead8->len;
767
768   if (bhead4->code != ENDB) {
769     /* perform a endian swap on 64bit pointers, otherwise the pointer might map to zero
770      * 0x0000000000000000000012345678 would become 0x12345678000000000000000000000000
771      */
772     if (do_endian_swap) {
773       BLI_endian_switch_int64(&bhead8->old);
774     }
775
776     /* this patch is to avoid a long long being read from not-eight aligned positions
777      * is necessary on any modern 64bit architecture) */
778     memcpy(&old, &bhead8->old, 8);
779     bhead4->old = (int)(old >> 3);
780
781     bhead4->SDNAnr = bhead8->SDNAnr;
782     bhead4->nr = bhead8->nr;
783   }
784 }
785
786 static void bh8_from_bh4(BHead *bhead, BHead4 *bhead4)
787 {
788   BHead8 *bhead8 = (BHead8 *)bhead;
789
790   bhead8->code = bhead4->code;
791   bhead8->len = bhead4->len;
792
793   if (bhead8->code != ENDB) {
794     bhead8->old = bhead4->old;
795     bhead8->SDNAnr = bhead4->SDNAnr;
796     bhead8->nr = bhead4->nr;
797   }
798 }
799
800 static BHeadN *get_bhead(FileData *fd)
801 {
802   BHeadN *new_bhead = NULL;
803   int readsize;
804
805   if (fd) {
806     if (!fd->is_eof) {
807       /* initializing to zero isn't strictly needed but shuts valgrind up
808        * since uninitialized memory gets compared */
809       BHead8 bhead8 = {0};
810       BHead4 bhead4 = {0};
811       BHead bhead = {0};
812
813       /* First read the bhead structure.
814        * Depending on the platform the file was written on this can
815        * be a big or little endian BHead4 or BHead8 structure.
816        *
817        * As usual 'ENDB' (the last *partial* bhead of the file)
818        * needs some special handling. We don't want to EOF just yet.
819        */
820       if (fd->flags & FD_FLAGS_FILE_POINTSIZE_IS_4) {
821         bhead4.code = DATA;
822         readsize = fd->read(fd, &bhead4, sizeof(bhead4), NULL);
823
824         if (readsize == sizeof(bhead4) || bhead4.code == ENDB) {
825           if (fd->flags & FD_FLAGS_SWITCH_ENDIAN) {
826             switch_endian_bh4(&bhead4);
827           }
828
829           if (fd->flags & FD_FLAGS_POINTSIZE_DIFFERS) {
830             bh8_from_bh4(&bhead, &bhead4);
831           }
832           else {
833             /* MIN2 is only to quiet '-Warray-bounds' compiler warning. */
834             BLI_assert(sizeof(bhead) == sizeof(bhead4));
835             memcpy(&bhead, &bhead4, MIN2(sizeof(bhead), sizeof(bhead4)));
836           }
837         }
838         else {
839           fd->is_eof = true;
840           bhead.len = 0;
841         }
842       }
843       else {
844         bhead8.code = DATA;
845         readsize = fd->read(fd, &bhead8, sizeof(bhead8), NULL);
846
847         if (readsize == sizeof(bhead8) || bhead8.code == ENDB) {
848           if (fd->flags & FD_FLAGS_SWITCH_ENDIAN) {
849             switch_endian_bh8(&bhead8);
850           }
851
852           if (fd->flags & FD_FLAGS_POINTSIZE_DIFFERS) {
853             bh4_from_bh8(&bhead, &bhead8, (fd->flags & FD_FLAGS_SWITCH_ENDIAN));
854           }
855           else {
856             /* MIN2 is only to quiet '-Warray-bounds' compiler warning. */
857             BLI_assert(sizeof(bhead) == sizeof(bhead8));
858             memcpy(&bhead, &bhead8, MIN2(sizeof(bhead), sizeof(bhead8)));
859           }
860         }
861         else {
862           fd->is_eof = true;
863           bhead.len = 0;
864         }
865       }
866
867       /* make sure people are not trying to pass bad blend files */
868       if (bhead.len < 0) {
869         fd->is_eof = true;
870       }
871
872       /* bhead now contains the (converted) bhead structure. Now read
873        * the associated data and put everything in a BHeadN (creative naming !)
874        */
875       if (fd->is_eof) {
876         /* pass */
877       }
878 #ifdef USE_BHEAD_READ_ON_DEMAND
879       else if (fd->seek != NULL && BHEAD_USE_READ_ON_DEMAND(&bhead)) {
880         /* Delay reading bhead content. */
881         new_bhead = MEM_mallocN(sizeof(BHeadN), "new_bhead");
882         if (new_bhead) {
883           new_bhead->next = new_bhead->prev = NULL;
884           new_bhead->file_offset = fd->file_offset;
885           new_bhead->has_data = false;
886           new_bhead->is_memchunk_identical = false;
887           new_bhead->bhead = bhead;
888           off64_t seek_new = fd->seek(fd, bhead.len, SEEK_CUR);
889           if (seek_new == -1) {
890             fd->is_eof = true;
891             MEM_freeN(new_bhead);
892             new_bhead = NULL;
893           }
894           BLI_assert(fd->file_offset == seek_new);
895         }
896         else {
897           fd->is_eof = true;
898         }
899       }
900 #endif
901       else {
902         new_bhead = MEM_mallocN(sizeof(BHeadN) + bhead.len, "new_bhead");
903         if (new_bhead) {
904           new_bhead->next = new_bhead->prev = NULL;
905 #ifdef USE_BHEAD_READ_ON_DEMAND
906           new_bhead->file_offset = 0; /* don't seek. */
907           new_bhead->has_data = true;
908 #endif
909           new_bhead->is_memchunk_identical = false;
910           new_bhead->bhead = bhead;
911
912           readsize = fd->read(fd, new_bhead + 1, bhead.len, &new_bhead->is_memchunk_identical);
913
914           if (readsize != bhead.len) {
915             fd->is_eof = true;
916             MEM_freeN(new_bhead);
917             new_bhead = NULL;
918           }
919         }
920         else {
921           fd->is_eof = true;
922         }
923       }
924     }
925   }
926
927   /* We've read a new block. Now add it to the list
928    * of blocks.
929    */
930   if (new_bhead) {
931     BLI_addtail(&fd->bhead_list, new_bhead);
932   }
933
934   return new_bhead;
935 }
936
937 BHead *blo_bhead_first(FileData *fd)
938 {
939   BHeadN *new_bhead;
940   BHead *bhead = NULL;
941
942   /* Rewind the file
943    * Read in a new block if necessary
944    */
945   new_bhead = fd->bhead_list.first;
946   if (new_bhead == NULL) {
947     new_bhead = get_bhead(fd);
948   }
949
950   if (new_bhead) {
951     bhead = &new_bhead->bhead;
952   }
953
954   return bhead;
955 }
956
957 BHead *blo_bhead_prev(FileData *UNUSED(fd), BHead *thisblock)
958 {
959   BHeadN *bheadn = BHEADN_FROM_BHEAD(thisblock);
960   BHeadN *prev = bheadn->prev;
961
962   return (prev) ? &prev->bhead : NULL;
963 }
964
965 BHead *blo_bhead_next(FileData *fd, BHead *thisblock)
966 {
967   BHeadN *new_bhead = NULL;
968   BHead *bhead = NULL;
969
970   if (thisblock) {
971     /* bhead is actually a sub part of BHeadN
972      * We calculate the BHeadN pointer from the BHead pointer below */
973     new_bhead = BHEADN_FROM_BHEAD(thisblock);
974
975     /* get the next BHeadN. If it doesn't exist we read in the next one */
976     new_bhead = new_bhead->next;
977     if (new_bhead == NULL) {
978       new_bhead = get_bhead(fd);
979     }
980   }
981
982   if (new_bhead) {
983     /* here we do the reverse:
984      * go from the BHeadN pointer to the BHead pointer */
985     bhead = &new_bhead->bhead;
986   }
987
988   return bhead;
989 }
990
991 #ifdef USE_BHEAD_READ_ON_DEMAND
992 static bool blo_bhead_read_data(FileData *fd, BHead *thisblock, void *buf)
993 {
994   bool success = true;
995   BHeadN *new_bhead = BHEADN_FROM_BHEAD(thisblock);
996   BLI_assert(new_bhead->has_data == false && new_bhead->file_offset != 0);
997   off64_t offset_backup = fd->file_offset;
998   if (UNLIKELY(fd->seek(fd, new_bhead->file_offset, SEEK_SET) == -1)) {
999     success = false;
1000   }
1001   else {
1002     if (fd->read(fd, buf, new_bhead->bhead.len, &new_bhead->is_memchunk_identical) !=
1003         new_bhead->bhead.len) {
1004       success = false;
1005     }
1006   }
1007   if (fd->seek(fd, offset_backup, SEEK_SET) == -1) {
1008     success = false;
1009   }
1010   return success;
1011 }
1012
1013 static BHead *blo_bhead_read_full(FileData *fd, BHead *thisblock)
1014 {
1015   BHeadN *new_bhead = BHEADN_FROM_BHEAD(thisblock);
1016   BHeadN *new_bhead_data = MEM_mallocN(sizeof(BHeadN) + new_bhead->bhead.len, "new_bhead");
1017   new_bhead_data->bhead = new_bhead->bhead;
1018   new_bhead_data->file_offset = new_bhead->file_offset;
1019   new_bhead_data->has_data = true;
1020   new_bhead_data->is_memchunk_identical = false;
1021   if (!blo_bhead_read_data(fd, thisblock, new_bhead_data + 1)) {
1022     MEM_freeN(new_bhead_data);
1023     return NULL;
1024   }
1025   return &new_bhead_data->bhead;
1026 }
1027 #endif /* USE_BHEAD_READ_ON_DEMAND */
1028
1029 /* Warning! Caller's responsibility to ensure given bhead **is** and ID one! */
1030 const char *blo_bhead_id_name(const FileData *fd, const BHead *bhead)
1031 {
1032   return (const char *)POINTER_OFFSET(bhead, sizeof(*bhead) + fd->id_name_offs);
1033 }
1034
1035 static void decode_blender_header(FileData *fd)
1036 {
1037   char header[SIZEOFBLENDERHEADER], num[4];
1038   int readsize;
1039
1040   /* read in the header data */
1041   readsize = fd->read(fd, header, sizeof(header), NULL);
1042
1043   if (readsize == sizeof(header) && STREQLEN(header, "BLENDER", 7) && ELEM(header[7], '_', '-') &&
1044       ELEM(header[8], 'v', 'V') &&
1045       (isdigit(header[9]) && isdigit(header[10]) && isdigit(header[11]))) {
1046     fd->flags |= FD_FLAGS_FILE_OK;
1047
1048     /* what size are pointers in the file ? */
1049     if (header[7] == '_') {
1050       fd->flags |= FD_FLAGS_FILE_POINTSIZE_IS_4;
1051       if (sizeof(void *) != 4) {
1052         fd->flags |= FD_FLAGS_POINTSIZE_DIFFERS;
1053       }
1054     }
1055     else {
1056       if (sizeof(void *) != 8) {
1057         fd->flags |= FD_FLAGS_POINTSIZE_DIFFERS;
1058       }
1059     }
1060
1061     /* is the file saved in a different endian
1062      * than we need ?
1063      */
1064     if (((header[8] == 'v') ? L_ENDIAN : B_ENDIAN) != ENDIAN_ORDER) {
1065       fd->flags |= FD_FLAGS_SWITCH_ENDIAN;
1066     }
1067
1068     /* get the version number */
1069     memcpy(num, header + 9, 3);
1070     num[3] = 0;
1071     fd->fileversion = atoi(num);
1072   }
1073 }
1074
1075 /**
1076  * \return Success if the file is read correctly, else set \a r_error_message.
1077  */
1078 static bool read_file_dna(FileData *fd, const char **r_error_message)
1079 {
1080   BHead *bhead;
1081   int subversion = 0;
1082
1083   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
1084     if (bhead->code == GLOB) {
1085       /* Before this, the subversion didn't exist in 'FileGlobal' so the subversion
1086        * value isn't accessible for the purpose of DNA versioning in this case. */
1087       if (fd->fileversion <= 242) {
1088         continue;
1089       }
1090       /* We can't use read_global because this needs 'DNA1' to be decoded,
1091        * however the first 4 chars are _always_ the subversion. */
1092       FileGlobal *fg = (void *)&bhead[1];
1093       BLI_STATIC_ASSERT(offsetof(FileGlobal, subvstr) == 0, "Must be first: subvstr")
1094       char num[5];
1095       memcpy(num, fg->subvstr, 4);
1096       num[4] = 0;
1097       subversion = atoi(num);
1098     }
1099     else if (bhead->code == DNA1) {
1100       const bool do_endian_swap = (fd->flags & FD_FLAGS_SWITCH_ENDIAN) != 0;
1101
1102       fd->filesdna = DNA_sdna_from_data(
1103           &bhead[1], bhead->len, do_endian_swap, true, r_error_message);
1104       if (fd->filesdna) {
1105         blo_do_versions_dna(fd->filesdna, fd->fileversion, subversion);
1106         fd->compflags = DNA_struct_get_compareflags(fd->filesdna, fd->memsdna);
1107         /* used to retrieve ID names from (bhead+1) */
1108         fd->id_name_offs = DNA_elem_offset(fd->filesdna, "ID", "char", "name[]");
1109
1110         return true;
1111       }
1112       else {
1113         return false;
1114       }
1115     }
1116     else if (bhead->code == ENDB) {
1117       break;
1118     }
1119   }
1120
1121   *r_error_message = "Missing DNA block";
1122   return false;
1123 }
1124
1125 static int *read_file_thumbnail(FileData *fd)
1126 {
1127   BHead *bhead;
1128   int *blend_thumb = NULL;
1129
1130   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
1131     if (bhead->code == TEST) {
1132       const bool do_endian_swap = (fd->flags & FD_FLAGS_SWITCH_ENDIAN) != 0;
1133       int *data = (int *)(bhead + 1);
1134
1135       if (bhead->len < (2 * sizeof(int))) {
1136         break;
1137       }
1138
1139       if (do_endian_swap) {
1140         BLI_endian_switch_int32(&data[0]);
1141         BLI_endian_switch_int32(&data[1]);
1142       }
1143
1144       const int width = data[0];
1145       const int height = data[1];
1146       if (!BLEN_THUMB_MEMSIZE_IS_VALID(width, height)) {
1147         break;
1148       }
1149       if (bhead->len < BLEN_THUMB_MEMSIZE_FILE(width, height)) {
1150         break;
1151       }
1152
1153       blend_thumb = data;
1154       break;
1155     }
1156     else if (bhead->code != REND) {
1157       /* Thumbnail is stored in TEST immediately after first REND... */
1158       break;
1159     }
1160   }
1161
1162   return blend_thumb;
1163 }
1164
1165 /** \} */
1166
1167 /* -------------------------------------------------------------------- */
1168 /** \name File Data API
1169  * \{ */
1170
1171 /* Regular file reading. */
1172
1173 static int fd_read_data_from_file(FileData *filedata,
1174                                   void *buffer,
1175                                   uint size,
1176                                   bool *UNUSED(r_is_memchunck_identical))
1177 {
1178   int readsize = read(filedata->filedes, buffer, size);
1179
1180   if (readsize < 0) {
1181     readsize = EOF;
1182   }
1183   else {
1184     filedata->file_offset += readsize;
1185   }
1186
1187   return (readsize);
1188 }
1189
1190 static off64_t fd_seek_data_from_file(FileData *filedata, off64_t offset, int whence)
1191 {
1192   filedata->file_offset = BLI_lseek(filedata->filedes, offset, whence);
1193   return filedata->file_offset;
1194 }
1195
1196 /* GZip file reading. */
1197
1198 static int fd_read_gzip_from_file(FileData *filedata,
1199                                   void *buffer,
1200                                   uint size,
1201                                   bool *UNUSED(r_is_memchunck_identical))
1202 {
1203   int readsize = gzread(filedata->gzfiledes, buffer, size);
1204
1205   if (readsize < 0) {
1206     readsize = EOF;
1207   }
1208   else {
1209     filedata->file_offset += readsize;
1210   }
1211
1212   return (readsize);
1213 }
1214
1215 /* Memory reading. */
1216
1217 static int fd_read_from_memory(FileData *filedata,
1218                                void *buffer,
1219                                uint size,
1220                                bool *UNUSED(r_is_memchunck_identical))
1221 {
1222   /* don't read more bytes then there are available in the buffer */
1223   int readsize = (int)MIN2(size, (uint)(filedata->buffersize - filedata->file_offset));
1224
1225   memcpy(buffer, filedata->buffer + filedata->file_offset, readsize);
1226   filedata->file_offset += readsize;
1227
1228   return (readsize);
1229 }
1230
1231 /* MemFile reading. */
1232
1233 static int fd_read_from_memfile(FileData *filedata,
1234                                 void *buffer,
1235                                 uint size,
1236                                 bool *r_is_memchunck_identical)
1237 {
1238   static size_t seek = SIZE_MAX; /* the current position */
1239   static size_t offset = 0;      /* size of previous chunks */
1240   static MemFileChunk *chunk = NULL;
1241   size_t chunkoffset, readsize, totread;
1242
1243   if (r_is_memchunck_identical != NULL) {
1244     *r_is_memchunck_identical = true;
1245   }
1246
1247   if (size == 0) {
1248     return 0;
1249   }
1250
1251   if (seek != (size_t)filedata->file_offset) {
1252     chunk = filedata->memfile->chunks.first;
1253     seek = 0;
1254
1255     while (chunk) {
1256       if (seek + chunk->size > (size_t)filedata->file_offset) {
1257         break;
1258       }
1259       seek += chunk->size;
1260       chunk = chunk->next;
1261     }
1262     offset = seek;
1263     seek = filedata->file_offset;
1264   }
1265
1266   if (chunk) {
1267     totread = 0;
1268
1269     do {
1270       /* first check if it's on the end if current chunk */
1271       if (seek - offset == chunk->size) {
1272         offset += chunk->size;
1273         chunk = chunk->next;
1274       }
1275
1276       /* debug, should never happen */
1277       if (chunk == NULL) {
1278         printf("illegal read, chunk zero\n");
1279         return 0;
1280       }
1281
1282       chunkoffset = seek - offset;
1283       readsize = size - totread;
1284
1285       /* data can be spread over multiple chunks, so clamp size
1286        * to within this chunk, and then it will read further in
1287        * the next chunk */
1288       if (chunkoffset + readsize > chunk->size) {
1289         readsize = chunk->size - chunkoffset;
1290       }
1291
1292       memcpy(POINTER_OFFSET(buffer, totread), chunk->buf + chunkoffset, readsize);
1293       totread += readsize;
1294       filedata->file_offset += readsize;
1295       seek += readsize;
1296       if (r_is_memchunck_identical != NULL) {
1297         /* `is_identical` of current chunk represents whether it changed compared to previous undo
1298          * step. this is fine in redo case (filedata->undo_direction > 0), but not in undo case,
1299          * where we need an extra flag defined when saving the next (future) step after the one we
1300          * want to restore, as we are supposed to 'come from' that future undo step, and not the
1301          * one before current one. */
1302         *r_is_memchunck_identical &= filedata->undo_direction > 0 ? chunk->is_identical :
1303                                                                     chunk->is_identical_future;
1304       }
1305     } while (totread < size);
1306
1307     return totread;
1308   }
1309
1310   return 0;
1311 }
1312
1313 static FileData *filedata_new(void)
1314 {
1315   FileData *fd = MEM_callocN(sizeof(FileData), "FileData");
1316
1317   fd->filedes = -1;
1318   fd->gzfiledes = NULL;
1319
1320   fd->memsdna = DNA_sdna_current_get();
1321
1322   fd->datamap = oldnewmap_new();
1323   fd->globmap = oldnewmap_new();
1324   fd->libmap = oldnewmap_new();
1325
1326   return fd;
1327 }
1328
1329 static FileData *blo_decode_and_check(FileData *fd, ReportList *reports)
1330 {
1331   decode_blender_header(fd);
1332
1333   if (fd->flags & FD_FLAGS_FILE_OK) {
1334     const char *error_message = NULL;
1335     if (read_file_dna(fd, &error_message) == false) {
1336       BKE_reportf(
1337           reports, RPT_ERROR, "Failed to read blend file '%s': %s", fd->relabase, error_message);
1338       blo_filedata_free(fd);
1339       fd = NULL;
1340     }
1341   }
1342   else {
1343     BKE_reportf(
1344         reports, RPT_ERROR, "Failed to read blend file '%s', not a blend file", fd->relabase);
1345     blo_filedata_free(fd);
1346     fd = NULL;
1347   }
1348
1349   return fd;
1350 }
1351
1352 static FileData *blo_filedata_from_file_descriptor(const char *filepath,
1353                                                    ReportList *reports,
1354                                                    int file)
1355 {
1356   FileDataReadFn *read_fn = NULL;
1357   FileDataSeekFn *seek_fn = NULL; /* Optional. */
1358
1359   gzFile gzfile = (gzFile)Z_NULL;
1360
1361   char header[7];
1362
1363   /* Regular file. */
1364   errno = 0;
1365   if (read(file, header, sizeof(header)) != sizeof(header)) {
1366     BKE_reportf(reports,
1367                 RPT_WARNING,
1368                 "Unable to read '%s': %s",
1369                 filepath,
1370                 errno ? strerror(errno) : TIP_("insufficient content"));
1371     return NULL;
1372   }
1373   else {
1374     BLI_lseek(file, 0, SEEK_SET);
1375   }
1376
1377   /* Regular file. */
1378   if (memcmp(header, "BLENDER", sizeof(header)) == 0) {
1379     read_fn = fd_read_data_from_file;
1380     seek_fn = fd_seek_data_from_file;
1381   }
1382
1383   /* Gzip file. */
1384   errno = 0;
1385   if ((read_fn == NULL) &&
1386       /* Check header magic. */
1387       (header[0] == 0x1f && header[1] == 0x8b)) {
1388     gzfile = BLI_gzopen(filepath, "rb");
1389     if (gzfile == (gzFile)Z_NULL) {
1390       BKE_reportf(reports,
1391                   RPT_WARNING,
1392                   "Unable to open '%s': %s",
1393                   filepath,
1394                   errno ? strerror(errno) : TIP_("unknown error reading file"));
1395       return NULL;
1396     }
1397     else {
1398       /* 'seek_fn' is too slow for gzip, don't set it. */
1399       read_fn = fd_read_gzip_from_file;
1400       /* Caller must close. */
1401       file = -1;
1402     }
1403   }
1404
1405   if (read_fn == NULL) {
1406     BKE_reportf(reports, RPT_WARNING, "Unrecognized file format '%s'", filepath);
1407     return NULL;
1408   }
1409
1410   FileData *fd = filedata_new();
1411
1412   fd->filedes = file;
1413   fd->gzfiledes = gzfile;
1414
1415   fd->read = read_fn;
1416   fd->seek = seek_fn;
1417
1418   return fd;
1419 }
1420
1421 static FileData *blo_filedata_from_file_open(const char *filepath, ReportList *reports)
1422 {
1423   errno = 0;
1424   const int file = BLI_open(filepath, O_BINARY | O_RDONLY, 0);
1425   if (file == -1) {
1426     BKE_reportf(reports,
1427                 RPT_WARNING,
1428                 "Unable to open '%s': %s",
1429                 filepath,
1430                 errno ? strerror(errno) : TIP_("unknown error reading file"));
1431     return NULL;
1432   }
1433   FileData *fd = blo_filedata_from_file_descriptor(filepath, reports, file);
1434   if ((fd == NULL) || (fd->filedes == -1)) {
1435     close(file);
1436   }
1437   return fd;
1438 }
1439
1440 /* cannot be called with relative paths anymore! */
1441 /* on each new library added, it now checks for the current FileData and expands relativeness */
1442 FileData *blo_filedata_from_file(const char *filepath, ReportList *reports)
1443 {
1444   FileData *fd = blo_filedata_from_file_open(filepath, reports);
1445   if (fd != NULL) {
1446     /* needed for library_append and read_libraries */
1447     BLI_strncpy(fd->relabase, filepath, sizeof(fd->relabase));
1448
1449     return blo_decode_and_check(fd, reports);
1450   }
1451   return NULL;
1452 }
1453
1454 /**
1455  * Same as blo_filedata_from_file(), but does not reads DNA data, only header.
1456  * Use it for light access (e.g. thumbnail reading).
1457  */
1458 static FileData *blo_filedata_from_file_minimal(const char *filepath)
1459 {
1460   FileData *fd = blo_filedata_from_file_open(filepath, NULL);
1461   if (fd != NULL) {
1462     decode_blender_header(fd);
1463     if (fd->flags & FD_FLAGS_FILE_OK) {
1464       return fd;
1465     }
1466     blo_filedata_free(fd);
1467   }
1468   return NULL;
1469 }
1470
1471 static int fd_read_gzip_from_memory(FileData *filedata,
1472                                     void *buffer,
1473                                     uint size,
1474                                     bool *UNUSED(r_is_memchunck_identical))
1475 {
1476   int err;
1477
1478   filedata->strm.next_out = (Bytef *)buffer;
1479   filedata->strm.avail_out = size;
1480
1481   // Inflate another chunk.
1482   err = inflate(&filedata->strm, Z_SYNC_FLUSH);
1483
1484   if (err == Z_STREAM_END) {
1485     return 0;
1486   }
1487   else if (err != Z_OK) {
1488     printf("fd_read_gzip_from_memory: zlib error\n");
1489     return 0;
1490   }
1491
1492   filedata->file_offset += size;
1493
1494   return (size);
1495 }
1496
1497 static int fd_read_gzip_from_memory_init(FileData *fd)
1498 {
1499
1500   fd->strm.next_in = (Bytef *)fd->buffer;
1501   fd->strm.avail_in = fd->buffersize;
1502   fd->strm.total_out = 0;
1503   fd->strm.zalloc = Z_NULL;
1504   fd->strm.zfree = Z_NULL;
1505
1506   if (inflateInit2(&fd->strm, (16 + MAX_WBITS)) != Z_OK) {
1507     return 0;
1508   }
1509
1510   fd->read = fd_read_gzip_from_memory;
1511
1512   return 1;
1513 }
1514
1515 FileData *blo_filedata_from_memory(const void *mem, int memsize, ReportList *reports)
1516 {
1517   if (!mem || memsize < SIZEOFBLENDERHEADER) {
1518     BKE_report(reports, RPT_WARNING, (mem) ? TIP_("Unable to read") : TIP_("Unable to open"));
1519     return NULL;
1520   }
1521   else {
1522     FileData *fd = filedata_new();
1523     const char *cp = mem;
1524
1525     fd->buffer = mem;
1526     fd->buffersize = memsize;
1527
1528     /* test if gzip */
1529     if (cp[0] == 0x1f && cp[1] == 0x8b) {
1530       if (0 == fd_read_gzip_from_memory_init(fd)) {
1531         blo_filedata_free(fd);
1532         return NULL;
1533       }
1534     }
1535     else {
1536       fd->read = fd_read_from_memory;
1537     }
1538
1539     fd->flags |= FD_FLAGS_NOT_MY_BUFFER;
1540
1541     return blo_decode_and_check(fd, reports);
1542   }
1543 }
1544
1545 FileData *blo_filedata_from_memfile(MemFile *memfile,
1546                                     const struct BlendFileReadParams *params,
1547                                     ReportList *reports)
1548 {
1549   if (!memfile) {
1550     BKE_report(reports, RPT_WARNING, "Unable to open blend <memory>");
1551     return NULL;
1552   }
1553   else {
1554     FileData *fd = filedata_new();
1555     fd->memfile = memfile;
1556     fd->undo_direction = params->undo_direction;
1557
1558     fd->read = fd_read_from_memfile;
1559     fd->flags |= FD_FLAGS_NOT_MY_BUFFER;
1560
1561     return blo_decode_and_check(fd, reports);
1562   }
1563 }
1564
1565 void blo_filedata_free(FileData *fd)
1566 {
1567   if (fd) {
1568     if (fd->filedes != -1) {
1569       close(fd->filedes);
1570     }
1571
1572     if (fd->gzfiledes != NULL) {
1573       gzclose(fd->gzfiledes);
1574     }
1575
1576     if (fd->strm.next_in) {
1577       if (inflateEnd(&fd->strm) != Z_OK) {
1578         printf("close gzip stream error\n");
1579       }
1580     }
1581
1582     if (fd->buffer && !(fd->flags & FD_FLAGS_NOT_MY_BUFFER)) {
1583       MEM_freeN((void *)fd->buffer);
1584       fd->buffer = NULL;
1585     }
1586
1587     /* Free all BHeadN data blocks */
1588 #ifndef NDEBUG
1589     BLI_freelistN(&fd->bhead_list);
1590 #else
1591     /* Sanity check we're not keeping memory we don't need. */
1592     LISTBASE_FOREACH_MUTABLE (BHeadN *, new_bhead, &fd->bhead_list) {
1593       if (fd->seek != NULL && BHEAD_USE_READ_ON_DEMAND(&new_bhead->bhead)) {
1594         BLI_assert(new_bhead->has_data == 0);
1595       }
1596       MEM_freeN(new_bhead);
1597     }
1598 #endif
1599
1600     if (fd->filesdna) {
1601       DNA_sdna_free(fd->filesdna);
1602     }
1603     if (fd->compflags) {
1604       MEM_freeN((void *)fd->compflags);
1605     }
1606
1607     if (fd->datamap) {
1608       oldnewmap_free(fd->datamap);
1609     }
1610     if (fd->globmap) {
1611       oldnewmap_free(fd->globmap);
1612     }
1613     if (fd->imamap) {
1614       oldnewmap_free(fd->imamap);
1615     }
1616     if (fd->movieclipmap) {
1617       oldnewmap_free(fd->movieclipmap);
1618     }
1619     if (fd->scenemap) {
1620       oldnewmap_free(fd->scenemap);
1621     }
1622     if (fd->soundmap) {
1623       oldnewmap_free(fd->soundmap);
1624     }
1625     if (fd->volumemap) {
1626       oldnewmap_free(fd->volumemap);
1627     }
1628     if (fd->packedmap) {
1629       oldnewmap_free(fd->packedmap);
1630     }
1631     if (fd->libmap && !(fd->flags & FD_FLAGS_NOT_MY_LIBMAP)) {
1632       oldnewmap_free(fd->libmap);
1633     }
1634     if (fd->old_idmap != NULL) {
1635       BKE_main_idmap_destroy(fd->old_idmap);
1636     }
1637     if (fd->bheadmap) {
1638       MEM_freeN(fd->bheadmap);
1639     }
1640
1641 #ifdef USE_GHASH_BHEAD
1642     if (fd->bhead_idname_hash) {
1643       BLI_ghash_free(fd->bhead_idname_hash, NULL, NULL);
1644     }
1645 #endif
1646
1647     MEM_freeN(fd);
1648   }
1649 }
1650
1651 /** \} */
1652
1653 /* -------------------------------------------------------------------- */
1654 /** \name Public Utilities
1655  * \{ */
1656
1657 /**
1658  * Check whether given path ends with a blend file compatible extension
1659  * (`.blend`, `.ble` or `.blend.gz`).
1660  *
1661  * \param str: The path to check.
1662  * \return true is this path ends with a blender file extension.
1663  */
1664 bool BLO_has_bfile_extension(const char *str)
1665 {
1666   const char *ext_test[4] = {".blend", ".ble", ".blend.gz", NULL};
1667   return BLI_path_extension_check_array(str, ext_test);
1668 }
1669
1670 /**
1671  * Try to explode given path into its 'library components'
1672  * (i.e. a .blend file, id type/group, and data-block itself).
1673  *
1674  * \param path: the full path to explode.
1675  * \param r_dir: the string that'll contain path up to blend file itself ('library' path).
1676  * WARNING! Must be #FILE_MAX_LIBEXTRA long (it also stores group and name strings)!
1677  * \param r_group: the string that'll contain 'group' part of the path, if any. May be NULL.
1678  * \param r_name: the string that'll contain data's name part of the path, if any. May be NULL.
1679  * \return true if path contains a blend file.
1680  */
1681 bool BLO_library_path_explode(const char *path, char *r_dir, char **r_group, char **r_name)
1682 {
1683   /* We might get some data names with slashes,
1684    * so we have to go up in path until we find blend file itself,
1685    * then we now next path item is group, and everything else is data name. */
1686   char *slash = NULL, *prev_slash = NULL, c = '\0';
1687
1688   r_dir[0] = '\0';
1689   if (r_group) {
1690     *r_group = NULL;
1691   }
1692   if (r_name) {
1693     *r_name = NULL;
1694   }
1695
1696   /* if path leads to an existing directory, we can be sure we're not (in) a library */
1697   if (BLI_is_dir(path)) {
1698     return false;
1699   }
1700
1701   strcpy(r_dir, path);
1702
1703   while ((slash = (char *)BLI_path_slash_rfind(r_dir))) {
1704     char tc = *slash;
1705     *slash = '\0';
1706     if (BLO_has_bfile_extension(r_dir) && BLI_is_file(r_dir)) {
1707       break;
1708     }
1709     else if (STREQ(r_dir, BLO_EMBEDDED_STARTUP_BLEND)) {
1710       break;
1711     }
1712
1713     if (prev_slash) {
1714       *prev_slash = c;
1715     }
1716     prev_slash = slash;
1717     c = tc;
1718   }
1719
1720   if (!slash) {
1721     return false;
1722   }
1723
1724   if (slash[1] != '\0') {
1725     BLI_assert(strlen(slash + 1) < BLO_GROUP_MAX);
1726     if (r_group) {
1727       *r_group = slash + 1;
1728     }
1729   }
1730
1731   if (prev_slash && (prev_slash[1] != '\0')) {
1732     BLI_assert(strlen(prev_slash + 1) < MAX_ID_NAME - 2);
1733     if (r_name) {
1734       *r_name = prev_slash + 1;
1735     }
1736   }
1737
1738   return true;
1739 }
1740
1741 /**
1742  * Does a very light reading of given .blend file to extract its stored thumbnail.
1743  *
1744  * \param filepath: The path of the file to extract thumbnail from.
1745  * \return The raw thumbnail
1746  * (MEM-allocated, as stored in file, use #BKE_main_thumbnail_to_imbuf()
1747  * to convert it to ImBuf image).
1748  */
1749 BlendThumbnail *BLO_thumbnail_from_file(const char *filepath)
1750 {
1751   FileData *fd;
1752   BlendThumbnail *data = NULL;
1753   int *fd_data;
1754
1755   fd = blo_filedata_from_file_minimal(filepath);
1756   fd_data = fd ? read_file_thumbnail(fd) : NULL;
1757
1758   if (fd_data) {
1759     const int width = fd_data[0];
1760     const int height = fd_data[1];
1761     if (BLEN_THUMB_MEMSIZE_IS_VALID(width, height)) {
1762       const size_t sz = BLEN_THUMB_MEMSIZE(width, height);
1763       data = MEM_mallocN(sz, __func__);
1764       if (data) {
1765         BLI_assert((sz - sizeof(*data)) ==
1766                    (BLEN_THUMB_MEMSIZE_FILE(width, height) - (sizeof(*fd_data) * 2)));
1767         data->width = width;
1768         data->height = height;
1769         memcpy(data->rect, &fd_data[2], sz - sizeof(*data));
1770       }
1771     }
1772   }
1773
1774   blo_filedata_free(fd);
1775
1776   return data;
1777 }
1778
1779 /** \} */
1780
1781 /* -------------------------------------------------------------------- */
1782 /** \name Old/New Pointer Map
1783  * \{ */
1784
1785 /* only direct databocks */
1786 static void *newdataadr(FileData *fd, const void *adr)
1787 {
1788   return oldnewmap_lookup_and_inc(fd->datamap, adr, true);
1789 }
1790
1791 /* only direct databocks */
1792 static void *newdataadr_no_us(FileData *fd, const void *adr)
1793 {
1794   return oldnewmap_lookup_and_inc(fd->datamap, adr, false);
1795 }
1796
1797 /* direct datablocks with global linking */
1798 static void *newglobadr(FileData *fd, const void *adr)
1799 {
1800   return oldnewmap_lookup_and_inc(fd->globmap, adr, true);
1801 }
1802
1803 /* used to restore image data after undo */
1804 static void *newimaadr(FileData *fd, const void *adr)
1805 {
1806   if (fd->imamap && adr) {
1807     return oldnewmap_lookup_and_inc(fd->imamap, adr, true);
1808   }
1809   return NULL;
1810 }
1811
1812 /* used to restore scene data after undo */
1813 static void *newsceadr(FileData *fd, const void *adr)
1814 {
1815   if (fd->scenemap && adr) {
1816     return oldnewmap_lookup_and_inc(fd->scenemap, adr, true);
1817   }
1818   return NULL;
1819 }
1820
1821 /* used to restore movie clip data after undo */
1822 static void *newmclipadr(FileData *fd, const void *adr)
1823 {
1824   if (fd->movieclipmap && adr) {
1825     return oldnewmap_lookup_and_inc(fd->movieclipmap, adr, true);
1826   }
1827   return NULL;
1828 }
1829
1830 /* used to restore sound data after undo */
1831 static void *newsoundadr(FileData *fd, const void *adr)
1832 {
1833   if (fd->soundmap && adr) {
1834     return oldnewmap_lookup_and_inc(fd->soundmap, adr, true);
1835   }
1836   return NULL;
1837 }
1838
1839 /* used to restore volume data after undo */
1840 static void *newvolumeadr(FileData *fd, const void *adr)
1841 {
1842   if (fd->volumemap && adr) {
1843     return oldnewmap_lookup_and_inc(fd->volumemap, adr, true);
1844   }
1845   return NULL;
1846 }
1847
1848 /* used to restore packed data after undo */
1849 static void *newpackedadr(FileData *fd, const void *adr)
1850 {
1851   if (fd->packedmap && adr) {
1852     return oldnewmap_lookup_and_inc(fd->packedmap, adr, true);
1853   }
1854
1855   return oldnewmap_lookup_and_inc(fd->datamap, adr, true);
1856 }
1857
1858 /* only lib data */
1859 static void *newlibadr(FileData *fd, const void *lib, const void *adr)
1860 {
1861   return oldnewmap_liblookup(fd->libmap, adr, lib);
1862 }
1863
1864 /* only lib data */
1865 void *blo_do_versions_newlibadr(FileData *fd, const void *lib, const void *adr)
1866 {
1867   return newlibadr(fd, lib, adr);
1868 }
1869
1870 /* increases user number */
1871 static void change_link_placeholder_to_real_ID_pointer_fd(FileData *fd, const void *old, void *new)
1872 {
1873   for (int i = 0; i < fd->libmap->nentries; i++) {
1874     OldNew *entry = &fd->libmap->entries[i];
1875
1876     if (old == entry->newp && entry->nr == ID_LINK_PLACEHOLDER) {
1877       entry->newp = new;
1878       if (new) {
1879         entry->nr = GS(((ID *)new)->name);
1880       }
1881     }
1882   }
1883 }
1884
1885 static void change_link_placeholder_to_real_ID_pointer(ListBase *mainlist,
1886                                                        FileData *basefd,
1887                                                        void *old,
1888                                                        void *new)
1889 {
1890   Main *mainptr;
1891
1892   for (mainptr = mainlist->first; mainptr; mainptr = mainptr->next) {
1893     FileData *fd;
1894
1895     if (mainptr->curlib) {
1896       fd = mainptr->curlib->filedata;
1897     }
1898     else {
1899       fd = basefd;
1900     }
1901
1902     if (fd) {
1903       change_link_placeholder_to_real_ID_pointer_fd(fd, old, new);
1904     }
1905   }
1906 }
1907
1908 /* lib linked proxy objects point to our local data, we need
1909  * to clear that pointer before reading the undo memfile since
1910  * the object might be removed, it is set again in reading
1911  * if the local object still exists.
1912  * This is only valid for local proxy objects though, linked ones should not be affected here.
1913  */
1914 void blo_clear_proxy_pointers_from_lib(Main *oldmain)
1915 {
1916   Object *ob = oldmain->objects.first;
1917
1918   for (; ob; ob = ob->id.next) {
1919     if (ob->id.lib != NULL && ob->proxy_from != NULL && ob->proxy_from->id.lib == NULL) {
1920       ob->proxy_from = NULL;
1921     }
1922   }
1923 }
1924
1925 void blo_make_scene_pointer_map(FileData *fd, Main *oldmain)
1926 {
1927   Scene *sce = oldmain->scenes.first;
1928
1929   fd->scenemap = oldnewmap_new();
1930
1931   for (; sce; sce = sce->id.next) {
1932     if (sce->eevee.light_cache_data) {
1933       struct LightCache *light_cache = sce->eevee.light_cache_data;
1934       oldnewmap_insert(fd->scenemap, light_cache, light_cache, 0);
1935     }
1936   }
1937 }
1938
1939 void blo_end_scene_pointer_map(FileData *fd, Main *oldmain)
1940 {
1941   OldNew *entry = fd->scenemap->entries;
1942   Scene *sce = oldmain->scenes.first;
1943   int i;
1944
1945   /* used entries were restored, so we put them to zero */
1946   for (i = 0; i < fd->scenemap->nentries; i++, entry++) {
1947     if (entry->nr > 0) {
1948       entry->newp = NULL;
1949     }
1950   }
1951
1952   for (; sce; sce = sce->id.next) {
1953     sce->eevee.light_cache_data = newsceadr(fd, sce->eevee.light_cache_data);
1954   }
1955 }
1956
1957 void blo_make_image_pointer_map(FileData *fd, Main *oldmain)
1958 {
1959   Image *ima = oldmain->images.first;
1960   Scene *sce = oldmain->scenes.first;
1961   int a;
1962
1963   fd->imamap = oldnewmap_new();
1964
1965   for (; ima; ima = ima->id.next) {
1966     if (ima->cache) {
1967       oldnewmap_insert(fd->imamap, ima->cache, ima->cache, 0);
1968     }
1969     for (int eye = 0; eye < 2; eye++) {
1970       for (a = 0; a < TEXTARGET_COUNT; a++) {
1971         if (ima->gputexture[a][eye] != NULL) {
1972           oldnewmap_insert(fd->imamap, ima->gputexture[a][eye], ima->gputexture[a][eye], 0);
1973         }
1974       }
1975     }
1976     if (ima->rr) {
1977       oldnewmap_insert(fd->imamap, ima->rr, ima->rr, 0);
1978     }
1979     LISTBASE_FOREACH (RenderSlot *, slot, &ima->renderslots) {
1980       if (slot->render) {
1981         oldnewmap_insert(fd->imamap, slot->render, slot->render, 0);
1982       }
1983     }
1984   }
1985   for (; sce; sce = sce->id.next) {
1986     if (sce->nodetree && sce->nodetree->previews) {
1987       bNodeInstanceHashIterator iter;
1988       NODE_INSTANCE_HASH_ITER (iter, sce->nodetree->previews) {
1989         bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
1990         oldnewmap_insert(fd->imamap, preview, preview, 0);
1991       }
1992     }
1993   }
1994 }
1995
1996 /* set old main image ibufs to zero if it has been restored */
1997 /* this works because freeing old main only happens after this call */
1998 void blo_end_image_pointer_map(FileData *fd, Main *oldmain)
1999 {
2000   OldNew *entry = fd->imamap->entries;
2001   Image *ima = oldmain->images.first;
2002   Scene *sce = oldmain->scenes.first;
2003   int i;
2004
2005   /* used entries were restored, so we put them to zero */
2006   for (i = 0; i < fd->imamap->nentries; i++, entry++) {
2007     if (entry->nr > 0) {
2008       entry->newp = NULL;
2009     }
2010   }
2011
2012   for (; ima; ima = ima->id.next) {
2013     ima->cache = newimaadr(fd, ima->cache);
2014     if (ima->cache == NULL) {
2015       ima->gpuflag = 0;
2016       ima->gpuframenr = INT_MAX;
2017       for (int eye = 0; eye < 2; eye++) {
2018         for (i = 0; i < TEXTARGET_COUNT; i++) {
2019           ima->gputexture[i][eye] = NULL;
2020         }
2021       }
2022       ima->rr = NULL;
2023     }
2024     LISTBASE_FOREACH (RenderSlot *, slot, &ima->renderslots) {
2025       slot->render = newimaadr(fd, slot->render);
2026     }
2027
2028     for (int eye = 0; eye < 2; eye++) {
2029       for (i = 0; i < TEXTARGET_COUNT; i++) {
2030         ima->gputexture[i][eye] = newimaadr(fd, ima->gputexture[i][eye]);
2031       }
2032     }
2033     ima->rr = newimaadr(fd, ima->rr);
2034   }
2035   for (; sce; sce = sce->id.next) {
2036     if (sce->nodetree && sce->nodetree->previews) {
2037       bNodeInstanceHash *new_previews = BKE_node_instance_hash_new("node previews");
2038       bNodeInstanceHashIterator iter;
2039
2040       /* reconstruct the preview hash, only using remaining pointers */
2041       NODE_INSTANCE_HASH_ITER (iter, sce->nodetree->previews) {
2042         bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
2043         if (preview) {
2044           bNodePreview *new_preview = newimaadr(fd, preview);
2045           if (new_preview) {
2046             bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
2047             BKE_node_instance_hash_insert(new_previews, key, new_preview);
2048           }
2049         }
2050       }
2051       BKE_node_instance_hash_free(sce->nodetree->previews, NULL);
2052       sce->nodetree->previews = new_previews;
2053     }
2054   }
2055 }
2056
2057 void blo_make_movieclip_pointer_map(FileData *fd, Main *oldmain)
2058 {
2059   MovieClip *clip = oldmain->movieclips.first;
2060   Scene *sce = oldmain->scenes.first;
2061
2062   fd->movieclipmap = oldnewmap_new();
2063
2064   for (; clip; clip = clip->id.next) {
2065     if (clip->cache) {
2066       oldnewmap_insert(fd->movieclipmap, clip->cache, clip->cache, 0);
2067     }
2068
2069     if (clip->tracking.camera.intrinsics) {
2070       oldnewmap_insert(
2071           fd->movieclipmap, clip->tracking.camera.intrinsics, clip->tracking.camera.intrinsics, 0);
2072     }
2073   }
2074
2075   for (; sce; sce = sce->id.next) {
2076     if (sce->nodetree) {
2077       bNode *node;
2078       for (node = sce->nodetree->nodes.first; node; node = node->next) {
2079         if (node->type == CMP_NODE_MOVIEDISTORTION) {
2080           oldnewmap_insert(fd->movieclipmap, node->storage, node->storage, 0);
2081         }
2082       }
2083     }
2084   }
2085 }
2086
2087 /* set old main movie clips caches to zero if it has been restored */
2088 /* this works because freeing old main only happens after this call */
2089 void blo_end_movieclip_pointer_map(FileData *fd, Main *oldmain)
2090 {
2091   OldNew *entry = fd->movieclipmap->entries;
2092   MovieClip *clip = oldmain->movieclips.first;
2093   Scene *sce = oldmain->scenes.first;
2094   int i;
2095
2096   /* used entries were restored, so we put them to zero */
2097   for (i = 0; i < fd->movieclipmap->nentries; i++, entry++) {
2098     if (entry->nr > 0) {
2099       entry->newp = NULL;
2100     }
2101   }
2102
2103   for (; clip; clip = clip->id.next) {
2104     clip->cache = newmclipadr(fd, clip->cache);
2105     clip->tracking.camera.intrinsics = newmclipadr(fd, clip->tracking.camera.intrinsics);
2106     BLI_freelistN(&clip->runtime.gputextures);
2107   }
2108
2109   for (; sce; sce = sce->id.next) {
2110     if (sce->nodetree) {
2111       bNode *node;
2112       for (node = sce->nodetree->nodes.first; node; node = node->next) {
2113         if (node->type == CMP_NODE_MOVIEDISTORTION) {
2114           node->storage = newmclipadr(fd, node->storage);
2115         }
2116       }
2117     }
2118   }
2119 }
2120
2121 void blo_make_sound_pointer_map(FileData *fd, Main *oldmain)
2122 {
2123   bSound *sound = oldmain->sounds.first;
2124
2125   fd->soundmap = oldnewmap_new();
2126
2127   for (; sound; sound = sound->id.next) {
2128     if (sound->waveform) {
2129       oldnewmap_insert(fd->soundmap, sound->waveform, sound->waveform, 0);
2130     }
2131   }
2132 }
2133
2134 /* set old main sound caches to zero if it has been restored */
2135 /* this works because freeing old main only happens after this call */
2136 void blo_end_sound_pointer_map(FileData *fd, Main *oldmain)
2137 {
2138   OldNew *entry = fd->soundmap->entries;
2139   bSound *sound = oldmain->sounds.first;
2140   int i;
2141
2142   /* used entries were restored, so we put them to zero */
2143   for (i = 0; i < fd->soundmap->nentries; i++, entry++) {
2144     if (entry->nr > 0) {
2145       entry->newp = NULL;
2146     }
2147   }
2148
2149   for (; sound; sound = sound->id.next) {
2150     sound->waveform = newsoundadr(fd, sound->waveform);
2151   }
2152 }
2153
2154 void blo_make_volume_pointer_map(FileData *fd, Main *oldmain)
2155 {
2156   fd->volumemap = oldnewmap_new();
2157
2158   Volume *volume = oldmain->volumes.first;
2159   for (; volume; volume = volume->id.next) {
2160     if (volume->runtime.grids) {
2161       oldnewmap_insert(fd->volumemap, volume->runtime.grids, volume->runtime.grids, 0);
2162     }
2163   }
2164 }
2165
2166 /* set old main volume caches to zero if it has been restored */
2167 /* this works because freeing old main only happens after this call */
2168 void blo_end_volume_pointer_map(FileData *fd, Main *oldmain)
2169 {
2170   OldNew *entry = fd->volumemap->entries;
2171   Volume *volume = oldmain->volumes.first;
2172   int i;
2173
2174   /* used entries were restored, so we put them to zero */
2175   for (i = 0; i < fd->volumemap->nentries; i++, entry++) {
2176     if (entry->nr > 0)
2177       entry->newp = NULL;
2178   }
2179
2180   for (; volume; volume = volume->id.next) {
2181     volume->runtime.grids = newvolumeadr(fd, volume->runtime.grids);
2182   }
2183 }
2184
2185 /* XXX disabled this feature - packed files also belong in temp saves and quit.blend,
2186  * to make restore work. */
2187
2188 static void insert_packedmap(FileData *fd, PackedFile *pf)
2189 {
2190   oldnewmap_insert(fd->packedmap, pf, pf, 0);
2191   oldnewmap_insert(fd->packedmap, pf->data, pf->data, 0);
2192 }
2193
2194 void blo_make_packed_pointer_map(FileData *fd, Main *oldmain)
2195 {
2196   Image *ima;
2197   VFont *vfont;
2198   bSound *sound;
2199   Volume *volume;
2200   Library *lib;
2201
2202   fd->packedmap = oldnewmap_new();
2203
2204   for (ima = oldmain->images.first; ima; ima = ima->id.next) {
2205     ImagePackedFile *imapf;
2206
2207     if (ima->packedfile) {
2208       insert_packedmap(fd, ima->packedfile);
2209     }
2210
2211     for (imapf = ima->packedfiles.first; imapf; imapf = imapf->next) {
2212       if (imapf->packedfile) {
2213         insert_packedmap(fd, imapf->packedfile);
2214       }
2215     }
2216   }
2217
2218   for (vfont = oldmain->fonts.first; vfont; vfont = vfont->id.next) {
2219     if (vfont->packedfile) {
2220       insert_packedmap(fd, vfont->packedfile);
2221     }
2222   }
2223
2224   for (sound = oldmain->sounds.first; sound; sound = sound->id.next) {
2225     if (sound->packedfile) {
2226       insert_packedmap(fd, sound->packedfile);
2227     }
2228   }
2229
2230   for (volume = oldmain->volumes.first; volume; volume = volume->id.next) {
2231     if (volume->packedfile) {
2232       insert_packedmap(fd, volume->packedfile);
2233     }
2234   }
2235
2236   for (lib = oldmain->libraries.first; lib; lib = lib->id.next) {
2237     if (lib->packedfile) {
2238       insert_packedmap(fd, lib->packedfile);
2239     }
2240   }
2241 }
2242
2243 /* set old main packed data to zero if it has been restored */
2244 /* this works because freeing old main only happens after this call */
2245 void blo_end_packed_pointer_map(FileData *fd, Main *oldmain)
2246 {
2247   Image *ima;
2248   VFont *vfont;
2249   bSound *sound;
2250   Volume *volume;
2251   Library *lib;
2252   OldNew *entry = fd->packedmap->entries;
2253   int i;
2254
2255   /* used entries were restored, so we put them to zero */
2256   for (i = 0; i < fd->packedmap->nentries; i++, entry++) {
2257     if (entry->nr > 0) {
2258       entry->newp = NULL;
2259     }
2260   }
2261
2262   for (ima = oldmain->images.first; ima; ima = ima->id.next) {
2263     ImagePackedFile *imapf;
2264
2265     ima->packedfile = newpackedadr(fd, ima->packedfile);
2266
2267     for (imapf = ima->packedfiles.first; imapf; imapf = imapf->next) {
2268       imapf->packedfile = newpackedadr(fd, imapf->packedfile);
2269     }
2270   }
2271
2272   for (vfont = oldmain->fonts.first; vfont; vfont = vfont->id.next) {
2273     vfont->packedfile = newpackedadr(fd, vfont->packedfile);
2274   }
2275
2276   for (sound = oldmain->sounds.first; sound; sound = sound->id.next) {
2277     sound->packedfile = newpackedadr(fd, sound->packedfile);
2278   }
2279
2280   for (lib = oldmain->libraries.first; lib; lib = lib->id.next) {
2281     lib->packedfile = newpackedadr(fd, lib->packedfile);
2282   }
2283
2284   for (volume = oldmain->volumes.first; volume; volume = volume->id.next) {
2285     volume->packedfile = newpackedadr(fd, volume->packedfile);
2286   }
2287 }
2288
2289 /* undo file support: add all library pointers in lookup */
2290 void blo_add_library_pointer_map(ListBase *old_mainlist, FileData *fd)
2291 {
2292   Main *ptr = old_mainlist->first;
2293   ListBase *lbarray[MAX_LIBARRAY];
2294
2295   for (ptr = ptr->next; ptr; ptr = ptr->next) {
2296     int i = set_listbasepointers(ptr, lbarray);
2297     while (i--) {
2298       ID *id;
2299       for (id = lbarray[i]->first; id; id = id->next) {
2300         oldnewmap_insert(fd->libmap, id, id, GS(id->name));
2301       }
2302     }
2303   }
2304
2305   fd->old_mainlist = old_mainlist;
2306 }
2307
2308 /* Build a GSet of old main (we only care about local data here, so we can do that after
2309  * split_main() call. */
2310 void blo_make_old_idmap_from_main(FileData *fd, Main *bmain)
2311 {
2312   if (fd->old_idmap != NULL) {
2313     BKE_main_idmap_destroy(fd->old_idmap);
2314   }
2315   fd->old_idmap = BKE_main_idmap_create(bmain, false, NULL, MAIN_IDMAP_TYPE_UUID);
2316 }
2317
2318 /** \} */
2319
2320 /* -------------------------------------------------------------------- */
2321 /** \name DNA Struct Loading
2322  * \{ */
2323
2324 static void switch_endian_structs(const struct SDNA *filesdna, BHead *bhead)
2325 {
2326   int blocksize, nblocks;
2327   char *data;
2328
2329   data = (char *)(bhead + 1);
2330   blocksize = filesdna->types_size[filesdna->structs[bhead->SDNAnr][0]];
2331
2332   nblocks = bhead->nr;
2333   while (nblocks--) {
2334     DNA_struct_switch_endian(filesdna, bhead->SDNAnr, data);
2335
2336     data += blocksize;
2337   }
2338 }
2339
2340 static void *read_struct(FileData *fd, BHead *bh, const char *blockname)
2341 {
2342   void *temp = NULL;
2343
2344   if (bh->len) {
2345 #ifdef USE_BHEAD_READ_ON_DEMAND
2346     BHead *bh_orig = bh;
2347 #endif
2348
2349     /* switch is based on file dna */
2350     if (bh->SDNAnr && (fd->flags & FD_FLAGS_SWITCH_ENDIAN)) {
2351 #ifdef USE_BHEAD_READ_ON_DEMAND
2352       if (BHEADN_FROM_BHEAD(bh)->has_data == false) {
2353         bh = blo_bhead_read_full(fd, bh);
2354         if (UNLIKELY(bh == NULL)) {
2355           fd->flags &= ~FD_FLAGS_FILE_OK;
2356           return NULL;
2357         }
2358       }
2359 #endif
2360       switch_endian_structs(fd->filesdna, bh);
2361     }
2362
2363     if (fd->compflags[bh->SDNAnr] != SDNA_CMP_REMOVED) {
2364       if (fd->compflags[bh->SDNAnr] == SDNA_CMP_NOT_EQUAL) {
2365 #ifdef USE_BHEAD_READ_ON_DEMAND
2366         if (BHEADN_FROM_BHEAD(bh)->has_data == false) {
2367           bh = blo_bhead_read_full(fd, bh);
2368           if (UNLIKELY(bh == NULL)) {
2369             fd->flags &= ~FD_FLAGS_FILE_OK;
2370             return NULL;
2371           }
2372         }
2373 #endif
2374         temp = DNA_struct_reconstruct(
2375             fd->memsdna, fd->filesdna, fd->compflags, bh->SDNAnr, bh->nr, (bh + 1));
2376       }
2377       else {
2378         /* SDNA_CMP_EQUAL */
2379         temp = MEM_mallocN(bh->len, blockname);
2380 #ifdef USE_BHEAD_READ_ON_DEMAND
2381         if (BHEADN_FROM_BHEAD(bh)->has_data) {
2382           memcpy(temp, (bh + 1), bh->len);
2383         }
2384         else {
2385           /* Instead of allocating the bhead, then copying it,
2386            * read the data from the file directly into the memory. */
2387           if (UNLIKELY(!blo_bhead_read_data(fd, bh, temp))) {
2388             fd->flags &= ~FD_FLAGS_FILE_OK;
2389             MEM_freeN(temp);
2390             temp = NULL;
2391           }
2392         }
2393 #else
2394         memcpy(temp, (bh + 1), bh->len);
2395 #endif
2396       }
2397     }
2398
2399 #ifdef USE_BHEAD_READ_ON_DEMAND
2400     if (bh_orig != bh) {
2401       MEM_freeN(BHEADN_FROM_BHEAD(bh));
2402     }
2403 #endif
2404   }
2405
2406   return temp;
2407 }
2408
2409 /* Like read_struct, but gets a pointer without allocating. Only works for
2410  * undo since DNA must match. */
2411 static const void *peek_struct_undo(FileData *fd, BHead *bhead)
2412 {
2413   BLI_assert(fd->memfile != NULL);
2414   UNUSED_VARS_NDEBUG(fd);
2415   return (bhead->len) ? (const void *)(bhead + 1) : NULL;
2416 }
2417
2418 static void link_glob_list(FileData *fd, ListBase *lb) /* for glob data */
2419 {
2420   Link *ln, *prev;
2421   void *poin;
2422
2423   if (BLI_listbase_is_empty(lb)) {
2424     return;
2425   }
2426   poin = newdataadr(fd, lb->first);
2427   if (lb->first) {
2428     oldnewmap_insert(fd->globmap, lb->first, poin, 0);
2429   }
2430   lb->first = poin;
2431
2432   ln = lb->first;
2433   prev = NULL;
2434   while (ln) {
2435     poin = newdataadr(fd, ln->next);
2436     if (ln->next) {
2437       oldnewmap_insert(fd->globmap, ln->next, poin, 0);
2438     }
2439     ln->next = poin;
2440     ln->prev = prev;
2441     prev = ln;
2442     ln = ln->next;
2443   }
2444   lb->last = prev;
2445 }
2446
2447 /** \} */
2448
2449 /* -------------------------------------------------------------------- */
2450 /** \name Read ID Properties
2451  * \{ */
2452
2453 static void IDP_DirectLinkProperty(IDProperty *prop, BlendDataReader *reader);
2454 static void IDP_LibLinkProperty(IDProperty *prop, FileData *fd);
2455
2456 static void IDP_DirectLinkIDPArray(IDProperty *prop, BlendDataReader *reader)
2457 {
2458   IDProperty *array;
2459   int i;
2460
2461   /* since we didn't save the extra buffer, set totallen to len */
2462   prop->totallen = prop->len;
2463   BLO_read_data_address(reader, &prop->data.pointer);
2464
2465   array = (IDProperty *)prop->data.pointer;
2466
2467   /* note!, idp-arrays didn't exist in 2.4x, so the pointer will be cleared
2468    * there's not really anything we can do to correct this, at least don't crash */
2469   if (array == NULL) {
2470     prop->len = 0;
2471     prop->totallen = 0;
2472   }
2473
2474   for (i = 0; i < prop->len; i++) {
2475     IDP_DirectLinkProperty(&array[i], reader);
2476   }
2477 }
2478
2479 static void IDP_DirectLinkArray(IDProperty *prop, BlendDataReader *reader)
2480 {
2481   IDProperty **array;
2482   int i;
2483
2484   /* since we didn't save the extra buffer, set totallen to len */
2485   prop->totallen = prop->len;
2486
2487   if (prop->subtype == IDP_GROUP) {
2488     BLO_read_pointer_array(reader, &prop->data.pointer);
2489     array = prop->data.pointer;
2490
2491     for (i = 0; i < prop->len; i++) {
2492       IDP_DirectLinkProperty(array[i], reader);
2493     }
2494   }
2495   else if (prop->subtype == IDP_DOUBLE) {
2496     BLO_read_double_array(reader, prop->len, (double **)&prop->data.pointer);
2497   }
2498   else {
2499     /* also used for floats */
2500     BLO_read_int32_array(reader, prop->len, (int **)&prop->data.pointer);
2501   }
2502 }
2503
2504 static void IDP_DirectLinkString(IDProperty *prop, BlendDataReader *reader)
2505 {
2506   /*since we didn't save the extra string buffer, set totallen to len.*/
2507   prop->totallen = prop->len;
2508   BLO_read_data_address(reader, &prop->data.pointer);
2509 }
2510
2511 static void IDP_DirectLinkGroup(IDProperty *prop, BlendDataReader *reader)
2512 {
2513   ListBase *lb = &prop->data.group;
2514   IDProperty *loop;
2515
2516   BLO_read_list(reader, lb);
2517
2518   /*Link child id properties now*/
2519   for (loop = prop->data.group.first; loop; loop = loop->next) {
2520     IDP_DirectLinkProperty(loop, reader);
2521   }
2522 }
2523
2524 static void IDP_DirectLinkProperty(IDProperty *prop, BlendDataReader *reader)
2525 {
2526   switch (prop->type) {
2527     case IDP_GROUP:
2528       IDP_DirectLinkGroup(prop, reader);
2529       break;
2530     case IDP_STRING:
2531       IDP_DirectLinkString(prop, reader);
2532       break;
2533     case IDP_ARRAY:
2534       IDP_DirectLinkArray(prop, reader);
2535       break;
2536     case IDP_IDPARRAY:
2537       IDP_DirectLinkIDPArray(prop, reader);
2538       break;
2539     case IDP_DOUBLE:
2540       /* Workaround for doubles.
2541        * They are stored in the same field as `int val, val2` in the IDPropertyData struct,
2542        * they have to deal with endianness specifically.
2543        *
2544        * In theory, val and val2 would've already been swapped
2545        * if switch_endian is true, so we have to first unswap
2546        * them then re-swap them as a single 64-bit entity. */
2547       if (BLO_read_requires_endian_switch(reader)) {
2548         BLI_endian_switch_int32(&prop->data.val);
2549         BLI_endian_switch_int32(&prop->data.val2);
2550         BLI_endian_switch_int64((int64_t *)&prop->data.val);
2551       }
2552       break;
2553     case IDP_INT:
2554     case IDP_FLOAT:
2555     case IDP_ID:
2556       break; /* Nothing special to do here. */
2557     default:
2558       /* Unknown IDP type, nuke it (we cannot handle unknown types everywhere in code,
2559        * IDP are way too polymorphic to do it safely. */
2560       printf(
2561           "%s: found unknown IDProperty type %d, reset to Integer one !\n", __func__, prop->type);
2562       /* Note: we do not attempt to free unknown prop, we have no way to know how to do that! */
2563       prop->type = IDP_INT;
2564       prop->subtype = 0;
2565       IDP_Int(prop) = 0;
2566   }
2567 }
2568
2569 #define IDP_DirectLinkGroup_OrFree(prop, reader) \
2570   _IDP_DirectLinkGroup_OrFree(prop, reader, __func__)
2571
2572 static void _IDP_DirectLinkGroup_OrFree(IDProperty **prop,
2573                                         BlendDataReader *reader,
2574                                         const char *caller_func_id)
2575 {
2576   if (*prop) {
2577     if ((*prop)->type == IDP_GROUP) {
2578       IDP_DirectLinkGroup(*prop, reader);
2579     }
2580     else {
2581       /* corrupt file! */
2582       printf("%s: found non group data, freeing type %d!\n", caller_func_id, (*prop)->type);
2583       /* don't risk id, data's likely corrupt. */
2584       // IDP_FreePropertyContent(*prop);
2585       *prop = NULL;
2586     }
2587   }
2588 }
2589
2590 static void IDP_LibLinkProperty(IDProperty *prop, FileData *fd)
2591 {
2592   if (!prop) {
2593     return;
2594   }
2595
2596   switch (prop->type) {
2597     case IDP_ID: /* PointerProperty */
2598     {
2599       void *newaddr = newlibadr(fd, NULL, IDP_Id(prop));
2600       if (IDP_Id(prop) && !newaddr && G.debug) {
2601         printf("Error while loading \"%s\". Data not found in file!\n", prop->name);
2602       }
2603       prop->data.pointer = newaddr;
2604       break;
2605     }
2606     case IDP_IDPARRAY: /* CollectionProperty */
2607     {
2608       IDProperty *idp_array = IDP_IDPArray(prop);
2609       for (int i = 0; i < prop->len; i++) {
2610         IDP_LibLinkProperty(&(idp_array[i]), fd);
2611       }
2612       break;
2613     }
2614     case IDP_GROUP: /* PointerProperty */
2615     {
2616       LISTBASE_FOREACH (IDProperty *, loop, &prop->data.group) {
2617         IDP_LibLinkProperty(loop, fd);
2618       }
2619       break;
2620     }
2621     default:
2622       break; /* Nothing to do for other IDProps. */
2623   }
2624 }
2625
2626 /** \} */
2627
2628 /* -------------------------------------------------------------------- */
2629 /** \name Read Image Preview
2630  * \{ */
2631
2632 static PreviewImage *direct_link_preview_image(BlendDataReader *reader, PreviewImage *old_prv)
2633 {
2634   PreviewImage *prv = BLO_read_get_new_data_address(reader, old_prv);
2635
2636   if (prv) {
2637     int i;
2638     for (i = 0; i < NUM_ICON_SIZES; i++) {
2639       if (prv->rect[i]) {
2640         BLO_read_data_address(reader, &prv->rect[i]);
2641       }
2642       prv->gputexture[i] = NULL;
2643     }
2644     prv->icon_id = 0;
2645     prv->tag = 0;
2646   }
2647
2648   return prv;
2649 }
2650
2651 /** \} */
2652
2653 /* -------------------------------------------------------------------- */
2654 /** \name Read ID
2655  * \{ */
2656
2657 static void lib_link_id(FileData *fd, Main *bmain, ID *id);
2658 static void lib_link_nodetree(FileData *fd, Main *bmain, bNodeTree *ntree);
2659 static void lib_link_collection(FileData *fd, Main *bmain, Collection *collection);
2660
2661 static void lib_link_id_embedded_id(FileData *fd, Main *bmain, ID *id)
2662 {
2663   /* Handle 'private IDs'. */
2664   bNodeTree *nodetree = ntreeFromID(id);
2665   if (nodetree != NULL) {
2666     lib_link_id(fd, bmain, &nodetree->id);
2667     lib_link_nodetree(fd, bmain, nodetree);
2668   }
2669
2670   if (GS(id->name) == ID_SCE) {
2671     Scene *scene = (Scene *)id;
2672     if (scene->master_collection != NULL) {
2673       lib_link_id(fd, bmain, &scene->master_collection->id);
2674       lib_link_collection(fd, bmain, scene->master_collection);
2675     }
2676   }
2677 }
2678
2679 static void lib_link_id(FileData *fd, Main *bmain, ID *id)
2680 {
2681   /* Note: WM IDProperties are never written to file, hence they should always be NULL here. */
2682   BLI_assert((GS(id->name) != ID_WM) || id->properties == NULL);
2683   IDP_LibLinkProperty(id->properties, fd);
2684
2685   AnimData *adt = BKE_animdata_from_id(id);
2686   if (adt != NULL) {
2687     lib_link_animdata(fd, id, adt);
2688   }
2689
2690   if (id->override_library) {
2691     id->override_library->reference = newlibadr(fd, id->lib, id->override_library->reference);
2692     id->override_library->storage = newlibadr(fd, id->lib, id->override_library->storage);
2693   }
2694
2695   lib_link_id_embedded_id(fd, bmain, id);
2696 }
2697
2698 static void direct_link_id_override_property_operation_cb(BlendDataReader *reader, void *data)
2699 {
2700   IDOverrideLibraryPropertyOperation *opop = data;
2701
2702   BLO_read_data_address(reader, &opop->subitem_reference_name);
2703   BLO_read_data_address(reader, &opop->subitem_local_name);
2704
2705   opop->tag = 0; /* Runtime only. */
2706 }
2707
2708 static void direct_link_id_override_property_cb(BlendDataReader *reader, void *data)
2709 {
2710   IDOverrideLibraryProperty *op = data;
2711
2712   BLO_read_data_address(reader, &op->rna_path);
2713
2714   op->tag = 0; /* Runtime only. */
2715
2716   BLO_read_list_cb(reader, &op->operations, direct_link_id_override_property_operation_cb);
2717 }
2718
2719 static void direct_link_id_common(
2720     BlendDataReader *reader, Library *current_library, ID *id, ID *id_old, const int tag);
2721 static void direct_link_nodetree(BlendDataReader *reader, bNodeTree *ntree);
2722 static void direct_link_collection(BlendDataReader *reader, Collection *collection);
2723
2724 static void direct_link_id_embedded_id(BlendDataReader *reader,
2725                                        Library *current_library,
2726                                        ID *id,
2727                                        ID *id_old)
2728 {
2729   /* Handle 'private IDs'. */
2730   bNodeTree **nodetree = BKE_ntree_ptr_from_id(id);
2731   if (nodetree != NULL && *nodetree != NULL) {
2732     BLO_read_data_address(reader, nodetree);
2733     direct_link_id_common(reader,
2734                           current_library,
2735                           (ID *)*nodetree,
2736                           id_old != NULL ? (ID *)ntreeFromID(id_old) : NULL,
2737                           0);
2738     direct_link_nodetree(reader, *nodetree);
2739   }
2740
2741   if (GS(id->name) == ID_SCE) {
2742     Scene *scene = (Scene *)id;
2743     if (scene->master_collection != NULL) {
2744       BLO_read_data_address(reader, &scene->master_collection);
2745       direct_link_id_common(reader,
2746                             current_library,
2747                             &scene->master_collection->id,
2748                             id_old != NULL ? &((Scene *)id_old)->master_collection->id : NULL,
2749                             0);
2750       direct_link_collection(reader, scene->master_collection);
2751     }
2752   }
2753 }
2754
2755 static int direct_link_id_restore_recalc_exceptions(const ID *id_current)
2756 {
2757   /* Exception for armature objects, where the pose has direct points to the
2758    * armature databolock. */
2759   if (GS(id_current->name) == ID_OB && ((Object *)id_current)->pose) {
2760     return ID_RECALC_GEOMETRY;
2761   }
2762
2763   return 0;
2764 }
2765
2766 static int direct_link_id_restore_recalc(const FileData *fd,
2767                                          const ID *id_target,
2768                                          const ID *id_current,
2769                                          const bool is_identical)
2770 {
2771   /* These are the evaluations that had not been performed yet at the time the
2772    * target undo state was written. These need to be done again, since they may
2773    * flush back changes to the original datablock. */
2774   int recalc = id_target->recalc;
2775
2776   if (id_current == NULL) {
2777     /* ID does not currently exist in the database, so also will not exist in
2778      * the dependency graphs. That means it will be newly created and as a
2779      * result also fully re-evaluated regardless of the recalc flag set here. */
2780     recalc |= ID_RECALC_ALL;
2781   }
2782   else {
2783     /* If the contents datablock changed, the depsgraph needs to copy the
2784      * datablock again to ensure it matches the original datablock. */
2785     if (!is_identical) {
2786       recalc |= ID_RECALC_COPY_ON_WRITE;
2787     }
2788
2789     /* Special exceptions. */
2790     recalc |= direct_link_id_restore_recalc_exceptions(id_current);
2791
2792     /* Evaluations for the current state that have not been performed yet
2793      * by the time we are performing this undo step. */
2794     recalc |= id_current->recalc;
2795
2796     /* Tags that were set between the target state and the current state,
2797      * that we need to perform again. */
2798     if (fd->undo_direction < 0) {
2799       /* Undo: tags from target to the current state. */
2800       recalc |= id_current->recalc_up_to_undo_push;
2801     }
2802     else {
2803       /* Redo: tags from current to the target state. */
2804       recalc |= id_target->recalc_up_to_undo_push;
2805     }
2806   }
2807
2808   return recalc;
2809 }
2810
2811 static void direct_link_id_common(
2812     BlendDataReader *reader, Library *current_library, ID *id, ID *id_old, const int tag)
2813 {
2814   if (reader->fd->memfile == NULL) {
2815     /* When actually reading a file , we do want to reset/re-generate session uuids.
2816      * In undo case, we want to re-use existing ones. */
2817     id->session_uuid = MAIN_ID_SESSION_UUID_UNSET;
2818   }
2819
2820   BKE_lib_libblock_session_uuid_ensure(id);
2821
2822   id->lib = current_library;
2823   id->us = ID_FAKE_USERS(id);
2824   id->icon_id = 0;
2825   id->newid = NULL; /* Needed because .blend may have been saved with crap value here... */
2826   id->orig_id = NULL;
2827   id->py_instance = NULL;
2828
2829   /* Initialize with provided tag. */
2830   id->tag = tag;
2831
2832   if (tag & LIB_TAG_ID_LINK_PLACEHOLDER) {
2833     /* For placeholder we only need to set the tag and properly initialize generic ID fields above,
2834      * no further data to read. */
2835     return;
2836   }
2837
2838   /*link direct data of ID properties*/
2839   if (id->properties) {
2840     BLO_read_data_address(reader, &id->properties);
2841     /* this case means the data was written incorrectly, it should not happen */
2842     IDP_DirectLinkGroup_OrFree(&id->properties, reader);
2843   }
2844
2845   id->flag &= ~LIB_INDIRECT_WEAK_LINK;
2846
2847   /* NOTE: It is important to not clear the recalc flags for undo/redo.
2848    * Preserving recalc flags on redo/undo is the only way to make dependency graph detect
2849    * that animation is to be evaluated on undo/redo. If this is not enforced by the recalc
2850    * flags dependency graph does not do animation update to avoid loss of unkeyed changes.,
2851    * which conflicts with undo/redo of changes to animation data itself.
2852    *
2853    * But for regular file load we clear the flag, since the flags might have been changed since
2854    * the version the file has been saved with. */
2855   if (reader->fd->memfile == NULL) {
2856     id->recalc = 0;
2857     id->recalc_after_undo_push = 0;
2858   }
2859   else if ((reader->fd->skip_flags & BLO_READ_SKIP_UNDO_OLD_MAIN) == 0) {
2860     id->recalc = direct_link_id_restore_recalc(reader->fd, id, id_old, false);
2861     id->recalc_after_undo_push = 0;
2862   }
2863
2864   /* Link direct data of overrides. */
2865   if (id->override_library) {
2866     BLO_read_data_address(reader, &id->override_library);
2867     BLO_read_list_cb(
2868         reader, &id->override_library->properties, direct_link_id_override_property_cb);
2869     id->override_library->runtime = NULL;
2870   }
2871
2872   DrawDataList *drawdata = DRW_drawdatalist_from_id(id);
2873   if (drawdata) {
2874     BLI_listbase_clear((ListBase *)drawdata);
2875   }
2876
2877   /* Handle 'private IDs'. */
2878   direct_link_id_embedded_id(reader, current_library, id, id_old);
2879 }
2880
2881 /** \} */
2882
2883 /* -------------------------------------------------------------------- */
2884 /** \name Read CurveProfile
2885  * \{ */
2886
2887 static void direct_link_curveprofile(BlendDataReader *reader, CurveProfile *profile)
2888 {
2889   BLO_read_data_address(reader, &profile->path);
2890   profile->table = NULL;
2891   profile->segments = NULL;
2892 }
2893
2894 /** \} */
2895
2896 /* -------------------------------------------------------------------- */
2897 /** \name Read ID: Brush
2898  * \{ */
2899
2900 /* library brush linking after fileread */
2901 static void lib_link_brush(FileData *fd, Main *UNUSED(bmain), Brush *brush)
2902 {
2903   /* brush->(mask_)mtex.obj is ignored on purpose? */
2904   brush->mtex.tex = newlibadr(fd, brush->id.lib, brush->mtex.tex);
2905   brush->mask_mtex.tex = newlibadr(fd, brush->id.lib, brush->mask_mtex.tex);
2906   brush->clone.image = newlibadr(fd, brush->id.lib, brush->clone.image);
2907   brush->toggle_brush = newlibadr(fd, brush->id.lib, brush->toggle_brush);
2908   brush->paint_curve = newlibadr(fd, brush->id.lib, brush->paint_curve);
2909
2910   /* link default grease pencil palette */
2911   if (brush->gpencil_settings != NULL) {
2912     if (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED) {
2913       brush->gpencil_settings->material = newlibadr(
2914           fd, brush->id.lib, brush->gpencil_settings->material);
2915
2916       if (!brush->gpencil_settings->material) {
2917         brush->gpencil_settings->flag &= ~GP_BRUSH_MATERIAL_PINNED;
2918       }
2919     }
2920     else {
2921       brush->gpencil_settings->material = NULL;
2922     }
2923   }
2924 }
2925
2926 static void direct_link_brush(BlendDataReader *reader, Brush *brush)
2927 {
2928   /* brush itself has been read */
2929
2930   /* fallof curve */
2931   BLO_read_data_address(reader, &brush->curve);
2932
2933   BLO_read_data_address(reader, &brush->gradient);
2934
2935   if (brush->curve) {
2936     BKE_curvemapping_blend_read(reader, brush->curve);
2937   }
2938   else {
2939     BKE_brush_curve_preset(brush, CURVE_PRESET_SHARP);
2940   }
2941
2942   /* grease pencil */
2943   BLO_read_data_address(reader, &brush->gpencil_settings);
2944   if (brush->gpencil_settings != NULL) {
2945     BLO_read_data_address(reader, &brush->gpencil_settings->curve_sensitivity);
2946     BLO_read_data_address(reader, &brush->gpencil_settings->curve_strength);
2947     BLO_read_data_address(reader, &brush->gpencil_settings->curve_jitter);
2948
2949     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_pressure);
2950     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_strength);
2951     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_uv);
2952     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_hue);
2953     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_saturation);
2954     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_value);
2955
2956     if (brush->gpencil_settings->curve_sensitivity) {
2957       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_sensitivity);
2958     }
2959
2960     if (brush->gpencil_settings->curve_strength) {
2961       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_strength);
2962     }
2963
2964     if (brush->gpencil_settings->curve_jitter) {
2965       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_jitter);
2966     }
2967
2968     if (brush->gpencil_settings->curve_rand_pressure) {
2969       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_pressure);
2970     }
2971
2972     if (brush->gpencil_settings->curve_rand_strength) {
2973       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_strength);
2974     }
2975
2976     if (brush->gpencil_settings->curve_rand_uv) {
2977       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_uv);
2978     }
2979
2980     if (brush->gpencil_settings->curve_rand_hue) {
2981       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_hue);
2982     }
2983
2984     if (brush->gpencil_settings->curve_rand_saturation) {
2985       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_saturation);
2986     }
2987
2988     if (brush->gpencil_settings->curve_rand_value) {
2989       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_value);
2990     }
2991   }
2992
2993   brush->preview = NULL;
2994   brush->icon_imbuf = NULL;
2995 }
2996
2997 /** \} */
2998
2999 /* -------------------------------------------------------------------- */
3000 /** \name Read ID: Palette
3001  * \{ */
3002
3003 static void lib_link_palette(FileData *UNUSED(fd), Main *UNUSED(bmain), Palette *UNUSED(palette))
3004 {
3005 }
3006
3007 static void direct_link_palette(BlendDataReader *reader, Palette *palette)
3008 {
3009
3010   /* palette itself has been read */
3011   BLO_read_list(reader, &palette->colors);
3012 }
3013
3014 static void lib_link_paint_curve(FileData *UNUSED(fd), Main *UNUSED(bmain), PaintCurve *UNUSED(pc))
3015 {
3016 }
3017
3018 static void direct_link_paint_curve(BlendDataReader *reader, PaintCurve *pc)
3019 {
3020   BLO_read_data_address(reader, &pc->points);
3021 }
3022
3023 /** \} */
3024
3025 /* -------------------------------------------------------------------- */
3026 /** \name Read PackedFile
3027  * \{ */
3028
3029 static PackedFile *direct_link_packedfile(BlendDataReader *reader, PackedFile *oldpf)
3030 {
3031   PackedFile *pf = newpackedadr(reader->fd, oldpf);
3032
3033   if (pf) {
3034     pf->data = newpackedadr(reader->fd, pf->data);
3035     if (pf->data == NULL) {
3036       /* We cannot allow a PackedFile with a NULL data field,
3037        * the whole code assumes this is not possible. See T70315. */
3038       printf("%s: NULL packedfile data, cleaning up...\n", __func__);
3039       MEM_SAFE_FREE(pf);
3040     }
3041   }
3042
3043   return pf;
3044 }
3045
3046 /** \} */
3047
3048 /* -------------------------------------------------------------------- */
3049 /** \name Read Animation (legacy for version patching)
3050  * \{ */
3051
3052 // XXX deprecated - old animation system
3053 static void lib_link_ipo(FileData *fd, Main *UNUSED(bmain), Ipo *ipo)
3054 {
3055   LISTBASE_FOREACH (IpoCurve *, icu, &ipo->curve) {
3056     if (icu->driver) {
3057       icu->driver->ob = newlibadr(fd, ipo->id.lib, icu->driver->ob);
3058     }
3059   }
3060 }
3061
3062 // XXX deprecated - old animation system
3063 static void direct_link_ipo(BlendDataReader *reader, Ipo *ipo)
3064 {
3065   IpoCurve *icu;
3066
3067   BLO_read_list(reader, &(ipo->curve));
3068
3069   for (icu = ipo->curve.first; icu; icu = icu->next) {
3070     BLO_read_data_address(reader, &icu->bezt);
3071     BLO_read_data_address(reader, &icu->bp);
3072     BLO_read_data_address(reader, &icu->driver);
3073   }
3074 }
3075
3076 // XXX deprecated - old animation system
3077 static void lib_link_nlastrips(FileData *fd, ID *id, ListBase *striplist)
3078 {
3079   bActionStrip *strip;
3080   bActionModifier *amod;
3081
3082   for (strip = striplist->first; strip; strip = strip->next) {
3083     strip->object = newlibadr(fd, id->lib, strip->object);
3084     strip->act = newlibadr(fd, id->lib, strip->act);
3085     strip->ipo = newlibadr(fd, id->lib, strip->ipo);
3086     for (amod = strip->modifiers.first; amod; amod = amod->next) {
3087       amod->ob = newlibadr(fd, id->lib, amod->ob);
3088     }
3089   }
3090 }
3091
3092 // XXX deprecated - old animation system
3093 static void direct_link_nlastrips(BlendDataReader *reader, ListBase *strips)
3094 {
3095   bActionStrip *strip;
3096
3097   BLO_read_list(reader, strips);
3098
3099   for (strip = strips->first; strip; strip = strip->next) {
3100     BLO_read_list(reader, &strip->modifiers);
3101   }
3102 }
3103
3104 // XXX deprecated - old animation system
3105 static void lib_link_constraint_channels(FileData *fd, ID *id, ListBase *chanbase)
3106 {
3107   bConstraintChannel *chan;
3108
3109   for (chan = chanbase->first; chan; chan = chan->next) {
3110     chan->ipo = newlibadr(fd, id->lib, chan->ipo);
3111   }
3112 }
3113
3114 /** \} */
3115
3116 /* -------------------------------------------------------------------- */
3117 /** \name Read ID: Action
3118  * \{ */
3119
3120 static void lib_link_fmodifiers(FileData *fd, ID *id, ListBase *list)
3121 {
3122   FModifier *fcm;
3123
3124   for (fcm = list->first; fcm; fcm = fcm->next) {
3125     /* data for specific modifiers */
3126     switch (fcm->type) {
3127       case FMODIFIER_TYPE_PYTHON: {
3128         FMod_Python *data = (FMod_Python *)fcm->data;
3129         data->script = newlibadr(fd, id->lib, data->script);
3130
3131         break;
3132       }
3133     }
3134   }
3135 }
3136
3137 static void lib_link_fcurves(FileData *fd, ID *id, ListBase *list)
3138 {
3139   FCurve *fcu;
3140
3141   if (list == NULL) {
3142     return;
3143   }
3144
3145   /* relink ID-block references... */
3146   for (fcu = list->first; fcu; fcu = fcu->next) {
3147     /* driver data */
3148     if (fcu->driver) {
3149       ChannelDriver *driver = fcu->driver;
3150       DriverVar *dvar;
3151
3152       for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
3153         DRIVER_TARGETS_LOOPER_BEGIN (dvar) {
3154           /* only relink if still used */
3155           if (tarIndex < dvar->num_targets) {
3156             dtar->id = newlibadr(fd, id->lib, dtar->id);
3157           }
3158           else {
3159             dtar->id = NULL;
3160           }
3161         }
3162         DRIVER_TARGETS_LOOPER_END;
3163       }
3164     }
3165
3166     /* modifiers */
3167     lib_link_fmodifiers(fd, id, &fcu->modifiers);
3168   }
3169 }
3170
3171 /* NOTE: this assumes that link_list has already been called on the list */
3172 static void direct_link_fmodifiers(BlendDataReader *reader, ListBase *list, FCurve *curve)
3173 {
3174   FModifier *fcm;
3175
3176   for (fcm = list->first; fcm; fcm = fcm->next) {
3177     /* relink general data */
3178     BLO_read_data_address(reader, &fcm->data);
3179     fcm->curve = curve;
3180
3181     /* do relinking of data for specific types */
3182     switch (fcm->type) {
3183       case FMODIFIER_TYPE_GENERATOR: {
3184         FMod_Generator *data = (FMod_Generator *)fcm->data;
3185         BLO_read_float_array(reader, data->arraysize, &data->coefficients);
3186         break;
3187       }
3188       case FMODIFIER_TYPE_ENVELOPE: {
3189         FMod_Envelope *data = (FMod_Envelope *)fcm->data;
3190
3191         BLO_read_data_address(reader, &data->data);
3192
3193         break;
3194       }
3195       case FMODIFIER_TYPE_PYTHON: {
3196         FMod_Python *data = (FMod_Python *)fcm->data;
3197
3198         BLO_read_data_address(reader, &data->prop);
3199         IDP_DirectLinkGroup_OrFree(&data->prop, reader);
3200
3201         break;
3202       }
3203     }
3204   }
3205 }
3206
3207 /* NOTE: this assumes that link_list has already been called on the list */
3208 static void direct_link_fcurves(BlendDataReader *reader, ListBase *list)
3209 {
3210   FCurve *fcu;
3211
3212   /* link F-Curve data to F-Curve again (non ID-libs) */
3213   for (fcu = list->first; fcu; fcu = fcu->next) {
3214     /* curve data */
3215     BLO_read_data_address(reader, &fcu->bezt);
3216     BLO_read_data_address(reader, &fcu->fpt);
3217
3218     /* rna path */
3219     BLO_read_data_address(reader, &fcu->rna_path);
3220
3221     /* group */
3222     BLO_read_data_address(reader, &fcu->grp);
3223
3224     /* clear disabled flag - allows disabled drivers to be tried again ([#32155]),
3225      * but also means that another method for "reviving disabled F-Curves" exists
3226      */
3227     fcu->flag &= ~FCURVE_DISABLED;
3228
3229     /* driver */
3230     BLO_read_data_address(reader, &fcu->driver);
3231     if (fcu->driver) {
3232       ChannelDriver *driver = fcu->driver;
3233       DriverVar *dvar;
3234
3235       /* Compiled expression data will need to be regenerated
3236        * (old pointer may still be set here). */
3237       driver->expr_comp = NULL;
3238       driver->expr_simple = NULL;
3239
3240       /* give the driver a fresh chance - the operating environment may be different now
3241        * (addons, etc. may be different) so the driver namespace may be sane now [#32155]
3242        */
3243       driver->flag &= ~DRIVER_FLAG_INVALID;
3244
3245       /* relink variables, targets and their paths */
3246       BLO_read_list(reader, &driver->variables);
3247       for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
3248         DRIVER_TARGETS_LOOPER_BEGIN (dvar) {
3249           /* only relink the targets being used */
3250           if (tarIndex < dvar->num_targets) {
3251             BLO_read_data_address(reader, &dtar->rna_path);
3252           }
3253           else {
3254             dtar->rna_path = NULL;
3255           }
3256         }
3257         DRIVER_TARGETS_LOOPER_END;
3258       }
3259     }
3260
3261     /* modifiers */
3262     BLO_read_list(reader, &fcu->modifiers);
3263     direct_link_fmodifiers(reader, &fcu->modifiers, fcu);
3264   }
3265 }
3266
3267 static void lib_link_action(FileData *fd, Main *UNUSED(bmain), bAction *act)
3268 {
3269   // XXX deprecated - old animation system <<<
3270   LISTBASE_FOREACH (bActionChannel *, chan, &act->chanbase) {
3271     chan->ipo = newlibadr(fd, act->id.lib, chan->ipo);
3272     lib_link_constraint_channels(fd, &act->id, &chan->constraintChannels);
3273   }
3274   // >>> XXX deprecated - old animation system
3275
3276   lib_link_fcurves(fd, &act->id, &act->curves);
3277
3278   LISTBASE_FOREACH (TimeMarker *, marker, &act->markers) {
3279     if (marker->camera) {
3280       marker->camera = newlibadr(fd, act->id.lib, marker->camera);
3281     }
3282   }
3283 }
3284
3285 static void direct_link_action(BlendDataReader *reader, bAction *act)
3286 {
3287   bActionChannel *achan;  // XXX deprecated - old animation system
3288   bActionGroup *agrp;
3289
3290   BLO_read_list(reader, &act->curves);
3291   BLO_read_list(reader, &act->chanbase);  // XXX deprecated - old animation system
3292   BLO_read_list(reader, &act->groups);
3293   BLO_read_list(reader, &act->markers);
3294
3295   // XXX deprecated - old animation system <<<
3296   for (achan = act->chanbase.first; achan; achan = achan->next) {
3297     BLO_read_data_address(reader, &achan->grp);
3298
3299     BLO_read_list(reader, &achan->constraintChannels);
3300   }
3301   // >>> XXX deprecated - old animation system
3302
3303   direct_link_fcurves(reader, &act->curves);
3304
3305   for (agrp = act->groups.first; agrp; agrp = agrp->next) {
3306     BLO_read_data_address(reader, &agrp->channels.first);
3307     BLO_read_data_address(reader, &agrp->channels.last);
3308   }
3309 }
3310
3311 static void lib_link_nladata_strips(FileData *fd, ID *id, ListBase *list)
3312 {
3313   NlaStrip *strip;
3314
3315   for (strip = list->first; strip; strip = strip->next) {
3316     /* check strip's children */
3317     lib_link_nladata_strips(fd, id, &strip->strips);
3318
3319     /* check strip's F-Curves */
3320     lib_link_fcurves(fd, id, &strip->fcurves);
3321
3322     /* reassign the counted-reference to action */
3323     strip->act = newlibadr(fd, id->lib, strip->act);
3324   }
3325 }
3326
3327 static void lib_link_nladata(FileData *fd, ID *id, ListBase *list)
3328 {
3329   NlaTrack *nlt;
3330
3331   /* we only care about the NLA strips inside the tracks */
3332   for (nlt = list->first; nlt; nlt = nlt->next) {
3333     lib_link_nladata_strips(fd, id, &nlt->strips);
3334   }
3335 }
3336
3337 /* This handles Animato NLA-Strips linking
3338  * NOTE: this assumes that link_list has already been called on the list
3339  */
3340 static void direct_link_nladata_strips(BlendDataReader *reader, ListBase *list)
3341 {
3342   NlaStrip *strip;
3343
3344   for (strip = list->first; strip; strip = strip->next) {
3345     /* strip's child strips */
3346     BLO_read_list(reader, &strip->strips);
3347     direct_link_nladata_strips(reader, &strip->strips);
3348
3349     /* strip's F-Curves */
3350     BLO_read_list(reader, &strip->fcurves);
3351     direct_link_fcurves(reader, &strip->fcurves);
3352
3353     /* strip's F-Modifiers */
3354     BLO_read_list(reader, &strip->modifiers);
3355     direct_link_fmodifiers(reader, &strip->modifiers, NULL);
3356   }
3357 }
3358
3359 /* NOTE: this assumes that BLO_read_list has already been called on the list */
3360 static void direct_link_nladata(BlendDataReader *reader, ListBase *list)
3361 {
3362   NlaTrack *nlt;
3363
3364   for (nlt = list->first; nlt; nlt = nlt->next) {
3365     /* relink list of strips */
3366     BLO_read_list(reader, &nlt->strips);
3367
3368     /* relink strip data */
3369     direct_link_nladata_strips(reader, &nlt->strips);
3370   }
3371 }
3372
3373 /* ------- */
3374
3375 static void lib_link_keyingsets(FileData *fd, ID *id, ListBase *list)
3376 {
3377   KeyingSet *ks;
3378   KS_Path *ksp;
3379
3380   /* here, we're only interested in the ID pointer stored in some of the paths */
3381   for (ks = list->first; ks; ks = ks->next) {
3382     for (ksp = ks->paths.first; ksp; ksp = ksp->next) {
3383       ksp->id = newlibadr(fd, id->lib, ksp->id);
3384     }
3385   }
3386 }
3387
3388 /* NOTE: this assumes that BLO_read_list has already been called on the list */
3389 static void direct_link_keyingsets(BlendDataReader *reader, ListBase *list)
3390 {
3391   KeyingSet *ks;
3392   KS_Path *ksp;
3393
3394   /* link KeyingSet data to KeyingSet again (non ID-libs) */
3395   for (ks = list->first; ks; ks = ks->next) {
3396     /* paths */
3397     BLO_read_list(reader, &ks->paths);
3398
3399     for (ksp = ks->paths.first; ksp; ksp = ksp->next) {
3400       /* rna path */
3401       BLO_read_data_address(reader, &ksp->rna_path);
3402     }
3403   }
3404 }
3405
3406 /* ------- */
3407
3408 static void lib_link_animdata(FileData *fd, ID *id, AnimData *adt)
3409 {
3410   if (adt == NULL) {
3411     return;
3412   }
3413
3414   /* link action data */
3415   adt->action = newlibadr(fd, id->lib, adt->action);
3416   adt->tmpact = newlibadr(fd, id->lib, adt->tmpact);
3417
3418   /* link drivers */
3419   lib_link_fcurves(fd, id, &adt->drivers);
3420
3421   /* overrides don't have lib-link for now, so no need to do anything */
3422
3423   /* link NLA-data */
3424   lib_link_nladata(fd, id, &adt->nla_tracks);
3425 }
3426
3427 static void direct_link_animdata(BlendDataReader *reader, AnimData *adt)
3428 {
3429   /* NOTE: must have called newdataadr already before doing this... */
3430   if (adt == NULL) {
3431     return;
3432   }
3433
3434   /* link drivers */
3435   BLO_read_list(reader, &adt->drivers);
3436   direct_link_fcurves(reader, &adt->drivers);
3437   adt->driver_array = NULL;
3438
3439   /* link overrides */
3440   // TODO...
3441
3442   /* link NLA-data */
3443   BLO_read_list(reader, &adt->nla_tracks);
3444   direct_link_nladata(reader, &adt->nla_tracks);
3445
3446   /* relink active track/strip - even though strictly speaking this should only be used
3447    * if we're in 'tweaking mode', we need to be able to have this loaded back for
3448    * undo, but also since users may not exit tweakmode before saving (#24535)
3449    */
3450   // TODO: it's not really nice that anyone should be able to save the file in this
3451   //      state, but it's going to be too hard to enforce this single case...
3452   BLO_read_data_address(reader, &adt->act_track);
3453   BLO_read_data_address(reader, &adt->actstrip);
3454 }
3455
3456 /** \} */
3457
3458 /* -------------------------------------------------------------------- */
3459 /** \name Read ID: CacheFiles
3460  * \{ */
3461
3462 static void lib_link_cachefiles(FileData *UNUSED(fd),
3463                                 Main *UNUSED(bmain),
3464                                 CacheFile *UNUSED(cache_file))
3465 {
3466 }
3467
3468 static void direct_link_cachefile(BlendDataReader *reader, CacheFile *cache_file)
3469 {
3470   BLI_listbase_clear(&cache_file->object_paths);
3471   cache_file->handle = NULL;
3472   cache_file->handle_filepath[0] = '\0';
3473   cache_file->handle_readers = NULL;
3474
3475   /* relink animdata */
3476   BLO_read_data_address(reader, &cache_file->adt);
3477   direct_link_animdata(reader, cache_file->adt);
3478 }
3479
3480 /** \} */
3481
3482 /* -------------------------------------------------------------------- */
3483 /** \name Read ID: WorkSpace
3484  * \{ */
3485
3486 static void lib_link_workspaces(FileData *fd, Main *bmain, WorkSpace *workspace)
3487 {
3488   ID *id = (ID *)workspace;
3489
3490   LISTBASE_FOREACH_MUTABLE (WorkSpaceLayout *, layout, &workspace->layouts) {
3491     layout->screen = newlibadr(fd, id->lib, layout->screen);
3492
3493     if (layout->screen) {
3494       if (ID_IS_LINKED(id)) {
3495         layout->screen->winid = 0;
3496         if (layout->screen->temp) {
3497           /* delete temp layouts when appending */
3498           BKE_workspace_layout_remove(bmain, workspace, layout);
3499         }
3500       }
3501     }
3502     else {
3503       /* If we're reading a layout without screen stored, it's useless and we shouldn't keep it
3504        * around. */
3505       BKE_workspace_layout_remove(bmain, workspace, layout);
3506     }
3507   }
3508 }
3509
3510 static void direct_link_workspace(BlendDataReader *reader, WorkSpace *workspace, const Main *main)
3511 {
3512   BLO_read_list(reader, &workspace->layouts);
3513   BLO_read_list(reader, &workspace->hook_layout_relations);
3514   BLO_read_list(reader, &workspace->owner_ids);
3515   BLO_read_list(reader, &workspace->tools);
3516
3517   LISTBASE_FOREACH (WorkSpaceDataRelation *, relation, &workspace->hook_layout_relations) {
3518     /* data from window - need to access through global oldnew-map */
3519     relation->parent = newglobadr(reader->fd, relation->parent);
3520     BLO_read_data_address(reader, &relation->value);
3521   }
3522
3523   /* Same issue/fix as in direct_link_workspace_link_scene_data: Can't read workspace data
3524    * when reading windows, so have to update windows after/when reading workspaces. */
3525   for (wmWindowManager *wm = main->wm.first; wm; wm = wm->id.next) {
3526     LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
3527       BLO_read_data_address(reader, &win->workspace_hook->act_layout);
3528     }
3529   }
3530
3531   LISTBASE_FOREACH (bToolRef *, tref, &workspace->tools) {
3532     tref->runtime = NULL;
3533     BLO_read_data_address(reader, &tref->properties);
3534     IDP_DirectLinkGroup_OrFree(&tref->properties, reader);
3535   }
3536
3537   workspace->status_text = NULL;
3538
3539   id_us_ensure_real(&workspace->id);
3540 }
3541
3542 static void lib_link_workspace_instance_hook(FileData *fd, WorkSpaceInstanceHook *hook, ID *id)
3543 {
3544   WorkSpace *workspace = BKE_workspace_active_get(hook);
3545   BKE_workspace_active_set(hook, newlibadr(fd, id->lib, workspace));
3546 }
3547
3548 /** \} */
3549
3550 /* -------------------------------------------------------------------- */
3551 /** \name Read ID: Node Tree
3552  * \{ */
3553
3554 static void lib_link_node_socket(FileData *fd, Library *lib, bNodeSocket *sock)
3555 {
3556   IDP_LibLinkProperty(sock->prop, fd);
3557
3558   switch ((eNodeSocketDatatype)sock->type) {
3559     case SOCK_OBJECT: {
3560       bNodeSocketValueObject *default_value = sock->default_value;
3561       default_value->value = newlibadr(fd, lib, default_value->value);
3562       break;
3563     }
3564     case SOCK_IMAGE: {
3565       bNodeSocketValueImage *default_value = sock->default_value;
3566       default_value->value = newlibadr(fd, lib, default_value->value);
3567       break;
3568     }
3569     case SOCK_FLOAT:
3570     case SOCK_VECTOR:
3571     case SOCK_RGBA:
3572     case SOCK_BOOLEAN:
3573     case SOCK_INT:
3574     case SOCK_STRING:
3575     case __SOCK_MESH:
3576     case SOCK_CUSTOM:
3577     case SOCK_SHADER:
3578     case SOCK_EMITTERS:
3579     case SOCK_EVENTS:
3580     case SOCK_FORCES:
3581     case SOCK_CONTROL_FLOW:
3582       break;
3583   }
3584 }
3585
3586 static void lib_link_node_sockets(FileData *fd, Library *lib, ListBase *sockets)
3587 {
3588   LISTBASE_FOREACH (bNodeSocket *, sock, sockets) {
3589     lib_link_node_socket(fd, lib, sock);
3590   }
3591 }
3592
3593 /* Single node tree (also used for material/scene trees), ntree is not NULL */
3594 static void lib_link_ntree(FileData *fd, Library *lib, bNodeTree *ntree)
3595 {
3596   ntree->id.lib = lib;
3597
3598   ntree->gpd = newlibadr(fd, lib, ntree->gpd);
3599
3600   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3601     /* Link ID Properties -- and copy this comment EXACTLY for easy finding
3602      * of library blocks that implement this.*/
3603     IDP_LibLinkProperty(node->prop, fd);
3604
3605     node->id = newlibadr(fd, lib, node->id);
3606
3607     lib_link_node_sockets(fd, lib, &node->inputs);
3608     lib_link_node_sockets(fd, lib, &node->outputs);
3609   }
3610
3611   lib_link_node_sockets(fd, lib, &ntree->inputs);
3612   lib_link_node_sockets(fd, lib, &ntree->outputs);
3613
3614   /* Set node->typeinfo pointers. This is done in lib linking, after the
3615    * first versioning that can change types still without functions that
3616    * update the typeinfo pointers. Versioning after lib linking needs
3617    * these top be valid. */
3618   ntreeSetTypes(NULL, ntree);
3619
3620   /* For nodes with static socket layout, add/remove sockets as needed
3621    * to match the static layout. */
3622   if (fd->memfile == NULL) {
3623     LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3624       node_verify_socket_templates(ntree, node);
3625     }
3626   }
3627 }
3628
3629 /* library ntree linking after fileread */
3630 static void lib_link_nodetree(FileData *fd, Main *UNUSED(bmain), bNodeTree *ntree)
3631 {
3632   lib_link_ntree(fd, ntree->id.lib, ntree);
3633 }
3634
3635 static void direct_link_node_socket(BlendDataReader *reader, bNodeSocket *sock)
3636 {
3637   BLO_read_data_address(reader, &sock->prop);
3638   IDP_DirectLinkGroup_OrFree(&sock->prop, reader);
3639
3640   BLO_read_data_address(reader, &sock->link);
3641   sock->typeinfo = NULL;
3642   BLO_read_data_address(reader, &sock->storage);
3643   BLO_read_data_address(reader, &sock->default_value);
3644   sock->cache = NULL;
3645 }
3646
3647 /* ntree itself has been read! */
3648 static void direct_link_nodetree(BlendDataReader *reader, bNodeTree *ntree)
3649 {
3650   /* note: writing and reading goes in sync, for speed */
3651   bNode *node;
3652   bNodeSocket *sock;
3653   bNodeLink *link;
3654
3655   ntree->init = 0; /* to set callbacks and force setting types */
3656   ntree->is_updating = false;
3657   ntree->typeinfo = NULL;
3658   ntree->interface_type = NULL;
3659
3660   ntree->progress = NULL;
3661   ntree->execdata = NULL;
3662
3663   BLO_read_data_address(reader, &ntree->adt);
3664   direct_link_animdata(reader, ntree->adt);
3665
3666   BLO_read_list(reader, &ntree->nodes);
3667   for (node = ntree->nodes.first; node; node = node->next) {
3668     node->typeinfo = NULL;
3669
3670     BLO_read_list(reader, &node->inputs);
3671     BLO_read_list(reader, &node->outputs);
3672
3673     BLO_read_data_address(reader, &node->prop);
3674     IDP_DirectLinkGroup_OrFree(&node->prop, reader);
3675
3676     BLO_read_list(reader, &node->internal_links);
3677     for (link = node->internal_links.first; link; link = link->next) {
3678       BLO_read_data_address(reader, &link->fromnode);
3679       BLO_read_data_address(reader, &link->fromsock);
3680       BLO_read_data_address(reader, &link->tonode);
3681       BLO_read_data_address(reader, &link->tosock);
3682     }
3683
3684     if (node->type == CMP_NODE_MOVIEDISTORTION) {
3685       node->storage = newmclipadr(reader->fd, node->storage);
3686     }
3687     else {
3688       BLO_read_data_address(reader, &node->storage);
3689     }
3690
3691     if (node->storage) {
3692       /* could be handlerized at some point */
3693       switch (node->type) {
3694         case SH_NODE_CURVE_VEC:
3695         case SH_NODE_CURVE_RGB:
3696         case CMP_NODE_TIME:
3697         case CMP_NODE_CURVE_VEC:
3698         case CMP_NODE_CURVE_RGB:
3699         case CMP_NODE_HUECORRECT:
3700         case TEX_NODE_CURVE_RGB:
3701         case TEX_NODE_CURVE_TIME: {
3702           BKE_curvemapping_blend_read(reader, node->storage);
3703           break;
3704         }
3705         case SH_NODE_SCRIPT: {
3706           NodeShaderScript *nss = (NodeShaderScript *)node->storage;
3707           BLO_read_data_address(reader, &nss->bytecode);
3708           break;
3709         }
3710         case SH_NODE_TEX_POINTDENSITY: {
3711           NodeShaderTexPointDensity *npd = (NodeShaderTexPointDensity *)node->storage;
3712           memset(&npd->pd, 0, sizeof(npd->pd));
3713           break;
3714         }
3715         case SH_NODE_TEX_IMAGE: {
3716           NodeTexImage *tex = (NodeTexImage *)node->storage;
3717           tex->iuser.ok = 1;
3718           tex->iuser.scene = NULL;
3719           break;
3720         }
3721         case SH_NODE_TEX_ENVIRONMENT: {
3722           NodeTexEnvironment *tex = (NodeTexEnvironment *)node->storage;
3723           tex->iuser.ok = 1;
3724           tex->iuser.scene = NULL;
3725           break;
3726         }
3727         case CMP_NODE_IMAGE:
3728         case CMP_NODE_R_LAYERS:
3729         case CMP_NODE_VIEWER:
3730         case CMP_NODE_SPLITVIEWER: {
3731           ImageUser *iuser = node->storage;
3732           iuser->ok = 1;
3733           iuser->scene = NULL;
3734           break;
3735         }
3736         case CMP_NODE_CRYPTOMATTE: {
3737           NodeCryptomatte *nc = (NodeCryptomatte *)node->storage;
3738           BLO_read_data_address(reader, &nc->matte_id);
3739           break;
3740         }
3741         case TEX_NODE_IMAGE: {
3742           ImageUser *iuser = node->storage;
3743           iuser->ok = 1;
3744           iuser->scene = NULL;
3745           break;
3746         }
3747         default:
3748           break;
3749       }
3750     }
3751   }
3752   BLO_read_list(reader, &ntree->links);
3753
3754   /* and we connect the rest */
3755   for (node = ntree->nodes.first; node; node = node->next) {
3756     BLO_read_data_address(reader, &node->parent);
3757     node->lasty = 0;
3758
3759     for (sock = node->inputs.first; sock; sock = sock->next) {
3760       direct_link_node_socket(reader, sock);
3761     }
3762     for (sock = node->outputs.first; sock; sock = sock->next) {
3763       direct_link_node_socket(reader, sock);
3764     }
3765   }
3766
3767   /* interface socket lists */
3768   BLO_read_list(reader, &ntree->inputs);
3769   BLO_read_list(reader, &ntree->outputs);
3770   for (sock = ntree->inputs.first; sock; sock = sock->next) {
3771     direct_link_node_socket(reader, sock);
3772   }
3773   for (sock = ntree->outputs.first; sock; sock = sock->next) {
3774     direct_link_node_socket(reader, sock);
3775   }
3776
3777   for (link = ntree->links.first; link; link = link->next) {
3778     BLO_read_data_address(reader, &link->fromnode);
3779     BLO_read_data_address(reader, &link->tonode);
3780     BLO_read_data_address(reader, &link->fromsock);
3781     BLO_read_data_address(reader, &link->tosock);
3782   }
3783
3784 #if 0
3785   if (ntree->previews) {
3786     bNodeInstanceHash* new_previews = BKE_node_instance_hash_new("node previews");
3787     bNodeInstanceHashIterator iter;