Merge branch 'blender-v2.90-release'
[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_memarena.h"
109 #include "BLI_mempool.h"
110 #include "BLI_threads.h"
111
112 #include "BLT_translation.h"
113
114 #include "BKE_action.h"
115 #include "BKE_anim_data.h"
116 #include "BKE_armature.h"
117 #include "BKE_brush.h"
118 #include "BKE_collection.h"
119 #include "BKE_colortools.h"
120 #include "BKE_constraint.h"
121 #include "BKE_curve.h"
122 #include "BKE_curveprofile.h"
123 #include "BKE_effect.h"
124 #include "BKE_fcurve_driver.h"
125 #include "BKE_fluid.h"
126 #include "BKE_global.h"  // for G
127 #include "BKE_gpencil_modifier.h"
128 #include "BKE_hair.h"
129 #include "BKE_idprop.h"
130 #include "BKE_idtype.h"
131 #include "BKE_image.h"
132 #include "BKE_layer.h"
133 #include "BKE_lib_id.h"
134 #include "BKE_lib_override.h"
135 #include "BKE_lib_query.h"
136 #include "BKE_main.h"  // for Main
137 #include "BKE_main_idmap.h"
138 #include "BKE_material.h"
139 #include "BKE_mesh.h"  // for ME_ defines (patching)
140 #include "BKE_mesh_runtime.h"
141 #include "BKE_modifier.h"
142 #include "BKE_multires.h"
143 #include "BKE_node.h"  // for tree type defines
144 #include "BKE_object.h"
145 #include "BKE_paint.h"
146 #include "BKE_particle.h"
147 #include "BKE_pointcache.h"
148 #include "BKE_pointcloud.h"
149 #include "BKE_report.h"
150 #include "BKE_scene.h"
151 #include "BKE_screen.h"
152 #include "BKE_sequencer.h"
153 #include "BKE_shader_fx.h"
154 #include "BKE_simulation.h"
155 #include "BKE_sound.h"
156 #include "BKE_volume.h"
157 #include "BKE_workspace.h"
158
159 #include "DRW_engine.h"
160
161 #include "DEG_depsgraph.h"
162
163 #include "NOD_socket.h"
164
165 #include "BLO_blend_defs.h"
166 #include "BLO_blend_validate.h"
167 #include "BLO_read_write.h"
168 #include "BLO_readfile.h"
169 #include "BLO_undofile.h"
170
171 #include "RE_engine.h"
172
173 #include "engines/eevee/eevee_lightcache.h"
174
175 #include "readfile.h"
176
177 #include <errno.h>
178
179 /* Make preferences read-only. */
180 #define U (*((const UserDef *)&U))
181
182 /**
183  * READ
184  * ====
185  *
186  * - Existing Library (#Main) push or free
187  * - allocate new #Main
188  * - load file
189  * - read #SDNA
190  * - for each LibBlock
191  *   - read LibBlock
192  *   - if a Library
193  *     - make a new #Main
194  *     - attach ID's to it
195  *   - else
196  *     - read associated 'direct data'
197  *     - link direct data (internal and to LibBlock)
198  * - read #FileGlobal
199  * - read #USER data, only when indicated (file is `~/.config/blender/X.XX/config/userpref.blend`)
200  * - free file
201  * - per Library (per #Main)
202  *   - read file
203  *   - read #SDNA
204  *   - find LibBlocks and attach #ID's to #Main
205  *     - if external LibBlock
206  *       - search all #Main's
207  *         - or it's already read,
208  *         - or not read yet
209  *         - or make new #Main
210  *   - per LibBlock
211  *     - read recursive
212  *     - read associated direct data
213  *     - link direct data (internal and to LibBlock)
214  *   - free file
215  * - per Library with unread LibBlocks
216  *   - read file
217  *   - read #SDNA
218  *   - per LibBlock
219  *     - read recursive
220  *     - read associated direct data
221  *     - link direct data (internal and to LibBlock)
222  *   - free file
223  * - join all #Main's
224  * - link all LibBlocks and indirect pointers to libblocks
225  * - initialize #FileGlobal and copy pointers to #Global
226  *
227  * \note Still a weak point is the new-address function, that doesn't solve reading from
228  * multiple files at the same time.
229  * (added remark: oh, i thought that was solved? will look at that... (ton).
230  */
231
232 /**
233  * Delay reading blocks we might not use (especially applies to library linking).
234  * which keeps large arrays in memory from data-blocks we may not even use.
235  *
236  * \note This is disabled when using compression,
237  * while zlib supports seek it's unusably slow, see: T61880.
238  */
239 #define USE_BHEAD_READ_ON_DEMAND
240
241 /* use GHash for BHead name-based lookups (speeds up linking) */
242 #define USE_GHASH_BHEAD
243
244 /* Use GHash for restoring pointers by name */
245 #define USE_GHASH_RESTORE_POINTER
246
247 /* Define this to have verbose debug prints. */
248 //#define USE_DEBUG_PRINT
249
250 #ifdef USE_DEBUG_PRINT
251 #  define DEBUG_PRINTF(...) printf(__VA_ARGS__)
252 #else
253 #  define DEBUG_PRINTF(...)
254 #endif
255
256 /* local prototypes */
257 static void read_libraries(FileData *basefd, ListBase *mainlist);
258 static void *read_struct(FileData *fd, BHead *bh, const char *blockname);
259 static void direct_link_modifiers(BlendDataReader *reader, ListBase *lb, Object *ob);
260 static BHead *find_bhead_from_code_name(FileData *fd, const short idcode, const char *name);
261 static BHead *find_bhead_from_idname(FileData *fd, const char *idname);
262
263 #ifdef USE_COLLECTION_COMPAT_28
264 static void expand_scene_collection(BlendExpander *expander, SceneCollection *sc);
265 #endif
266 static void direct_link_animdata(BlendDataReader *reader, AnimData *adt);
267 static void lib_link_animdata(BlendLibReader *reader, ID *id, AnimData *adt);
268
269 typedef struct BHeadN {
270   struct BHeadN *next, *prev;
271 #ifdef USE_BHEAD_READ_ON_DEMAND
272   /** Use to read the data from the file directly into memory as needed. */
273   off64_t file_offset;
274   /** When set, the remainder of this allocation is the data, otherwise it needs to be read. */
275   bool has_data;
276 #endif
277   bool is_memchunk_identical;
278   struct BHead bhead;
279 } BHeadN;
280
281 #define BHEADN_FROM_BHEAD(bh) ((BHeadN *)POINTER_OFFSET(bh, -offsetof(BHeadN, bhead)))
282
283 /* We could change this in the future, for now it's simplest if only data is delayed
284  * because ID names are used in lookup tables. */
285 #define BHEAD_USE_READ_ON_DEMAND(bhead) ((bhead)->code == DATA)
286
287 /**
288  * This function ensures that reports are printed,
289  * in the case of library linking errors this is important!
290  *
291  * bit kludge but better then doubling up on prints,
292  * we could alternatively have a versions of a report function which forces printing - campbell
293  */
294 void blo_reportf_wrap(ReportList *reports, ReportType type, const char *format, ...)
295 {
296   char fixed_buf[1024]; /* should be long enough */
297
298   va_list args;
299
300   va_start(args, format);
301   vsnprintf(fixed_buf, sizeof(fixed_buf), format, args);
302   va_end(args);
303
304   fixed_buf[sizeof(fixed_buf) - 1] = '\0';
305
306   BKE_report(reports, type, fixed_buf);
307
308   if (G.background == 0) {
309     printf("%s: %s\n", BKE_report_type_str(type), fixed_buf);
310   }
311 }
312
313 /* for reporting linking messages */
314 static const char *library_parent_filepath(Library *lib)
315 {
316   return lib->parent ? lib->parent->filepath_abs : "<direct>";
317 }
318
319 /* -------------------------------------------------------------------- */
320 /** \name OldNewMap API
321  * \{ */
322
323 typedef struct OldNew {
324   const void *oldp;
325   void *newp;
326   /* `nr` is "user count" for data, and ID code for libdata. */
327   int nr;
328 } OldNew;
329
330 typedef struct OldNewMap {
331   /* Array that stores the actual entries. */
332   OldNew *entries;
333   int nentries;
334   /* Hashmap that stores indices into the `entries` array. */
335   int32_t *map;
336
337   int capacity_exp;
338 } OldNewMap;
339
340 #define ENTRIES_CAPACITY(onm) (1ll << (onm)->capacity_exp)
341 #define MAP_CAPACITY(onm) (1ll << ((onm)->capacity_exp + 1))
342 #define SLOT_MASK(onm) (MAP_CAPACITY(onm) - 1)
343 #define DEFAULT_SIZE_EXP 6
344 #define PERTURB_SHIFT 5
345
346 /* based on the probing algorithm used in Python dicts. */
347 #define ITER_SLOTS(onm, KEY, SLOT_NAME, INDEX_NAME) \
348   uint32_t hash = BLI_ghashutil_ptrhash(KEY); \
349   uint32_t mask = SLOT_MASK(onm); \
350   uint perturb = hash; \
351   int SLOT_NAME = mask & hash; \
352   int INDEX_NAME = onm->map[SLOT_NAME]; \
353   for (;; SLOT_NAME = mask & ((5 * SLOT_NAME) + 1 + perturb), \
354           perturb >>= PERTURB_SHIFT, \
355           INDEX_NAME = onm->map[SLOT_NAME])
356
357 static void oldnewmap_insert_index_in_map(OldNewMap *onm, const void *ptr, int index)
358 {
359   ITER_SLOTS (onm, ptr, slot, stored_index) {
360     if (stored_index == -1) {
361       onm->map[slot] = index;
362       break;
363     }
364   }
365 }
366
367 static void oldnewmap_insert_or_replace(OldNewMap *onm, OldNew entry)
368 {
369   ITER_SLOTS (onm, entry.oldp, slot, index) {
370     if (index == -1) {
371       onm->entries[onm->nentries] = entry;
372       onm->map[slot] = onm->nentries;
373       onm->nentries++;
374       break;
375     }
376     if (onm->entries[index].oldp == entry.oldp) {
377       onm->entries[index] = entry;
378       break;
379     }
380   }
381 }
382
383 static OldNew *oldnewmap_lookup_entry(const OldNewMap *onm, const void *addr)
384 {
385   ITER_SLOTS (onm, addr, slot, index) {
386     if (index >= 0) {
387       OldNew *entry = &onm->entries[index];
388       if (entry->oldp == addr) {
389         return entry;
390       }
391     }
392     else {
393       return NULL;
394     }
395   }
396 }
397
398 static void oldnewmap_clear_map(OldNewMap *onm)
399 {
400   memset(onm->map, 0xFF, MAP_CAPACITY(onm) * sizeof(*onm->map));
401 }
402
403 static void oldnewmap_increase_size(OldNewMap *onm)
404 {
405   onm->capacity_exp++;
406   onm->entries = MEM_reallocN(onm->entries, sizeof(*onm->entries) * ENTRIES_CAPACITY(onm));
407   onm->map = MEM_reallocN(onm->map, sizeof(*onm->map) * MAP_CAPACITY(onm));
408   oldnewmap_clear_map(onm);
409   for (int i = 0; i < onm->nentries; i++) {
410     oldnewmap_insert_index_in_map(onm, onm->entries[i].oldp, i);
411   }
412 }
413
414 /* Public OldNewMap API */
415
416 static OldNewMap *oldnewmap_new(void)
417 {
418   OldNewMap *onm = MEM_callocN(sizeof(*onm), "OldNewMap");
419
420   onm->capacity_exp = DEFAULT_SIZE_EXP;
421   onm->entries = MEM_malloc_arrayN(
422       ENTRIES_CAPACITY(onm), sizeof(*onm->entries), "OldNewMap.entries");
423   onm->map = MEM_malloc_arrayN(MAP_CAPACITY(onm), sizeof(*onm->map), "OldNewMap.map");
424   oldnewmap_clear_map(onm);
425
426   return onm;
427 }
428
429 static void oldnewmap_insert(OldNewMap *onm, const void *oldaddr, void *newaddr, int nr)
430 {
431   if (oldaddr == NULL || newaddr == NULL) {
432     return;
433   }
434
435   if (UNLIKELY(onm->nentries == ENTRIES_CAPACITY(onm))) {
436     oldnewmap_increase_size(onm);
437   }
438
439   OldNew entry;
440   entry.oldp = oldaddr;
441   entry.newp = newaddr;
442   entry.nr = nr;
443   oldnewmap_insert_or_replace(onm, entry);
444 }
445
446 void blo_do_versions_oldnewmap_insert(OldNewMap *onm, const void *oldaddr, void *newaddr, int nr)
447 {
448   oldnewmap_insert(onm, oldaddr, newaddr, nr);
449 }
450
451 static void *oldnewmap_lookup_and_inc(OldNewMap *onm, const void *addr, bool increase_users)
452 {
453   OldNew *entry = oldnewmap_lookup_entry(onm, addr);
454   if (entry == NULL) {
455     return NULL;
456   }
457   if (increase_users) {
458     entry->nr++;
459   }
460   return entry->newp;
461 }
462
463 /* for libdata, OldNew.nr has ID code, no increment */
464 static void *oldnewmap_liblookup(OldNewMap *onm, const void *addr, const void *lib)
465 {
466   if (addr == NULL) {
467     return NULL;
468   }
469
470   ID *id = oldnewmap_lookup_and_inc(onm, addr, false);
471   if (id == NULL) {
472     return NULL;
473   }
474   if (!lib || id->lib) {
475     return id;
476   }
477   return NULL;
478 }
479
480 static void oldnewmap_clear(OldNewMap *onm)
481 {
482   /* Free unused data. */
483   for (int i = 0; i < onm->nentries; i++) {
484     OldNew *entry = &onm->entries[i];
485     if (entry->nr == 0) {
486       MEM_freeN(entry->newp);
487       entry->newp = NULL;
488     }
489   }
490
491   onm->capacity_exp = DEFAULT_SIZE_EXP;
492   oldnewmap_clear_map(onm);
493   onm->nentries = 0;
494 }
495
496 static void oldnewmap_free(OldNewMap *onm)
497 {
498   MEM_freeN(onm->entries);
499   MEM_freeN(onm->map);
500   MEM_freeN(onm);
501 }
502
503 #undef ENTRIES_CAPACITY
504 #undef MAP_CAPACITY
505 #undef SLOT_MASK
506 #undef DEFAULT_SIZE_EXP
507 #undef PERTURB_SHIFT
508 #undef ITER_SLOTS
509
510 /** \} */
511
512 /* -------------------------------------------------------------------- */
513 /** \name Helper Functions
514  * \{ */
515
516 static void add_main_to_main(Main *mainvar, Main *from)
517 {
518   ListBase *lbarray[MAX_LIBARRAY], *fromarray[MAX_LIBARRAY];
519   int a;
520
521   set_listbasepointers(mainvar, lbarray);
522   a = set_listbasepointers(from, fromarray);
523   while (a--) {
524     BLI_movelisttolist(lbarray[a], fromarray[a]);
525   }
526 }
527
528 void blo_join_main(ListBase *mainlist)
529 {
530   Main *tojoin, *mainl;
531
532   mainl = mainlist->first;
533   while ((tojoin = mainl->next)) {
534     add_main_to_main(mainl, tojoin);
535     BLI_remlink(mainlist, tojoin);
536     BKE_main_free(tojoin);
537   }
538 }
539
540 static void split_libdata(ListBase *lb_src, Main **lib_main_array, const uint lib_main_array_len)
541 {
542   for (ID *id = lb_src->first, *idnext; id; id = idnext) {
543     idnext = id->next;
544
545     if (id->lib) {
546       if (((uint)id->lib->temp_index < lib_main_array_len) &&
547           /* this check should never fail, just in case 'id->lib' is a dangling pointer. */
548           (lib_main_array[id->lib->temp_index]->curlib == id->lib)) {
549         Main *mainvar = lib_main_array[id->lib->temp_index];
550         ListBase *lb_dst = which_libbase(mainvar, GS(id->name));
551         BLI_remlink(lb_src, id);
552         BLI_addtail(lb_dst, id);
553       }
554       else {
555         printf("%s: invalid library for '%s'\n", __func__, id->name);
556         BLI_assert(0);
557       }
558     }
559   }
560 }
561
562 void blo_split_main(ListBase *mainlist, Main *main)
563 {
564   mainlist->first = mainlist->last = main;
565   main->next = NULL;
566
567   if (BLI_listbase_is_empty(&main->libraries)) {
568     return;
569   }
570
571   /* (Library.temp_index -> Main), lookup table */
572   const uint lib_main_array_len = BLI_listbase_count(&main->libraries);
573   Main **lib_main_array = MEM_malloc_arrayN(lib_main_array_len, sizeof(*lib_main_array), __func__);
574
575   int i = 0;
576   for (Library *lib = main->libraries.first; lib; lib = lib->id.next, i++) {
577     Main *libmain = BKE_main_new();
578     libmain->curlib = lib;
579     libmain->versionfile = lib->versionfile;
580     libmain->subversionfile = lib->subversionfile;
581     BLI_addtail(mainlist, libmain);
582     lib->temp_index = i;
583     lib_main_array[i] = libmain;
584   }
585
586   ListBase *lbarray[MAX_LIBARRAY];
587   i = set_listbasepointers(main, lbarray);
588   while (i--) {
589     ID *id = lbarray[i]->first;
590     if (id == NULL || GS(id->name) == ID_LI) {
591       /* No ID_LI data-lock should ever be linked anyway, but just in case, better be explicit. */
592       continue;
593     }
594     split_libdata(lbarray[i], lib_main_array, lib_main_array_len);
595   }
596
597   MEM_freeN(lib_main_array);
598 }
599
600 static void read_file_version(FileData *fd, Main *main)
601 {
602   BHead *bhead;
603
604   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
605     if (bhead->code == GLOB) {
606       FileGlobal *fg = read_struct(fd, bhead, "Global");
607       if (fg) {
608         main->subversionfile = fg->subversion;
609         main->minversionfile = fg->minversion;
610         main->minsubversionfile = fg->minsubversion;
611         MEM_freeN(fg);
612       }
613       else if (bhead->code == ENDB) {
614         break;
615       }
616     }
617   }
618   if (main->curlib) {
619     main->curlib->versionfile = main->versionfile;
620     main->curlib->subversionfile = main->subversionfile;
621   }
622 }
623
624 #ifdef USE_GHASH_BHEAD
625 static void read_file_bhead_idname_map_create(FileData *fd)
626 {
627   BHead *bhead;
628
629   /* dummy values */
630   bool is_link = false;
631   int code_prev = ENDB;
632   uint reserve = 0;
633
634   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
635     if (code_prev != bhead->code) {
636       code_prev = bhead->code;
637       is_link = BKE_idtype_idcode_is_valid(code_prev) ? BKE_idtype_idcode_is_linkable(code_prev) :
638                                                         false;
639     }
640
641     if (is_link) {
642       reserve += 1;
643     }
644   }
645
646   BLI_assert(fd->bhead_idname_hash == NULL);
647
648   fd->bhead_idname_hash = BLI_ghash_str_new_ex(__func__, reserve);
649
650   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
651     if (code_prev != bhead->code) {
652       code_prev = bhead->code;
653       is_link = BKE_idtype_idcode_is_valid(code_prev) ? BKE_idtype_idcode_is_linkable(code_prev) :
654                                                         false;
655     }
656
657     if (is_link) {
658       BLI_ghash_insert(fd->bhead_idname_hash, (void *)blo_bhead_id_name(fd, bhead), bhead);
659     }
660   }
661 }
662 #endif
663
664 static Main *blo_find_main(FileData *fd, const char *filepath, const char *relabase)
665 {
666   ListBase *mainlist = fd->mainlist;
667   Main *m;
668   Library *lib;
669   char name1[FILE_MAX];
670
671   BLI_strncpy(name1, filepath, sizeof(name1));
672   BLI_path_normalize(relabase, name1);
673
674   //  printf("blo_find_main: relabase  %s\n", relabase);
675   //  printf("blo_find_main: original in  %s\n", filepath);
676   //  printf("blo_find_main: converted to %s\n", name1);
677
678   for (m = mainlist->first; m; m = m->next) {
679     const char *libname = (m->curlib) ? m->curlib->filepath_abs : m->name;
680
681     if (BLI_path_cmp(name1, libname) == 0) {
682       if (G.debug & G_DEBUG) {
683         printf("blo_find_main: found library %s\n", libname);
684       }
685       return m;
686     }
687   }
688
689   m = BKE_main_new();
690   BLI_addtail(mainlist, m);
691
692   /* Add library data-block itself to 'main' Main, since libraries are **never** linked data.
693    * Fixes bug where you could end with all ID_LI data-blocks having the same name... */
694   lib = BKE_libblock_alloc(mainlist->first, ID_LI, BLI_path_basename(filepath), 0);
695
696   /* Important, consistency with main ID reading code from read_libblock(). */
697   lib->id.us = ID_FAKE_USERS(lib);
698
699   /* Matches direct_link_library(). */
700   id_us_ensure_real(&lib->id);
701
702   BLI_strncpy(lib->filepath, filepath, sizeof(lib->filepath));
703   BLI_strncpy(lib->filepath_abs, name1, sizeof(lib->filepath_abs));
704
705   m->curlib = lib;
706
707   read_file_version(fd, m);
708
709   if (G.debug & G_DEBUG) {
710     printf("blo_find_main: added new lib %s\n", filepath);
711   }
712   return m;
713 }
714
715 /** \} */
716
717 /* -------------------------------------------------------------------- */
718 /** \name File Parsing
719  * \{ */
720
721 typedef struct BlendDataReader {
722   FileData *fd;
723 } BlendDataReader;
724
725 typedef struct BlendLibReader {
726   FileData *fd;
727   Main *main;
728 } BlendLibReader;
729
730 typedef struct BlendExpander {
731   FileData *fd;
732   Main *main;
733 } BlendExpander;
734
735 static void switch_endian_bh4(BHead4 *bhead)
736 {
737   /* the ID_.. codes */
738   if ((bhead->code & 0xFFFF) == 0) {
739     bhead->code >>= 16;
740   }
741
742   if (bhead->code != ENDB) {
743     BLI_endian_switch_int32(&bhead->len);
744     BLI_endian_switch_int32(&bhead->SDNAnr);
745     BLI_endian_switch_int32(&bhead->nr);
746   }
747 }
748
749 static void switch_endian_bh8(BHead8 *bhead)
750 {
751   /* the ID_.. codes */
752   if ((bhead->code & 0xFFFF) == 0) {
753     bhead->code >>= 16;
754   }
755
756   if (bhead->code != ENDB) {
757     BLI_endian_switch_int32(&bhead->len);
758     BLI_endian_switch_int32(&bhead->SDNAnr);
759     BLI_endian_switch_int32(&bhead->nr);
760   }
761 }
762
763 static void bh4_from_bh8(BHead *bhead, BHead8 *bhead8, int do_endian_swap)
764 {
765   BHead4 *bhead4 = (BHead4 *)bhead;
766   int64_t old;
767
768   bhead4->code = bhead8->code;
769   bhead4->len = bhead8->len;
770
771   if (bhead4->code != ENDB) {
772     /* perform a endian swap on 64bit pointers, otherwise the pointer might map to zero
773      * 0x0000000000000000000012345678 would become 0x12345678000000000000000000000000
774      */
775     if (do_endian_swap) {
776       BLI_endian_switch_int64(&bhead8->old);
777     }
778
779     /* this patch is to avoid a long long being read from not-eight aligned positions
780      * is necessary on any modern 64bit architecture) */
781     memcpy(&old, &bhead8->old, 8);
782     bhead4->old = (int)(old >> 3);
783
784     bhead4->SDNAnr = bhead8->SDNAnr;
785     bhead4->nr = bhead8->nr;
786   }
787 }
788
789 static void bh8_from_bh4(BHead *bhead, BHead4 *bhead4)
790 {
791   BHead8 *bhead8 = (BHead8 *)bhead;
792
793   bhead8->code = bhead4->code;
794   bhead8->len = bhead4->len;
795
796   if (bhead8->code != ENDB) {
797     bhead8->old = bhead4->old;
798     bhead8->SDNAnr = bhead4->SDNAnr;
799     bhead8->nr = bhead4->nr;
800   }
801 }
802
803 static BHeadN *get_bhead(FileData *fd)
804 {
805   BHeadN *new_bhead = NULL;
806   int readsize;
807
808   if (fd) {
809     if (!fd->is_eof) {
810       /* initializing to zero isn't strictly needed but shuts valgrind up
811        * since uninitialized memory gets compared */
812       BHead8 bhead8 = {0};
813       BHead4 bhead4 = {0};
814       BHead bhead = {0};
815
816       /* First read the bhead structure.
817        * Depending on the platform the file was written on this can
818        * be a big or little endian BHead4 or BHead8 structure.
819        *
820        * As usual 'ENDB' (the last *partial* bhead of the file)
821        * needs some special handling. We don't want to EOF just yet.
822        */
823       if (fd->flags & FD_FLAGS_FILE_POINTSIZE_IS_4) {
824         bhead4.code = DATA;
825         readsize = fd->read(fd, &bhead4, sizeof(bhead4), NULL);
826
827         if (readsize == sizeof(bhead4) || bhead4.code == ENDB) {
828           if (fd->flags & FD_FLAGS_SWITCH_ENDIAN) {
829             switch_endian_bh4(&bhead4);
830           }
831
832           if (fd->flags & FD_FLAGS_POINTSIZE_DIFFERS) {
833             bh8_from_bh4(&bhead, &bhead4);
834           }
835           else {
836             /* MIN2 is only to quiet '-Warray-bounds' compiler warning. */
837             BLI_assert(sizeof(bhead) == sizeof(bhead4));
838             memcpy(&bhead, &bhead4, MIN2(sizeof(bhead), sizeof(bhead4)));
839           }
840         }
841         else {
842           fd->is_eof = true;
843           bhead.len = 0;
844         }
845       }
846       else {
847         bhead8.code = DATA;
848         readsize = fd->read(fd, &bhead8, sizeof(bhead8), NULL);
849
850         if (readsize == sizeof(bhead8) || bhead8.code == ENDB) {
851           if (fd->flags & FD_FLAGS_SWITCH_ENDIAN) {
852             switch_endian_bh8(&bhead8);
853           }
854
855           if (fd->flags & FD_FLAGS_POINTSIZE_DIFFERS) {
856             bh4_from_bh8(&bhead, &bhead8, (fd->flags & FD_FLAGS_SWITCH_ENDIAN));
857           }
858           else {
859             /* MIN2 is only to quiet '-Warray-bounds' compiler warning. */
860             BLI_assert(sizeof(bhead) == sizeof(bhead8));
861             memcpy(&bhead, &bhead8, MIN2(sizeof(bhead), sizeof(bhead8)));
862           }
863         }
864         else {
865           fd->is_eof = true;
866           bhead.len = 0;
867         }
868       }
869
870       /* make sure people are not trying to pass bad blend files */
871       if (bhead.len < 0) {
872         fd->is_eof = true;
873       }
874
875       /* bhead now contains the (converted) bhead structure. Now read
876        * the associated data and put everything in a BHeadN (creative naming !)
877        */
878       if (fd->is_eof) {
879         /* pass */
880       }
881 #ifdef USE_BHEAD_READ_ON_DEMAND
882       else if (fd->seek != NULL && BHEAD_USE_READ_ON_DEMAND(&bhead)) {
883         /* Delay reading bhead content. */
884         new_bhead = MEM_mallocN(sizeof(BHeadN), "new_bhead");
885         if (new_bhead) {
886           new_bhead->next = new_bhead->prev = NULL;
887           new_bhead->file_offset = fd->file_offset;
888           new_bhead->has_data = false;
889           new_bhead->is_memchunk_identical = false;
890           new_bhead->bhead = bhead;
891           off64_t seek_new = fd->seek(fd, bhead.len, SEEK_CUR);
892           if (seek_new == -1) {
893             fd->is_eof = true;
894             MEM_freeN(new_bhead);
895             new_bhead = NULL;
896           }
897           BLI_assert(fd->file_offset == seek_new);
898         }
899         else {
900           fd->is_eof = true;
901         }
902       }
903 #endif
904       else {
905         new_bhead = MEM_mallocN(sizeof(BHeadN) + bhead.len, "new_bhead");
906         if (new_bhead) {
907           new_bhead->next = new_bhead->prev = NULL;
908 #ifdef USE_BHEAD_READ_ON_DEMAND
909           new_bhead->file_offset = 0; /* don't seek. */
910           new_bhead->has_data = true;
911 #endif
912           new_bhead->is_memchunk_identical = false;
913           new_bhead->bhead = bhead;
914
915           readsize = fd->read(fd, new_bhead + 1, bhead.len, &new_bhead->is_memchunk_identical);
916
917           if (readsize != bhead.len) {
918             fd->is_eof = true;
919             MEM_freeN(new_bhead);
920             new_bhead = NULL;
921           }
922         }
923         else {
924           fd->is_eof = true;
925         }
926       }
927     }
928   }
929
930   /* We've read a new block. Now add it to the list
931    * of blocks.
932    */
933   if (new_bhead) {
934     BLI_addtail(&fd->bhead_list, new_bhead);
935   }
936
937   return new_bhead;
938 }
939
940 BHead *blo_bhead_first(FileData *fd)
941 {
942   BHeadN *new_bhead;
943   BHead *bhead = NULL;
944
945   /* Rewind the file
946    * Read in a new block if necessary
947    */
948   new_bhead = fd->bhead_list.first;
949   if (new_bhead == NULL) {
950     new_bhead = get_bhead(fd);
951   }
952
953   if (new_bhead) {
954     bhead = &new_bhead->bhead;
955   }
956
957   return bhead;
958 }
959
960 BHead *blo_bhead_prev(FileData *UNUSED(fd), BHead *thisblock)
961 {
962   BHeadN *bheadn = BHEADN_FROM_BHEAD(thisblock);
963   BHeadN *prev = bheadn->prev;
964
965   return (prev) ? &prev->bhead : NULL;
966 }
967
968 BHead *blo_bhead_next(FileData *fd, BHead *thisblock)
969 {
970   BHeadN *new_bhead = NULL;
971   BHead *bhead = NULL;
972
973   if (thisblock) {
974     /* bhead is actually a sub part of BHeadN
975      * We calculate the BHeadN pointer from the BHead pointer below */
976     new_bhead = BHEADN_FROM_BHEAD(thisblock);
977
978     /* get the next BHeadN. If it doesn't exist we read in the next one */
979     new_bhead = new_bhead->next;
980     if (new_bhead == NULL) {
981       new_bhead = get_bhead(fd);
982     }
983   }
984
985   if (new_bhead) {
986     /* here we do the reverse:
987      * go from the BHeadN pointer to the BHead pointer */
988     bhead = &new_bhead->bhead;
989   }
990
991   return bhead;
992 }
993
994 #ifdef USE_BHEAD_READ_ON_DEMAND
995 static bool blo_bhead_read_data(FileData *fd, BHead *thisblock, void *buf)
996 {
997   bool success = true;
998   BHeadN *new_bhead = BHEADN_FROM_BHEAD(thisblock);
999   BLI_assert(new_bhead->has_data == false && new_bhead->file_offset != 0);
1000   off64_t offset_backup = fd->file_offset;
1001   if (UNLIKELY(fd->seek(fd, new_bhead->file_offset, SEEK_SET) == -1)) {
1002     success = false;
1003   }
1004   else {
1005     if (fd->read(fd, buf, new_bhead->bhead.len, &new_bhead->is_memchunk_identical) !=
1006         new_bhead->bhead.len) {
1007       success = false;
1008     }
1009   }
1010   if (fd->seek(fd, offset_backup, SEEK_SET) == -1) {
1011     success = false;
1012   }
1013   return success;
1014 }
1015
1016 static BHead *blo_bhead_read_full(FileData *fd, BHead *thisblock)
1017 {
1018   BHeadN *new_bhead = BHEADN_FROM_BHEAD(thisblock);
1019   BHeadN *new_bhead_data = MEM_mallocN(sizeof(BHeadN) + new_bhead->bhead.len, "new_bhead");
1020   new_bhead_data->bhead = new_bhead->bhead;
1021   new_bhead_data->file_offset = new_bhead->file_offset;
1022   new_bhead_data->has_data = true;
1023   new_bhead_data->is_memchunk_identical = false;
1024   if (!blo_bhead_read_data(fd, thisblock, new_bhead_data + 1)) {
1025     MEM_freeN(new_bhead_data);
1026     return NULL;
1027   }
1028   return &new_bhead_data->bhead;
1029 }
1030 #endif /* USE_BHEAD_READ_ON_DEMAND */
1031
1032 /* Warning! Caller's responsibility to ensure given bhead **is** and ID one! */
1033 const char *blo_bhead_id_name(const FileData *fd, const BHead *bhead)
1034 {
1035   return (const char *)POINTER_OFFSET(bhead, sizeof(*bhead) + fd->id_name_offs);
1036 }
1037
1038 static void decode_blender_header(FileData *fd)
1039 {
1040   char header[SIZEOFBLENDERHEADER], num[4];
1041   int readsize;
1042
1043   /* read in the header data */
1044   readsize = fd->read(fd, header, sizeof(header), NULL);
1045
1046   if (readsize == sizeof(header) && STREQLEN(header, "BLENDER", 7) && ELEM(header[7], '_', '-') &&
1047       ELEM(header[8], 'v', 'V') &&
1048       (isdigit(header[9]) && isdigit(header[10]) && isdigit(header[11]))) {
1049     fd->flags |= FD_FLAGS_FILE_OK;
1050
1051     /* what size are pointers in the file ? */
1052     if (header[7] == '_') {
1053       fd->flags |= FD_FLAGS_FILE_POINTSIZE_IS_4;
1054       if (sizeof(void *) != 4) {
1055         fd->flags |= FD_FLAGS_POINTSIZE_DIFFERS;
1056       }
1057     }
1058     else {
1059       if (sizeof(void *) != 8) {
1060         fd->flags |= FD_FLAGS_POINTSIZE_DIFFERS;
1061       }
1062     }
1063
1064     /* is the file saved in a different endian
1065      * than we need ?
1066      */
1067     if (((header[8] == 'v') ? L_ENDIAN : B_ENDIAN) != ENDIAN_ORDER) {
1068       fd->flags |= FD_FLAGS_SWITCH_ENDIAN;
1069     }
1070
1071     /* get the version number */
1072     memcpy(num, header + 9, 3);
1073     num[3] = 0;
1074     fd->fileversion = atoi(num);
1075   }
1076 }
1077
1078 /**
1079  * \return Success if the file is read correctly, else set \a r_error_message.
1080  */
1081 static bool read_file_dna(FileData *fd, const char **r_error_message)
1082 {
1083   BHead *bhead;
1084   int subversion = 0;
1085
1086   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
1087     if (bhead->code == GLOB) {
1088       /* Before this, the subversion didn't exist in 'FileGlobal' so the subversion
1089        * value isn't accessible for the purpose of DNA versioning in this case. */
1090       if (fd->fileversion <= 242) {
1091         continue;
1092       }
1093       /* We can't use read_global because this needs 'DNA1' to be decoded,
1094        * however the first 4 chars are _always_ the subversion. */
1095       FileGlobal *fg = (void *)&bhead[1];
1096       BLI_STATIC_ASSERT(offsetof(FileGlobal, subvstr) == 0, "Must be first: subvstr")
1097       char num[5];
1098       memcpy(num, fg->subvstr, 4);
1099       num[4] = 0;
1100       subversion = atoi(num);
1101     }
1102     else if (bhead->code == DNA1) {
1103       const bool do_endian_swap = (fd->flags & FD_FLAGS_SWITCH_ENDIAN) != 0;
1104
1105       fd->filesdna = DNA_sdna_from_data(
1106           &bhead[1], bhead->len, do_endian_swap, true, r_error_message);
1107       if (fd->filesdna) {
1108         blo_do_versions_dna(fd->filesdna, fd->fileversion, subversion);
1109         fd->compflags = DNA_struct_get_compareflags(fd->filesdna, fd->memsdna);
1110         /* used to retrieve ID names from (bhead+1) */
1111         fd->id_name_offs = DNA_elem_offset(fd->filesdna, "ID", "char", "name[]");
1112
1113         return true;
1114       }
1115
1116       return false;
1117     }
1118     else if (bhead->code == ENDB) {
1119       break;
1120     }
1121   }
1122
1123   *r_error_message = "Missing DNA block";
1124   return false;
1125 }
1126
1127 static int *read_file_thumbnail(FileData *fd)
1128 {
1129   BHead *bhead;
1130   int *blend_thumb = NULL;
1131
1132   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
1133     if (bhead->code == TEST) {
1134       const bool do_endian_swap = (fd->flags & FD_FLAGS_SWITCH_ENDIAN) != 0;
1135       int *data = (int *)(bhead + 1);
1136
1137       if (bhead->len < (sizeof(int[2]))) {
1138         break;
1139       }
1140
1141       if (do_endian_swap) {
1142         BLI_endian_switch_int32(&data[0]);
1143         BLI_endian_switch_int32(&data[1]);
1144       }
1145
1146       const int width = data[0];
1147       const int height = data[1];
1148       if (!BLEN_THUMB_MEMSIZE_IS_VALID(width, height)) {
1149         break;
1150       }
1151       if (bhead->len < BLEN_THUMB_MEMSIZE_FILE(width, height)) {
1152         break;
1153       }
1154
1155       blend_thumb = data;
1156       break;
1157     }
1158     if (bhead->code != REND) {
1159       /* Thumbnail is stored in TEST immediately after first REND... */
1160       break;
1161     }
1162   }
1163
1164   return blend_thumb;
1165 }
1166
1167 /** \} */
1168
1169 /* -------------------------------------------------------------------- */
1170 /** \name File Data API
1171  * \{ */
1172
1173 /* Regular file reading. */
1174
1175 static int fd_read_data_from_file(FileData *filedata,
1176                                   void *buffer,
1177                                   uint size,
1178                                   bool *UNUSED(r_is_memchunck_identical))
1179 {
1180   int readsize = read(filedata->filedes, buffer, size);
1181
1182   if (readsize < 0) {
1183     readsize = EOF;
1184   }
1185   else {
1186     filedata->file_offset += readsize;
1187   }
1188
1189   return readsize;
1190 }
1191
1192 static off64_t fd_seek_data_from_file(FileData *filedata, off64_t offset, int whence)
1193 {
1194   filedata->file_offset = BLI_lseek(filedata->filedes, offset, whence);
1195   return filedata->file_offset;
1196 }
1197
1198 /* GZip file reading. */
1199
1200 static int fd_read_gzip_from_file(FileData *filedata,
1201                                   void *buffer,
1202                                   uint size,
1203                                   bool *UNUSED(r_is_memchunck_identical))
1204 {
1205   int readsize = gzread(filedata->gzfiledes, buffer, size);
1206
1207   if (readsize < 0) {
1208     readsize = EOF;
1209   }
1210   else {
1211     filedata->file_offset += readsize;
1212   }
1213
1214   return readsize;
1215 }
1216
1217 /* Memory reading. */
1218
1219 static int fd_read_from_memory(FileData *filedata,
1220                                void *buffer,
1221                                uint size,
1222                                bool *UNUSED(r_is_memchunck_identical))
1223 {
1224   /* don't read more bytes then there are available in the buffer */
1225   int readsize = (int)MIN2(size, (uint)(filedata->buffersize - filedata->file_offset));
1226
1227   memcpy(buffer, filedata->buffer + filedata->file_offset, readsize);
1228   filedata->file_offset += readsize;
1229
1230   return readsize;
1231 }
1232
1233 /* MemFile reading. */
1234
1235 static int fd_read_from_memfile(FileData *filedata,
1236                                 void *buffer,
1237                                 uint size,
1238                                 bool *r_is_memchunck_identical)
1239 {
1240   static size_t seek = SIZE_MAX; /* the current position */
1241   static size_t offset = 0;      /* size of previous chunks */
1242   static MemFileChunk *chunk = NULL;
1243   size_t chunkoffset, readsize, totread;
1244
1245   if (r_is_memchunck_identical != NULL) {
1246     *r_is_memchunck_identical = true;
1247   }
1248
1249   if (size == 0) {
1250     return 0;
1251   }
1252
1253   if (seek != (size_t)filedata->file_offset) {
1254     chunk = filedata->memfile->chunks.first;
1255     seek = 0;
1256
1257     while (chunk) {
1258       if (seek + chunk->size > (size_t)filedata->file_offset) {
1259         break;
1260       }
1261       seek += chunk->size;
1262       chunk = chunk->next;
1263     }
1264     offset = seek;
1265     seek = filedata->file_offset;
1266   }
1267
1268   if (chunk) {
1269     totread = 0;
1270
1271     do {
1272       /* first check if it's on the end if current chunk */
1273       if (seek - offset == chunk->size) {
1274         offset += chunk->size;
1275         chunk = chunk->next;
1276       }
1277
1278       /* debug, should never happen */
1279       if (chunk == NULL) {
1280         printf("illegal read, chunk zero\n");
1281         return 0;
1282       }
1283
1284       chunkoffset = seek - offset;
1285       readsize = size - totread;
1286
1287       /* data can be spread over multiple chunks, so clamp size
1288        * to within this chunk, and then it will read further in
1289        * the next chunk */
1290       if (chunkoffset + readsize > chunk->size) {
1291         readsize = chunk->size - chunkoffset;
1292       }
1293
1294       memcpy(POINTER_OFFSET(buffer, totread), chunk->buf + chunkoffset, readsize);
1295       totread += readsize;
1296       filedata->file_offset += readsize;
1297       seek += readsize;
1298       if (r_is_memchunck_identical != NULL) {
1299         /* `is_identical` of current chunk represents whether it changed compared to previous undo
1300          * step. this is fine in redo case (filedata->undo_direction > 0), but not in undo case,
1301          * where we need an extra flag defined when saving the next (future) step after the one we
1302          * want to restore, as we are supposed to 'come from' that future undo step, and not the
1303          * one before current one. */
1304         *r_is_memchunck_identical &= filedata->undo_direction > 0 ? chunk->is_identical :
1305                                                                     chunk->is_identical_future;
1306       }
1307     } while (totread < size);
1308
1309     return totread;
1310   }
1311
1312   return 0;
1313 }
1314
1315 static FileData *filedata_new(void)
1316 {
1317   FileData *fd = MEM_callocN(sizeof(FileData), "FileData");
1318
1319   fd->filedes = -1;
1320   fd->gzfiledes = NULL;
1321
1322   fd->memsdna = DNA_sdna_current_get();
1323
1324   fd->datamap = oldnewmap_new();
1325   fd->globmap = oldnewmap_new();
1326   fd->libmap = oldnewmap_new();
1327
1328   return fd;
1329 }
1330
1331 static FileData *blo_decode_and_check(FileData *fd, ReportList *reports)
1332 {
1333   decode_blender_header(fd);
1334
1335   if (fd->flags & FD_FLAGS_FILE_OK) {
1336     const char *error_message = NULL;
1337     if (read_file_dna(fd, &error_message) == false) {
1338       BKE_reportf(
1339           reports, RPT_ERROR, "Failed to read blend file '%s': %s", fd->relabase, error_message);
1340       blo_filedata_free(fd);
1341       fd = NULL;
1342     }
1343   }
1344   else {
1345     BKE_reportf(
1346         reports, RPT_ERROR, "Failed to read blend file '%s', not a blend file", fd->relabase);
1347     blo_filedata_free(fd);
1348     fd = NULL;
1349   }
1350
1351   return fd;
1352 }
1353
1354 static FileData *blo_filedata_from_file_descriptor(const char *filepath,
1355                                                    ReportList *reports,
1356                                                    int file)
1357 {
1358   FileDataReadFn *read_fn = NULL;
1359   FileDataSeekFn *seek_fn = NULL; /* Optional. */
1360
1361   gzFile gzfile = (gzFile)Z_NULL;
1362
1363   char header[7];
1364
1365   /* Regular file. */
1366   errno = 0;
1367   if (read(file, header, sizeof(header)) != sizeof(header)) {
1368     BKE_reportf(reports,
1369                 RPT_WARNING,
1370                 "Unable to read '%s': %s",
1371                 filepath,
1372                 errno ? strerror(errno) : TIP_("insufficient content"));
1373     return NULL;
1374   }
1375
1376   BLI_lseek(file, 0, SEEK_SET);
1377
1378   /* Regular file. */
1379   if (memcmp(header, "BLENDER", sizeof(header)) == 0) {
1380     read_fn = fd_read_data_from_file;
1381     seek_fn = fd_seek_data_from_file;
1382   }
1383
1384   /* Gzip file. */
1385   errno = 0;
1386   if ((read_fn == NULL) &&
1387       /* Check header magic. */
1388       (header[0] == 0x1f && header[1] == 0x8b)) {
1389     gzfile = BLI_gzopen(filepath, "rb");
1390     if (gzfile == (gzFile)Z_NULL) {
1391       BKE_reportf(reports,
1392                   RPT_WARNING,
1393                   "Unable to open '%s': %s",
1394                   filepath,
1395                   errno ? strerror(errno) : TIP_("unknown error reading file"));
1396       return NULL;
1397     }
1398
1399     /* 'seek_fn' is too slow for gzip, don't set it. */
1400     read_fn = fd_read_gzip_from_file;
1401     /* Caller must close. */
1402     file = -1;
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   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
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 FileData *blo_filedata_from_memfile(MemFile *memfile,
1545                                     const struct BlendFileReadParams *params,
1546                                     ReportList *reports)
1547 {
1548   if (!memfile) {
1549     BKE_report(reports, RPT_WARNING, "Unable to open blend <memory>");
1550     return NULL;
1551   }
1552
1553   FileData *fd = filedata_new();
1554   fd->memfile = memfile;
1555   fd->undo_direction = params->undo_direction;
1556
1557   fd->read = fd_read_from_memfile;
1558   fd->flags |= FD_FLAGS_NOT_MY_BUFFER;
1559
1560   return blo_decode_and_check(fd, reports);
1561 }
1562
1563 void blo_filedata_free(FileData *fd)
1564 {
1565   if (fd) {
1566     if (fd->filedes != -1) {
1567       close(fd->filedes);
1568     }
1569
1570     if (fd->gzfiledes != NULL) {
1571       gzclose(fd->gzfiledes);
1572     }
1573
1574     if (fd->strm.next_in) {
1575       if (inflateEnd(&fd->strm) != Z_OK) {
1576         printf("close gzip stream error\n");
1577       }
1578     }
1579
1580     if (fd->buffer && !(fd->flags & FD_FLAGS_NOT_MY_BUFFER)) {
1581       MEM_freeN((void *)fd->buffer);
1582       fd->buffer = NULL;
1583     }
1584
1585     /* Free all BHeadN data blocks */
1586 #ifndef NDEBUG
1587     BLI_freelistN(&fd->bhead_list);
1588 #else
1589     /* Sanity check we're not keeping memory we don't need. */
1590     LISTBASE_FOREACH_MUTABLE (BHeadN *, new_bhead, &fd->bhead_list) {
1591       if (fd->seek != NULL && BHEAD_USE_READ_ON_DEMAND(&new_bhead->bhead)) {
1592         BLI_assert(new_bhead->has_data == 0);
1593       }
1594       MEM_freeN(new_bhead);
1595     }
1596 #endif
1597
1598     if (fd->filesdna) {
1599       DNA_sdna_free(fd->filesdna);
1600     }
1601     if (fd->compflags) {
1602       MEM_freeN((void *)fd->compflags);
1603     }
1604
1605     if (fd->datamap) {
1606       oldnewmap_free(fd->datamap);
1607     }
1608     if (fd->globmap) {
1609       oldnewmap_free(fd->globmap);
1610     }
1611     if (fd->packedmap) {
1612       oldnewmap_free(fd->packedmap);
1613     }
1614     if (fd->libmap && !(fd->flags & FD_FLAGS_NOT_MY_LIBMAP)) {
1615       oldnewmap_free(fd->libmap);
1616     }
1617     if (fd->old_idmap != NULL) {
1618       BKE_main_idmap_destroy(fd->old_idmap);
1619     }
1620     blo_cache_storage_end(fd);
1621     if (fd->bheadmap) {
1622       MEM_freeN(fd->bheadmap);
1623     }
1624
1625 #ifdef USE_GHASH_BHEAD
1626     if (fd->bhead_idname_hash) {
1627       BLI_ghash_free(fd->bhead_idname_hash, NULL, NULL);
1628     }
1629 #endif
1630
1631     MEM_freeN(fd);
1632   }
1633 }
1634
1635 /** \} */
1636
1637 /* -------------------------------------------------------------------- */
1638 /** \name Public Utilities
1639  * \{ */
1640
1641 /**
1642  * Check whether given path ends with a blend file compatible extension
1643  * (`.blend`, `.ble` or `.blend.gz`).
1644  *
1645  * \param str: The path to check.
1646  * \return true is this path ends with a blender file extension.
1647  */
1648 bool BLO_has_bfile_extension(const char *str)
1649 {
1650   const char *ext_test[4] = {".blend", ".ble", ".blend.gz", NULL};
1651   return BLI_path_extension_check_array(str, ext_test);
1652 }
1653
1654 /**
1655  * Try to explode given path into its 'library components'
1656  * (i.e. a .blend file, id type/group, and data-block itself).
1657  *
1658  * \param path: the full path to explode.
1659  * \param r_dir: the string that'll contain path up to blend file itself ('library' path).
1660  * WARNING! Must be #FILE_MAX_LIBEXTRA long (it also stores group and name strings)!
1661  * \param r_group: the string that'll contain 'group' part of the path, if any. May be NULL.
1662  * \param r_name: the string that'll contain data's name part of the path, if any. May be NULL.
1663  * \return true if path contains a blend file.
1664  */
1665 bool BLO_library_path_explode(const char *path, char *r_dir, char **r_group, char **r_name)
1666 {
1667   /* We might get some data names with slashes,
1668    * so we have to go up in path until we find blend file itself,
1669    * then we now next path item is group, and everything else is data name. */
1670   char *slash = NULL, *prev_slash = NULL, c = '\0';
1671
1672   r_dir[0] = '\0';
1673   if (r_group) {
1674     *r_group = NULL;
1675   }
1676   if (r_name) {
1677     *r_name = NULL;
1678   }
1679
1680   /* if path leads to an existing directory, we can be sure we're not (in) a library */
1681   if (BLI_is_dir(path)) {
1682     return false;
1683   }
1684
1685   strcpy(r_dir, path);
1686
1687   while ((slash = (char *)BLI_path_slash_rfind(r_dir))) {
1688     char tc = *slash;
1689     *slash = '\0';
1690     if (BLO_has_bfile_extension(r_dir) && BLI_is_file(r_dir)) {
1691       break;
1692     }
1693     if (STREQ(r_dir, BLO_EMBEDDED_STARTUP_BLEND)) {
1694       break;
1695     }
1696
1697     if (prev_slash) {
1698       *prev_slash = c;
1699     }
1700     prev_slash = slash;
1701     c = tc;
1702   }
1703
1704   if (!slash) {
1705     return false;
1706   }
1707
1708   if (slash[1] != '\0') {
1709     BLI_assert(strlen(slash + 1) < BLO_GROUP_MAX);
1710     if (r_group) {
1711       *r_group = slash + 1;
1712     }
1713   }
1714
1715   if (prev_slash && (prev_slash[1] != '\0')) {
1716     BLI_assert(strlen(prev_slash + 1) < MAX_ID_NAME - 2);
1717     if (r_name) {
1718       *r_name = prev_slash + 1;
1719     }
1720   }
1721
1722   return true;
1723 }
1724
1725 /**
1726  * Does a very light reading of given .blend file to extract its stored thumbnail.
1727  *
1728  * \param filepath: The path of the file to extract thumbnail from.
1729  * \return The raw thumbnail
1730  * (MEM-allocated, as stored in file, use #BKE_main_thumbnail_to_imbuf()
1731  * to convert it to ImBuf image).
1732  */
1733 BlendThumbnail *BLO_thumbnail_from_file(const char *filepath)
1734 {
1735   FileData *fd;
1736   BlendThumbnail *data = NULL;
1737   int *fd_data;
1738
1739   fd = blo_filedata_from_file_minimal(filepath);
1740   fd_data = fd ? read_file_thumbnail(fd) : NULL;
1741
1742   if (fd_data) {
1743     const int width = fd_data[0];
1744     const int height = fd_data[1];
1745     if (BLEN_THUMB_MEMSIZE_IS_VALID(width, height)) {
1746       const size_t sz = BLEN_THUMB_MEMSIZE(width, height);
1747       data = MEM_mallocN(sz, __func__);
1748       if (data) {
1749         BLI_assert((sz - sizeof(*data)) ==
1750                    (BLEN_THUMB_MEMSIZE_FILE(width, height) - (sizeof(*fd_data) * 2)));
1751         data->width = width;
1752         data->height = height;
1753         memcpy(data->rect, &fd_data[2], sz - sizeof(*data));
1754       }
1755     }
1756   }
1757
1758   blo_filedata_free(fd);
1759
1760   return data;
1761 }
1762
1763 /** \} */
1764
1765 /* -------------------------------------------------------------------- */
1766 /** \name Old/New Pointer Map
1767  * \{ */
1768
1769 /* only direct databocks */
1770 static void *newdataadr(FileData *fd, const void *adr)
1771 {
1772   return oldnewmap_lookup_and_inc(fd->datamap, adr, true);
1773 }
1774
1775 /* only direct databocks */
1776 static void *newdataadr_no_us(FileData *fd, const void *adr)
1777 {
1778   return oldnewmap_lookup_and_inc(fd->datamap, adr, false);
1779 }
1780
1781 /* direct datablocks with global linking */
1782 static void *newglobadr(FileData *fd, const void *adr)
1783 {
1784   return oldnewmap_lookup_and_inc(fd->globmap, adr, true);
1785 }
1786
1787 /* used to restore packed data after undo */
1788 static void *newpackedadr(FileData *fd, const void *adr)
1789 {
1790   if (fd->packedmap && adr) {
1791     return oldnewmap_lookup_and_inc(fd->packedmap, adr, true);
1792   }
1793
1794   return oldnewmap_lookup_and_inc(fd->datamap, adr, true);
1795 }
1796
1797 /* only lib data */
1798 static void *newlibadr(FileData *fd, const void *lib, const void *adr)
1799 {
1800   return oldnewmap_liblookup(fd->libmap, adr, lib);
1801 }
1802
1803 /* only lib data */
1804 void *blo_do_versions_newlibadr(FileData *fd, const void *lib, const void *adr)
1805 {
1806   return newlibadr(fd, lib, adr);
1807 }
1808
1809 /* increases user number */
1810 static void change_link_placeholder_to_real_ID_pointer_fd(FileData *fd, const void *old, void *new)
1811 {
1812   for (int i = 0; i < fd->libmap->nentries; i++) {
1813     OldNew *entry = &fd->libmap->entries[i];
1814
1815     if (old == entry->newp && entry->nr == ID_LINK_PLACEHOLDER) {
1816       entry->newp = new;
1817       if (new) {
1818         entry->nr = GS(((ID *)new)->name);
1819       }
1820     }
1821   }
1822 }
1823
1824 static void change_link_placeholder_to_real_ID_pointer(ListBase *mainlist,
1825                                                        FileData *basefd,
1826                                                        void *old,
1827                                                        void *new)
1828 {
1829   Main *mainptr;
1830
1831   for (mainptr = mainlist->first; mainptr; mainptr = mainptr->next) {
1832     FileData *fd;
1833
1834     if (mainptr->curlib) {
1835       fd = mainptr->curlib->filedata;
1836     }
1837     else {
1838       fd = basefd;
1839     }
1840
1841     if (fd) {
1842       change_link_placeholder_to_real_ID_pointer_fd(fd, old, new);
1843     }
1844   }
1845 }
1846
1847 /* lib linked proxy objects point to our local data, we need
1848  * to clear that pointer before reading the undo memfile since
1849  * the object might be removed, it is set again in reading
1850  * if the local object still exists.
1851  * This is only valid for local proxy objects though, linked ones should not be affected here.
1852  */
1853 void blo_clear_proxy_pointers_from_lib(Main *oldmain)
1854 {
1855   Object *ob = oldmain->objects.first;
1856
1857   for (; ob; ob = ob->id.next) {
1858     if (ob->id.lib != NULL && ob->proxy_from != NULL && ob->proxy_from->id.lib == NULL) {
1859       ob->proxy_from = NULL;
1860     }
1861   }
1862 }
1863
1864 /* XXX disabled this feature - packed files also belong in temp saves and quit.blend,
1865  * to make restore work. */
1866
1867 static void insert_packedmap(FileData *fd, PackedFile *pf)
1868 {
1869   oldnewmap_insert(fd->packedmap, pf, pf, 0);
1870   oldnewmap_insert(fd->packedmap, pf->data, pf->data, 0);
1871 }
1872
1873 void blo_make_packed_pointer_map(FileData *fd, Main *oldmain)
1874 {
1875   Image *ima;
1876   VFont *vfont;
1877   bSound *sound;
1878   Volume *volume;
1879   Library *lib;
1880
1881   fd->packedmap = oldnewmap_new();
1882
1883   for (ima = oldmain->images.first; ima; ima = ima->id.next) {
1884     ImagePackedFile *imapf;
1885
1886     if (ima->packedfile) {
1887       insert_packedmap(fd, ima->packedfile);
1888     }
1889
1890     for (imapf = ima->packedfiles.first; imapf; imapf = imapf->next) {
1891       if (imapf->packedfile) {
1892         insert_packedmap(fd, imapf->packedfile);
1893       }
1894     }
1895   }
1896
1897   for (vfont = oldmain->fonts.first; vfont; vfont = vfont->id.next) {
1898     if (vfont->packedfile) {
1899       insert_packedmap(fd, vfont->packedfile);
1900     }
1901   }
1902
1903   for (sound = oldmain->sounds.first; sound; sound = sound->id.next) {
1904     if (sound->packedfile) {
1905       insert_packedmap(fd, sound->packedfile);
1906     }
1907   }
1908
1909   for (volume = oldmain->volumes.first; volume; volume = volume->id.next) {
1910     if (volume->packedfile) {
1911       insert_packedmap(fd, volume->packedfile);
1912     }
1913   }
1914
1915   for (lib = oldmain->libraries.first; lib; lib = lib->id.next) {
1916     if (lib->packedfile) {
1917       insert_packedmap(fd, lib->packedfile);
1918     }
1919   }
1920 }
1921
1922 /* set old main packed data to zero if it has been restored */
1923 /* this works because freeing old main only happens after this call */
1924 void blo_end_packed_pointer_map(FileData *fd, Main *oldmain)
1925 {
1926   Image *ima;
1927   VFont *vfont;
1928   bSound *sound;
1929   Volume *volume;
1930   Library *lib;
1931   OldNew *entry = fd->packedmap->entries;
1932   int i;
1933
1934   /* used entries were restored, so we put them to zero */
1935   for (i = 0; i < fd->packedmap->nentries; i++, entry++) {
1936     if (entry->nr > 0) {
1937       entry->newp = NULL;
1938     }
1939   }
1940
1941   for (ima = oldmain->images.first; ima; ima = ima->id.next) {
1942     ImagePackedFile *imapf;
1943
1944     ima->packedfile = newpackedadr(fd, ima->packedfile);
1945
1946     for (imapf = ima->packedfiles.first; imapf; imapf = imapf->next) {
1947       imapf->packedfile = newpackedadr(fd, imapf->packedfile);
1948     }
1949   }
1950
1951   for (vfont = oldmain->fonts.first; vfont; vfont = vfont->id.next) {
1952     vfont->packedfile = newpackedadr(fd, vfont->packedfile);
1953   }
1954
1955   for (sound = oldmain->sounds.first; sound; sound = sound->id.next) {
1956     sound->packedfile = newpackedadr(fd, sound->packedfile);
1957   }
1958
1959   for (lib = oldmain->libraries.first; lib; lib = lib->id.next) {
1960     lib->packedfile = newpackedadr(fd, lib->packedfile);
1961   }
1962
1963   for (volume = oldmain->volumes.first; volume; volume = volume->id.next) {
1964     volume->packedfile = newpackedadr(fd, volume->packedfile);
1965   }
1966 }
1967
1968 /* undo file support: add all library pointers in lookup */
1969 void blo_add_library_pointer_map(ListBase *old_mainlist, FileData *fd)
1970 {
1971   Main *ptr = old_mainlist->first;
1972   ListBase *lbarray[MAX_LIBARRAY];
1973
1974   for (ptr = ptr->next; ptr; ptr = ptr->next) {
1975     int i = set_listbasepointers(ptr, lbarray);
1976     while (i--) {
1977       ID *id;
1978       for (id = lbarray[i]->first; id; id = id->next) {
1979         oldnewmap_insert(fd->libmap, id, id, GS(id->name));
1980       }
1981     }
1982   }
1983
1984   fd->old_mainlist = old_mainlist;
1985 }
1986
1987 /* Build a GSet of old main (we only care about local data here, so we can do that after
1988  * split_main() call. */
1989 void blo_make_old_idmap_from_main(FileData *fd, Main *bmain)
1990 {
1991   if (fd->old_idmap != NULL) {
1992     BKE_main_idmap_destroy(fd->old_idmap);
1993   }
1994   fd->old_idmap = BKE_main_idmap_create(bmain, false, NULL, MAIN_IDMAP_TYPE_UUID);
1995 }
1996
1997 typedef struct BLOCacheStorage {
1998   GHash *cache_map;
1999   MemArena *memarena;
2000 } BLOCacheStorage;
2001
2002 /** Register a cache data entry to be preserved when reading some undo memfile. */
2003 static void blo_cache_storage_entry_register(ID *id,
2004                                              const IDCacheKey *key,
2005                                              void **UNUSED(cache_p),
2006                                              eIDTypeInfoCacheCallbackFlags UNUSED(flags),
2007                                              void *cache_storage_v)
2008 {
2009   BLI_assert(key->id_session_uuid == id->session_uuid);
2010   UNUSED_VARS_NDEBUG(id);
2011
2012   BLOCacheStorage *cache_storage = cache_storage_v;
2013   BLI_assert(!BLI_ghash_haskey(cache_storage->cache_map, key));
2014
2015   IDCacheKey *storage_key = BLI_memarena_alloc(cache_storage->memarena, sizeof(*storage_key));
2016   *storage_key = *key;
2017   BLI_ghash_insert(cache_storage->cache_map, storage_key, POINTER_FROM_UINT(0));
2018 }
2019
2020 /** Restore a cache data entry from old ID into new one, when reading some undo memfile. */
2021 static void blo_cache_storage_entry_restore_in_new(ID *UNUSED(id),
2022                                                    const IDCacheKey *key,
2023                                                    void **cache_p,
2024                                                    eIDTypeInfoCacheCallbackFlags flags,
2025                                                    void *cache_storage_v)
2026 {
2027   BLOCacheStorage *cache_storage = cache_storage_v;
2028
2029   if (cache_storage == NULL) {
2030     /* In non-undo case, only clear the pointer if it is a purely runtime one.
2031      * If it may be stored in a persistent way in the .blend file, direct_link code is responsible
2032      * to properly deal with it. */
2033     if ((flags & IDTYPE_CACHE_CB_FLAGS_PERSISTENT) == 0) {
2034       *cache_p = NULL;
2035     }
2036     return;
2037   }
2038
2039   void **value = BLI_ghash_lookup_p(cache_storage->cache_map, key);
2040   if (value == NULL) {
2041     *cache_p = NULL;
2042     return;
2043   }
2044   *value = POINTER_FROM_UINT(POINTER_AS_UINT(*value) + 1);
2045   *cache_p = key->cache_v;
2046 }
2047
2048 /** Clear as needed a cache data entry from old ID, when reading some undo memfile. */
2049 static void blo_cache_storage_entry_clear_in_old(ID *UNUSED(id),
2050                                                  const IDCacheKey *key,
2051                                                  void **cache_p,
2052                                                  eIDTypeInfoCacheCallbackFlags UNUSED(flags),
2053                                                  void *cache_storage_v)
2054 {
2055   BLOCacheStorage *cache_storage = cache_storage_v;
2056
2057   void **value = BLI_ghash_lookup_p(cache_storage->cache_map, key);
2058   if (value == NULL) {
2059     *cache_p = NULL;
2060     return;
2061   }
2062   /* If that cache has been restored into some new ID, we want to remove it from old one, otherwise
2063    * keep it there so that it gets properly freed together with its ID. */
2064   *cache_p = POINTER_AS_UINT(*value) != 0 ? NULL : key->cache_v;
2065 }
2066
2067 void blo_cache_storage_init(FileData *fd, Main *bmain)
2068 {
2069   if (fd->memfile != NULL) {
2070     BLI_assert(fd->cache_storage == NULL);
2071     fd->cache_storage = MEM_mallocN(sizeof(*fd->cache_storage), __func__);
2072     fd->cache_storage->memarena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
2073     fd->cache_storage->cache_map = BLI_ghash_new(
2074         BKE_idtype_cache_key_hash, BKE_idtype_cache_key_cmp, __func__);
2075
2076     ListBase *lb;
2077     FOREACH_MAIN_LISTBASE_BEGIN (bmain, lb) {
2078       ID *id = lb->first;
2079       if (id == NULL) {
2080         continue;
2081       }
2082
2083       const IDTypeInfo *type_info = BKE_idtype_get_info_from_id(id);
2084       if (type_info->foreach_cache == NULL) {
2085         continue;
2086       }
2087
2088       FOREACH_MAIN_LISTBASE_ID_BEGIN (lb, id) {
2089         if (ID_IS_LINKED(id)) {
2090           continue;
2091         }
2092         BKE_idtype_id_foreach_cache(id, blo_cache_storage_entry_register, fd->cache_storage);
2093       }
2094       FOREACH_MAIN_LISTBASE_ID_END;
2095     }
2096     FOREACH_MAIN_LISTBASE_END;
2097   }
2098   else {
2099     fd->cache_storage = NULL;
2100   }
2101 }
2102
2103 void blo_cache_storage_old_bmain_clear(FileData *fd, Main *bmain_old)
2104 {
2105   if (fd->cache_storage != NULL) {
2106     ListBase *lb;
2107     FOREACH_MAIN_LISTBASE_BEGIN (bmain_old, lb) {
2108       ID *id = lb->first;
2109       if (id == NULL) {
2110         continue;
2111       }
2112
2113       const IDTypeInfo *type_info = BKE_idtype_get_info_from_id(id);
2114       if (type_info->foreach_cache == NULL) {
2115         continue;
2116       }
2117
2118       FOREACH_MAIN_LISTBASE_ID_BEGIN (lb, id) {
2119         if (ID_IS_LINKED(id)) {
2120           continue;
2121         }
2122         BKE_idtype_id_foreach_cache(id, blo_cache_storage_entry_clear_in_old, fd->cache_storage);
2123       }
2124       FOREACH_MAIN_LISTBASE_ID_END;
2125     }
2126     FOREACH_MAIN_LISTBASE_END;
2127   }
2128 }
2129
2130 void blo_cache_storage_end(FileData *fd)
2131 {
2132   if (fd->cache_storage != NULL) {
2133     BLI_ghash_free(fd->cache_storage->cache_map, NULL, NULL);
2134     BLI_memarena_free(fd->cache_storage->memarena);
2135     MEM_freeN(fd->cache_storage);
2136     fd->cache_storage = NULL;
2137   }
2138 }
2139
2140 /** \} */
2141
2142 /* -------------------------------------------------------------------- */
2143 /** \name DNA Struct Loading
2144  * \{ */
2145
2146 static void switch_endian_structs(const struct SDNA *filesdna, BHead *bhead)
2147 {
2148   int blocksize, nblocks;
2149   char *data;
2150
2151   data = (char *)(bhead + 1);
2152   blocksize = filesdna->types_size[filesdna->structs[bhead->SDNAnr][0]];
2153
2154   nblocks = bhead->nr;
2155   while (nblocks--) {
2156     DNA_struct_switch_endian(filesdna, bhead->SDNAnr, data);
2157
2158     data += blocksize;
2159   }
2160 }
2161
2162 static void *read_struct(FileData *fd, BHead *bh, const char *blockname)
2163 {
2164   void *temp = NULL;
2165
2166   if (bh->len) {
2167 #ifdef USE_BHEAD_READ_ON_DEMAND
2168     BHead *bh_orig = bh;
2169 #endif
2170
2171     /* switch is based on file dna */
2172     if (bh->SDNAnr && (fd->flags & FD_FLAGS_SWITCH_ENDIAN)) {
2173 #ifdef USE_BHEAD_READ_ON_DEMAND
2174       if (BHEADN_FROM_BHEAD(bh)->has_data == false) {
2175         bh = blo_bhead_read_full(fd, bh);
2176         if (UNLIKELY(bh == NULL)) {
2177           fd->flags &= ~FD_FLAGS_FILE_OK;
2178           return NULL;
2179         }
2180       }
2181 #endif
2182       switch_endian_structs(fd->filesdna, bh);
2183     }
2184
2185     if (fd->compflags[bh->SDNAnr] != SDNA_CMP_REMOVED) {
2186       if (fd->compflags[bh->SDNAnr] == SDNA_CMP_NOT_EQUAL) {
2187 #ifdef USE_BHEAD_READ_ON_DEMAND
2188         if (BHEADN_FROM_BHEAD(bh)->has_data == false) {
2189           bh = blo_bhead_read_full(fd, bh);
2190           if (UNLIKELY(bh == NULL)) {
2191             fd->flags &= ~FD_FLAGS_FILE_OK;
2192             return NULL;
2193           }
2194         }
2195 #endif
2196         temp = DNA_struct_reconstruct(
2197             fd->memsdna, fd->filesdna, fd->compflags, bh->SDNAnr, bh->nr, (bh + 1));
2198       }
2199       else {
2200         /* SDNA_CMP_EQUAL */
2201         temp = MEM_mallocN(bh->len, blockname);
2202 #ifdef USE_BHEAD_READ_ON_DEMAND
2203         if (BHEADN_FROM_BHEAD(bh)->has_data) {
2204           memcpy(temp, (bh + 1), bh->len);
2205         }
2206         else {
2207           /* Instead of allocating the bhead, then copying it,
2208            * read the data from the file directly into the memory. */
2209           if (UNLIKELY(!blo_bhead_read_data(fd, bh, temp))) {
2210             fd->flags &= ~FD_FLAGS_FILE_OK;
2211             MEM_freeN(temp);
2212             temp = NULL;
2213           }
2214         }
2215 #else
2216         memcpy(temp, (bh + 1), bh->len);
2217 #endif
2218       }
2219     }
2220
2221 #ifdef USE_BHEAD_READ_ON_DEMAND
2222     if (bh_orig != bh) {
2223       MEM_freeN(BHEADN_FROM_BHEAD(bh));
2224     }
2225 #endif
2226   }
2227
2228   return temp;
2229 }
2230
2231 /* Like read_struct, but gets a pointer without allocating. Only works for
2232  * undo since DNA must match. */
2233 static const void *peek_struct_undo(FileData *fd, BHead *bhead)
2234 {
2235   BLI_assert(fd->memfile != NULL);
2236   UNUSED_VARS_NDEBUG(fd);
2237   return (bhead->len) ? (const void *)(bhead + 1) : NULL;
2238 }
2239
2240 static void link_glob_list(FileData *fd, ListBase *lb) /* for glob data */
2241 {
2242   Link *ln, *prev;
2243   void *poin;
2244
2245   if (BLI_listbase_is_empty(lb)) {
2246     return;
2247   }
2248   poin = newdataadr(fd, lb->first);
2249   if (lb->first) {
2250     oldnewmap_insert(fd->globmap, lb->first, poin, 0);
2251   }
2252   lb->first = poin;
2253
2254   ln = lb->first;
2255   prev = NULL;
2256   while (ln) {
2257     poin = newdataadr(fd, ln->next);
2258     if (ln->next) {
2259       oldnewmap_insert(fd->globmap, ln->next, poin, 0);
2260     }
2261     ln->next = poin;
2262     ln->prev = prev;
2263     prev = ln;
2264     ln = ln->next;
2265   }
2266   lb->last = prev;
2267 }
2268
2269 /** \} */
2270
2271 /* -------------------------------------------------------------------- */
2272 /** \name Read ID Properties
2273  * \{ */
2274
2275 static void IDP_DirectLinkProperty(IDProperty *prop, BlendDataReader *reader);
2276 static void IDP_LibLinkProperty(IDProperty *prop, BlendLibReader *reader);
2277
2278 static void IDP_DirectLinkIDPArray(IDProperty *prop, BlendDataReader *reader)
2279 {
2280   IDProperty *array;
2281   int i;
2282
2283   /* since we didn't save the extra buffer, set totallen to len */
2284   prop->totallen = prop->len;
2285   BLO_read_data_address(reader, &prop->data.pointer);
2286
2287   array = (IDProperty *)prop->data.pointer;
2288
2289   /* note!, idp-arrays didn't exist in 2.4x, so the pointer will be cleared
2290    * there's not really anything we can do to correct this, at least don't crash */
2291   if (array == NULL) {
2292     prop->len = 0;
2293     prop->totallen = 0;
2294   }
2295
2296   for (i = 0; i < prop->len; i++) {
2297     IDP_DirectLinkProperty(&array[i], reader);
2298   }
2299 }
2300
2301 static void IDP_DirectLinkArray(IDProperty *prop, BlendDataReader *reader)
2302 {
2303   IDProperty **array;
2304   int i;
2305
2306   /* since we didn't save the extra buffer, set totallen to len */
2307   prop->totallen = prop->len;
2308
2309   if (prop->subtype == IDP_GROUP) {
2310     BLO_read_pointer_array(reader, &prop->data.pointer);
2311     array = prop->data.pointer;
2312
2313     for (i = 0; i < prop->len; i++) {
2314       IDP_DirectLinkProperty(array[i], reader);
2315     }
2316   }
2317   else if (prop->subtype == IDP_DOUBLE) {
2318     BLO_read_double_array(reader, prop->len, (double **)&prop->data.pointer);
2319   }
2320   else {
2321     /* also used for floats */
2322     BLO_read_int32_array(reader, prop->len, (int **)&prop->data.pointer);
2323   }
2324 }
2325
2326 static void IDP_DirectLinkString(IDProperty *prop, BlendDataReader *reader)
2327 {
2328   /*since we didn't save the extra string buffer, set totallen to len.*/
2329   prop->totallen = prop->len;
2330   BLO_read_data_address(reader, &prop->data.pointer);
2331 }
2332
2333 static void IDP_DirectLinkGroup(IDProperty *prop, BlendDataReader *reader)
2334 {
2335   ListBase *lb = &prop->data.group;
2336   IDProperty *loop;
2337
2338   BLO_read_list(reader, lb);
2339
2340   /*Link child id properties now*/
2341   for (loop = prop->data.group.first; loop; loop = loop->next) {
2342     IDP_DirectLinkProperty(loop, reader);
2343   }
2344 }
2345
2346 static void IDP_DirectLinkProperty(IDProperty *prop, BlendDataReader *reader)
2347 {
2348   switch (prop->type) {
2349     case IDP_GROUP:
2350       IDP_DirectLinkGroup(prop, reader);
2351       break;
2352     case IDP_STRING:
2353       IDP_DirectLinkString(prop, reader);
2354       break;
2355     case IDP_ARRAY:
2356       IDP_DirectLinkArray(prop, reader);
2357       break;
2358     case IDP_IDPARRAY:
2359       IDP_DirectLinkIDPArray(prop, reader);
2360       break;
2361     case IDP_DOUBLE:
2362       /* Workaround for doubles.
2363        * They are stored in the same field as `int val, val2` in the IDPropertyData struct,
2364        * they have to deal with endianness specifically.
2365        *
2366        * In theory, val and val2 would've already been swapped
2367        * if switch_endian is true, so we have to first unswap
2368        * them then re-swap them as a single 64-bit entity. */
2369       if (BLO_read_requires_endian_switch(reader)) {
2370         BLI_endian_switch_int32(&prop->data.val);
2371         BLI_endian_switch_int32(&prop->data.val2);
2372         BLI_endian_switch_int64((int64_t *)&prop->data.val);
2373       }
2374       break;
2375     case IDP_INT:
2376     case IDP_FLOAT:
2377     case IDP_ID:
2378       break; /* Nothing special to do here. */
2379     default:
2380       /* Unknown IDP type, nuke it (we cannot handle unknown types everywhere in code,
2381        * IDP are way too polymorphic to do it safely. */
2382       printf(
2383           "%s: found unknown IDProperty type %d, reset to Integer one !\n", __func__, prop->type);
2384       /* Note: we do not attempt to free unknown prop, we have no way to know how to do that! */
2385       prop->type = IDP_INT;
2386       prop->subtype = 0;
2387       IDP_Int(prop) = 0;
2388   }
2389 }
2390
2391 #define IDP_DirectLinkGroup_OrFree(prop, reader) \
2392   _IDP_DirectLinkGroup_OrFree(prop, reader, __func__)
2393
2394 static void _IDP_DirectLinkGroup_OrFree(IDProperty **prop,
2395                                         BlendDataReader *reader,
2396                                         const char *caller_func_id)
2397 {
2398   if (*prop) {
2399     if ((*prop)->type == IDP_GROUP) {
2400       IDP_DirectLinkGroup(*prop, reader);
2401     }
2402     else {
2403       /* corrupt file! */
2404       printf("%s: found non group data, freeing type %d!\n", caller_func_id, (*prop)->type);
2405       /* don't risk id, data's likely corrupt. */
2406       // IDP_FreePropertyContent(*prop);
2407       *prop = NULL;
2408     }
2409   }
2410 }
2411
2412 static void IDP_LibLinkProperty(IDProperty *prop, BlendLibReader *reader)
2413 {
2414   if (!prop) {
2415     return;
2416   }
2417
2418   switch (prop->type) {
2419     case IDP_ID: /* PointerProperty */
2420     {
2421       void *newaddr = BLO_read_get_new_id_address(reader, NULL, IDP_Id(prop));
2422       if (IDP_Id(prop) && !newaddr && G.debug) {
2423         printf("Error while loading \"%s\". Data not found in file!\n", prop->name);
2424       }
2425       prop->data.pointer = newaddr;
2426       break;
2427     }
2428     case IDP_IDPARRAY: /* CollectionProperty */
2429     {
2430       IDProperty *idp_array = IDP_IDPArray(prop);
2431       for (int i = 0; i < prop->len; i++) {
2432         IDP_LibLinkProperty(&(idp_array[i]), reader);
2433       }
2434       break;
2435     }
2436     case IDP_GROUP: /* PointerProperty */
2437     {
2438       LISTBASE_FOREACH (IDProperty *, loop, &prop->data.group) {
2439         IDP_LibLinkProperty(loop, reader);
2440       }
2441       break;
2442     }
2443     default:
2444       break; /* Nothing to do for other IDProps. */
2445   }
2446 }
2447
2448 /** \} */
2449
2450 /* -------------------------------------------------------------------- */
2451 /** \name Read Image Preview
2452  * \{ */
2453
2454 static PreviewImage *direct_link_preview_image(BlendDataReader *reader, PreviewImage *old_prv)
2455 {
2456   PreviewImage *prv = BLO_read_get_new_data_address(reader, old_prv);
2457
2458   if (prv) {
2459     int i;
2460     for (i = 0; i < NUM_ICON_SIZES; i++) {
2461       if (prv->rect[i]) {
2462         BLO_read_data_address(reader, &prv->rect[i]);
2463       }
2464       prv->gputexture[i] = NULL;
2465     }
2466     prv->icon_id = 0;
2467     prv->tag = 0;
2468   }
2469
2470   return prv;
2471 }
2472
2473 /** \} */
2474
2475 /* -------------------------------------------------------------------- */
2476 /** \name Read ID
2477  * \{ */
2478
2479 static void lib_link_id(BlendLibReader *reader, ID *id);
2480 static void lib_link_nodetree(BlendLibReader *reader, bNodeTree *ntree);
2481 static void lib_link_collection(BlendLibReader *reader, Collection *collection);
2482
2483 static void lib_link_id_embedded_id(BlendLibReader *reader, ID *id)
2484 {
2485
2486   /* Handle 'private IDs'. */
2487   bNodeTree *nodetree = ntreeFromID(id);
2488   if (nodetree != NULL) {
2489     lib_link_id(reader, &nodetree->id);
2490     lib_link_nodetree(reader, nodetree);
2491   }
2492
2493   if (GS(id->name) == ID_SCE) {
2494     Scene *scene = (Scene *)id;
2495     if (scene->master_collection != NULL) {
2496       lib_link_id(reader, &scene->master_collection->id);
2497       lib_link_collection(reader, scene->master_collection);
2498     }
2499   }
2500 }
2501
2502 static void lib_link_id(BlendLibReader *reader, ID *id)
2503 {
2504   /* Note: WM IDProperties are never written to file, hence they should always be NULL here. */
2505   BLI_assert((GS(id->name) != ID_WM) || id->properties == NULL);
2506   IDP_LibLinkProperty(id->properties, reader);
2507
2508   AnimData *adt = BKE_animdata_from_id(id);
2509   if (adt != NULL) {
2510     lib_link_animdata(reader, id, adt);
2511   }
2512
2513   if (id->override_library) {
2514     BLO_read_id_address(reader, id->lib, &id->override_library->reference);
2515     BLO_read_id_address(reader, id->lib, &id->override_library->storage);
2516   }
2517
2518   lib_link_id_embedded_id(reader, id);
2519 }
2520
2521 static void direct_link_id_override_property_operation_cb(BlendDataReader *reader, void *data)
2522 {
2523   IDOverrideLibraryPropertyOperation *opop = data;
2524
2525   BLO_read_data_address(reader, &opop->subitem_reference_name);
2526   BLO_read_data_address(reader, &opop->subitem_local_name);
2527
2528   opop->tag = 0; /* Runtime only. */
2529 }
2530
2531 static void direct_link_id_override_property_cb(BlendDataReader *reader, void *data)
2532 {
2533   IDOverrideLibraryProperty *op = data;
2534
2535   BLO_read_data_address(reader, &op->rna_path);
2536
2537   op->tag = 0; /* Runtime only. */
2538
2539   BLO_read_list_cb(reader, &op->operations, direct_link_id_override_property_operation_cb);
2540 }
2541
2542 static void direct_link_id_common(
2543     BlendDataReader *reader, Library *current_library, ID *id, ID *id_old, const int tag);
2544 static void direct_link_nodetree(BlendDataReader *reader, bNodeTree *ntree);
2545 static void direct_link_collection(BlendDataReader *reader, Collection *collection);
2546
2547 static void direct_link_id_embedded_id(BlendDataReader *reader,
2548                                        Library *current_library,
2549                                        ID *id,
2550                                        ID *id_old)
2551 {
2552   /* Handle 'private IDs'. */
2553   bNodeTree **nodetree = BKE_ntree_ptr_from_id(id);
2554   if (nodetree != NULL && *nodetree != NULL) {
2555     BLO_read_data_address(reader, nodetree);
2556     direct_link_id_common(reader,
2557                           current_library,
2558                           (ID *)*nodetree,
2559                           id_old != NULL ? (ID *)ntreeFromID(id_old) : NULL,
2560                           0);
2561     direct_link_nodetree(reader, *nodetree);
2562   }
2563
2564   if (GS(id->name) == ID_SCE) {
2565     Scene *scene = (Scene *)id;
2566     if (scene->master_collection != NULL) {
2567       BLO_read_data_address(reader, &scene->master_collection);
2568       direct_link_id_common(reader,
2569                             current_library,
2570                             &scene->master_collection->id,
2571                             id_old != NULL ? &((Scene *)id_old)->master_collection->id : NULL,
2572                             0);
2573       direct_link_collection(reader, scene->master_collection);
2574     }
2575   }
2576 }
2577
2578 static int direct_link_id_restore_recalc_exceptions(const ID *id_current)
2579 {
2580   /* Exception for armature objects, where the pose has direct points to the
2581    * armature databolock. */
2582   if (GS(id_current->name) == ID_OB && ((Object *)id_current)->pose) {
2583     return ID_RECALC_GEOMETRY;
2584   }
2585
2586   return 0;
2587 }
2588
2589 static int direct_link_id_restore_recalc(const FileData *fd,
2590                                          const ID *id_target,
2591                                          const ID *id_current,
2592                                          const bool is_identical)
2593 {
2594   /* These are the evaluations that had not been performed yet at the time the
2595    * target undo state was written. These need to be done again, since they may
2596    * flush back changes to the original datablock. */
2597   int recalc = id_target->recalc;
2598
2599   if (id_current == NULL) {
2600     /* ID does not currently exist in the database, so also will not exist in
2601      * the dependency graphs. That means it will be newly created and as a
2602      * result also fully re-evaluated regardless of the recalc flag set here. */
2603     recalc |= ID_RECALC_ALL;
2604   }
2605   else {
2606     /* If the contents datablock changed, the depsgraph needs to copy the
2607      * datablock again to ensure it matches the original datablock. */
2608     if (!is_identical) {
2609       recalc |= ID_RECALC_COPY_ON_WRITE;
2610     }
2611
2612     /* Special exceptions. */
2613     recalc |= direct_link_id_restore_recalc_exceptions(id_current);
2614
2615     /* Evaluations for the current state that have not been performed yet
2616      * by the time we are performing this undo step. */
2617     recalc |= id_current->recalc;
2618
2619     /* Tags that were set between the target state and the current state,
2620      * that we need to perform again. */
2621     if (fd->undo_direction < 0) {
2622       /* Undo: tags from target to the current state. */
2623       recalc |= id_current->recalc_up_to_undo_push;
2624     }
2625     else {
2626       /* Redo: tags from current to the target state. */
2627       recalc |= id_target->recalc_up_to_undo_push;
2628     }
2629   }
2630
2631   return recalc;
2632 }
2633
2634 static void direct_link_id_common(
2635     BlendDataReader *reader, Library *current_library, ID *id, ID *id_old, const int tag)
2636 {
2637   if (reader->fd->memfile == NULL) {
2638     /* When actually reading a file , we do want to reset/re-generate session uuids.
2639      * In undo case, we want to re-use existing ones. */
2640     id->session_uuid = MAIN_ID_SESSION_UUID_UNSET;
2641   }
2642
2643   BKE_lib_libblock_session_uuid_ensure(id);
2644
2645   id->lib = current_library;
2646   id->us = ID_FAKE_USERS(id);
2647   id->icon_id = 0;
2648   id->newid = NULL; /* Needed because .blend may have been saved with crap value here... */
2649   id->orig_id = NULL;
2650   id->py_instance = NULL;
2651
2652   /* Initialize with provided tag. */
2653   id->tag = tag;
2654
2655   if (tag & LIB_TAG_ID_LINK_PLACEHOLDER) {
2656     /* For placeholder we only need to set the tag and properly initialize generic ID fields above,
2657      * no further data to read. */
2658     return;
2659   }
2660
2661   /*link direct data of ID properties*/
2662   if (id->properties) {
2663     BLO_read_data_address(reader, &id->properties);
2664     /* this case means the data was written incorrectly, it should not happen */
2665     IDP_DirectLinkGroup_OrFree(&id->properties, reader);
2666   }
2667
2668   id->flag &= ~LIB_INDIRECT_WEAK_LINK;
2669
2670   /* NOTE: It is important to not clear the recalc flags for undo/redo.
2671    * Preserving recalc flags on redo/undo is the only way to make dependency graph detect
2672    * that animation is to be evaluated on undo/redo. If this is not enforced by the recalc
2673    * flags dependency graph does not do animation update to avoid loss of unkeyed changes.,
2674    * which conflicts with undo/redo of changes to animation data itself.
2675    *
2676    * But for regular file load we clear the flag, since the flags might have been changed since
2677    * the version the file has been saved with. */
2678   if (reader->fd->memfile == NULL) {
2679     id->recalc = 0;
2680     id->recalc_after_undo_push = 0;
2681   }
2682   else if ((reader->fd->skip_flags & BLO_READ_SKIP_UNDO_OLD_MAIN) == 0) {
2683     id->recalc = direct_link_id_restore_recalc(reader->fd, id, id_old, false);
2684     id->recalc_after_undo_push = 0;
2685   }
2686
2687   /* Link direct data of overrides. */
2688   if (id->override_library) {
2689     BLO_read_data_address(reader, &id->override_library);
2690     BLO_read_list_cb(
2691         reader, &id->override_library->properties, direct_link_id_override_property_cb);
2692     id->override_library->runtime = NULL;
2693   }
2694
2695   DrawDataList *drawdata = DRW_drawdatalist_from_id(id);
2696   if (drawdata) {
2697     BLI_listbase_clear((ListBase *)drawdata);
2698   }
2699
2700   /* Handle 'private IDs'. */
2701   direct_link_id_embedded_id(reader, current_library, id, id_old);
2702 }
2703
2704 /** \} */
2705
2706 /* -------------------------------------------------------------------- */
2707 /** \name Read ID: Brush
2708  * \{ */
2709
2710 /* library brush linking after fileread */
2711 static void lib_link_brush(BlendLibReader *reader, Brush *brush)
2712 {
2713   /* brush->(mask_)mtex.obj is ignored on purpose? */
2714   BLO_read_id_address(reader, brush->id.lib, &brush->mtex.tex);
2715   BLO_read_id_address(reader, brush->id.lib, &brush->mask_mtex.tex);
2716   BLO_read_id_address(reader, brush->id.lib, &brush->clone.image);
2717   BLO_read_id_address(reader, brush->id.lib, &brush->toggle_brush);
2718   BLO_read_id_address(reader, brush->id.lib, &brush->paint_curve);
2719
2720   /* link default grease pencil palette */
2721   if (brush->gpencil_settings != NULL) {
2722     if (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED) {
2723       BLO_read_id_address(reader, brush->id.lib, &brush->gpencil_settings->material);
2724
2725       if (!brush->gpencil_settings->material) {
2726         brush->gpencil_settings->flag &= ~GP_BRUSH_MATERIAL_PINNED;
2727       }
2728     }
2729     else {
2730       brush->gpencil_settings->material = NULL;
2731     }
2732   }
2733 }
2734
2735 static void direct_link_brush(BlendDataReader *reader, Brush *brush)
2736 {
2737   /* brush itself has been read */
2738
2739   /* fallof curve */
2740   BLO_read_data_address(reader, &brush->curve);
2741
2742   BLO_read_data_address(reader, &brush->gradient);
2743
2744   if (brush->curve) {
2745     BKE_curvemapping_blend_read(reader, brush->curve);
2746   }
2747   else {
2748     BKE_brush_curve_preset(brush, CURVE_PRESET_SHARP);
2749   }
2750
2751   /* grease pencil */
2752   BLO_read_data_address(reader, &brush->gpencil_settings);
2753   if (brush->gpencil_settings != NULL) {
2754     BLO_read_data_address(reader, &brush->gpencil_settings->curve_sensitivity);
2755     BLO_read_data_address(reader, &brush->gpencil_settings->curve_strength);
2756     BLO_read_data_address(reader, &brush->gpencil_settings->curve_jitter);
2757
2758     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_pressure);
2759     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_strength);
2760     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_uv);
2761     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_hue);
2762     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_saturation);
2763     BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_value);
2764
2765     if (brush->gpencil_settings->curve_sensitivity) {
2766       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_sensitivity);
2767     }
2768
2769     if (brush->gpencil_settings->curve_strength) {
2770       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_strength);
2771     }
2772
2773     if (brush->gpencil_settings->curve_jitter) {
2774       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_jitter);
2775     }
2776
2777     if (brush->gpencil_settings->curve_rand_pressure) {
2778       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_pressure);
2779     }
2780
2781     if (brush->gpencil_settings->curve_rand_strength) {
2782       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_strength);
2783     }
2784
2785     if (brush->gpencil_settings->curve_rand_uv) {
2786       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_uv);
2787     }
2788
2789     if (brush->gpencil_settings->curve_rand_hue) {
2790       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_hue);
2791     }
2792
2793     if (brush->gpencil_settings->curve_rand_saturation) {
2794       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_saturation);
2795     }
2796
2797     if (brush->gpencil_settings->curve_rand_value) {
2798       BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_value);
2799     }
2800   }
2801
2802   brush->preview = NULL;
2803   brush->icon_imbuf = NULL;
2804 }
2805
2806 /** \} */
2807
2808 /* -------------------------------------------------------------------- */
2809 /** \name Read ID: Palette
2810  * \{ */
2811
2812 static void lib_link_palette(BlendLibReader *UNUSED(reader), Palette *UNUSED(palette))
2813 {
2814 }
2815
2816 static void direct_link_palette(BlendDataReader *reader, Palette *palette)
2817 {
2818
2819   /* palette itself has been read */
2820   BLO_read_list(reader, &palette->colors);
2821 }
2822
2823 static void lib_link_paint_curve(BlendLibReader *UNUSED(reader), PaintCurve *UNUSED(pc))
2824 {
2825 }
2826
2827 static void direct_link_paint_curve(BlendDataReader *reader, PaintCurve *pc)
2828 {
2829   BLO_read_data_address(reader, &pc->points);
2830 }
2831
2832 /** \} */
2833
2834 /* -------------------------------------------------------------------- */
2835 /** \name Read PackedFile
2836  * \{ */
2837
2838 static PackedFile *direct_link_packedfile(BlendDataReader *reader, PackedFile *oldpf)
2839 {
2840   PackedFile *pf = newpackedadr(reader->fd, oldpf);
2841
2842   if (pf) {
2843     pf->data = newpackedadr(reader->fd, pf->data);
2844     if (pf->data == NULL) {
2845       /* We cannot allow a PackedFile with a NULL data field,
2846        * the whole code assumes this is not possible. See T70315. */
2847       printf("%s: NULL packedfile data, cleaning up...\n", __func__);
2848       MEM_SAFE_FREE(pf);
2849     }
2850   }
2851
2852   return pf;
2853 }
2854
2855 /** \} */
2856
2857 /* -------------------------------------------------------------------- */
2858 /** \name Read Animation (legacy for version patching)
2859  * \{ */
2860
2861 // XXX deprecated - old animation system
2862 static void lib_link_ipo(BlendLibReader *reader, Ipo *ipo)
2863 {
2864   LISTBASE_FOREACH (IpoCurve *, icu, &ipo->curve) {
2865     if (icu->driver) {
2866       BLO_read_id_address(reader, ipo->id.lib, &icu->driver->ob);
2867     }
2868   }
2869 }
2870
2871 // XXX deprecated - old animation system
2872 static void direct_link_ipo(BlendDataReader *reader, Ipo *ipo)
2873 {
2874   IpoCurve *icu;
2875
2876   BLO_read_list(reader, &(ipo->curve));
2877
2878   for (icu = ipo->curve.first; icu; icu = icu->next) {
2879     BLO_read_data_address(reader, &icu->bezt);
2880     BLO_read_data_address(reader, &icu->bp);
2881     BLO_read_data_address(reader, &icu->driver);
2882   }
2883 }
2884
2885 // XXX deprecated - old animation system
2886 static void lib_link_nlastrips(BlendLibReader *reader, ID *id, ListBase *striplist)
2887 {
2888   bActionStrip *strip;
2889   bActionModifier *amod;
2890
2891   for (strip = striplist->first; strip; strip = strip->next) {
2892     BLO_read_id_address(reader, id->lib, &strip->object);
2893     BLO_read_id_address(reader, id->lib, &strip->act);
2894     BLO_read_id_address(reader, id->lib, &strip->ipo);
2895     for (amod = strip->modifiers.first; amod; amod = amod->next) {
2896       BLO_read_id_address(reader, id->lib, &amod->ob);
2897     }
2898   }
2899 }
2900
2901 // XXX deprecated - old animation system
2902 static void direct_link_nlastrips(BlendDataReader *reader, ListBase *strips)
2903 {
2904   bActionStrip *strip;
2905
2906   BLO_read_list(reader, strips);
2907
2908   for (strip = strips->first; strip; strip = strip->next) {
2909     BLO_read_list(reader, &strip->modifiers);
2910   }
2911 }
2912
2913 // XXX deprecated - old animation system
2914 static void lib_link_constraint_channels(BlendLibReader *reader, ID *id, ListBase *chanbase)
2915 {
2916   bConstraintChannel *chan;
2917
2918   for (chan = chanbase->first; chan; chan = chan->next) {
2919     BLO_read_id_address(reader, id->lib, &chan->ipo);
2920   }
2921 }
2922
2923 /** \} */
2924
2925 /* -------------------------------------------------------------------- */
2926 /** \name Read ID: Action
2927  * \{ */
2928
2929 static void lib_link_fmodifiers(BlendLibReader *reader, ID *id, ListBase *list)
2930 {
2931   FModifier *fcm;
2932
2933   for (fcm = list->first; fcm; fcm = fcm->next) {
2934     /* data for specific modifiers */
2935     switch (fcm->type) {
2936       case FMODIFIER_TYPE_PYTHON: {
2937         FMod_Python *data = (FMod_Python *)fcm->data;
2938         BLO_read_id_address(reader, id->lib, &data->script);
2939
2940         break;
2941       }
2942     }
2943   }
2944 }
2945
2946 static void lib_link_fcurves(BlendLibReader *reader, ID *id, ListBase *list)
2947 {
2948   FCurve *fcu;
2949
2950   if (list == NULL) {
2951     return;
2952   }
2953
2954   /* relink ID-block references... */
2955   for (fcu = list->first; fcu; fcu = fcu->next) {
2956     /* driver data */
2957     if (fcu->driver) {
2958       ChannelDriver *driver = fcu->driver;
2959       DriverVar *dvar;
2960
2961       for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
2962         DRIVER_TARGETS_LOOPER_BEGIN (dvar) {
2963           /* only relink if still used */
2964           if (tarIndex < dvar->num_targets) {
2965             BLO_read_id_address(reader, id->lib, &dtar->id);
2966           }
2967           else {
2968             dtar->id = NULL;
2969           }
2970         }
2971         DRIVER_TARGETS_LOOPER_END;
2972       }
2973     }
2974
2975     /* modifiers */
2976     lib_link_fmodifiers(reader, id, &fcu->modifiers);
2977   }
2978 }
2979
2980 /* NOTE: this assumes that link_list has already been called on the list */
2981 static void direct_link_fmodifiers(BlendDataReader *reader, ListBase *list, FCurve *curve)
2982 {
2983   FModifier *fcm;
2984
2985   for (fcm = list->first; fcm; fcm = fcm->next) {
2986     /* relink general data */
2987     BLO_read_data_address(reader, &fcm->data);
2988     fcm->curve = curve;
2989
2990     /* do relinking of data for specific types */
2991     switch (fcm->type) {
2992       case FMODIFIER_TYPE_GENERATOR: {
2993         FMod_Generator *data = (FMod_Generator *)fcm->data;
2994         BLO_read_float_array(reader, data->arraysize, &data->coefficients);
2995         break;
2996       }
2997       case FMODIFIER_TYPE_ENVELOPE: {
2998         FMod_Envelope *data = (FMod_Envelope *)fcm->data;
2999
3000         BLO_read_data_address(reader, &data->data);
3001
3002         break;
3003       }
3004       case FMODIFIER_TYPE_PYTHON: {
3005         FMod_Python *data = (FMod_Python *)fcm->data;
3006
3007         BLO_read_data_address(reader, &data->prop);
3008         IDP_DirectLinkGroup_OrFree(&data->prop, reader);
3009
3010         break;
3011       }
3012     }
3013   }
3014 }
3015
3016 /* NOTE: this assumes that link_list has already been called on the list */
3017 static void direct_link_fcurves(BlendDataReader *reader, ListBase *list)
3018 {
3019   FCurve *fcu;
3020
3021   /* link F-Curve data to F-Curve again (non ID-libs) */
3022   for (fcu = list->first; fcu; fcu = fcu->next) {
3023     /* curve data */
3024     BLO_read_data_address(reader, &fcu->bezt);
3025     BLO_read_data_address(reader, &fcu->fpt);
3026
3027     /* rna path */
3028     BLO_read_data_address(reader, &fcu->rna_path);
3029
3030     /* group */
3031     BLO_read_data_address(reader, &fcu->grp);
3032
3033     /* clear disabled flag - allows disabled drivers to be tried again ([#32155]),
3034      * but also means that another method for "reviving disabled F-Curves" exists
3035      */
3036     fcu->flag &= ~FCURVE_DISABLED;
3037
3038     /* driver */
3039     BLO_read_data_address(reader, &fcu->driver);
3040     if (fcu->driver) {
3041       ChannelDriver *driver = fcu->driver;
3042       DriverVar *dvar;
3043
3044       /* Compiled expression data will need to be regenerated
3045        * (old pointer may still be set here). */
3046       driver->expr_comp = NULL;
3047       driver->expr_simple = NULL;
3048
3049       /* give the driver a fresh chance - the operating environment may be different now
3050        * (addons, etc. may be different) so the driver namespace may be sane now [#32155]
3051        */
3052       driver->flag &= ~DRIVER_FLAG_INVALID;
3053
3054       /* relink variables, targets and their paths */
3055       BLO_read_list(reader, &driver->variables);
3056       for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
3057         DRIVER_TARGETS_LOOPER_BEGIN (dvar) {
3058           /* only relink the targets being used */
3059           if (tarIndex < dvar->num_targets) {
3060             BLO_read_data_address(reader, &dtar->rna_path);
3061           }
3062           else {
3063             dtar->rna_path = NULL;
3064           }
3065         }
3066         DRIVER_TARGETS_LOOPER_END;
3067       }
3068     }
3069
3070     /* modifiers */
3071     BLO_read_list(reader, &fcu->modifiers);
3072     direct_link_fmodifiers(reader, &fcu->modifiers, fcu);
3073   }
3074 }
3075
3076 static void lib_link_action(BlendLibReader *reader, bAction *act)
3077 {
3078   // XXX deprecated - old animation system <<<
3079   LISTBASE_FOREACH (bActionChannel *, chan, &act->chanbase) {
3080     BLO_read_id_address(reader, act->id.lib, &chan->ipo);
3081     lib_link_constraint_channels(reader, &act->id, &chan->constraintChannels);
3082   }
3083   // >>> XXX deprecated - old animation system
3084
3085   lib_link_fcurves(reader, &act->id, &act->curves);
3086
3087   LISTBASE_FOREACH (TimeMarker *, marker, &act->markers) {
3088     if (marker->camera) {
3089       BLO_read_id_address(reader, act->id.lib, &marker->camera);
3090     }
3091   }
3092 }
3093
3094 static void direct_link_action(BlendDataReader *reader, bAction *act)
3095 {
3096   bActionChannel *achan;  // XXX deprecated - old animation system
3097   bActionGroup *agrp;
3098
3099   BLO_read_list(reader, &act->curves);
3100   BLO_read_list(reader, &act->chanbase);  // XXX deprecated - old animation system
3101   BLO_read_list(reader, &act->groups);
3102   BLO_read_list(reader, &act->markers);
3103
3104   // XXX deprecated - old animation system <<<
3105   for (achan = act->chanbase.first; achan; achan = achan->next) {
3106     BLO_read_data_address(reader, &achan->grp);
3107
3108     BLO_read_list(reader, &achan->constraintChannels);
3109   }
3110   // >>> XXX deprecated - old animation system
3111
3112   direct_link_fcurves(reader, &act->curves);
3113
3114   for (agrp = act->groups.first; agrp; agrp = agrp->next) {
3115     BLO_read_data_address(reader, &agrp->channels.first);
3116     BLO_read_data_address(reader, &agrp->channels.last);
3117   }
3118 }
3119
3120 static void lib_link_nladata_strips(BlendLibReader *reader, ID *id, ListBase *list)
3121 {
3122   NlaStrip *strip;
3123
3124   for (strip = list->first; strip; strip = strip->next) {
3125     /* check strip's children */
3126     lib_link_nladata_strips(reader, id, &strip->strips);
3127
3128     /* check strip's F-Curves */
3129     lib_link_fcurves(reader, id, &strip->fcurves);
3130
3131     /* reassign the counted-reference to action */
3132     BLO_read_id_address(reader, id->lib, &strip->act);
3133   }
3134 }
3135
3136 static void lib_link_nladata(BlendLibReader *reader, ID *id, ListBase *list)
3137 {
3138   NlaTrack *nlt;
3139
3140   /* we only care about the NLA strips inside the tracks */
3141   for (nlt = list->first; nlt; nlt = nlt->next) {
3142     lib_link_nladata_strips(reader, id, &nlt->strips);
3143   }
3144 }
3145
3146 /* This handles Animato NLA-Strips linking
3147  * NOTE: this assumes that link_list has already been called on the list
3148  */
3149 static void direct_link_nladata_strips(BlendDataReader *reader, ListBase *list)
3150 {
3151   NlaStrip *strip;
3152
3153   for (strip = list->first; strip; strip = strip->next) {
3154     /* strip's child strips */
3155     BLO_read_list(reader, &strip->strips);
3156     direct_link_nladata_strips(reader, &strip->strips);
3157
3158     /* strip's F-Curves */
3159     BLO_read_list(reader, &strip->fcurves);
3160     direct_link_fcurves(reader, &strip->fcurves);
3161
3162     /* strip's F-Modifiers */
3163     BLO_read_list(reader, &strip->modifiers);
3164     direct_link_fmodifiers(reader, &strip->modifiers, NULL);
3165   }
3166 }
3167
3168 /* NOTE: this assumes that BLO_read_list has already been called on the list */
3169 static void direct_link_nladata(BlendDataReader *reader, ListBase *list)
3170 {
3171   NlaTrack *nlt;
3172
3173   for (nlt = list->first; nlt; nlt = nlt->next) {
3174     /* relink list of strips */
3175     BLO_read_list(reader, &nlt->strips);
3176
3177     /* relink strip data */
3178     direct_link_nladata_strips(reader, &nlt->strips);
3179   }
3180 }
3181
3182 /* ------- */
3183
3184 static void lib_link_keyingsets(BlendLibReader *reader, ID *id, ListBase *list)
3185 {
3186   KeyingSet *ks;
3187   KS_Path *ksp;
3188
3189   /* here, we're only interested in the ID pointer stored in some of the paths */
3190   for (ks = list->first; ks; ks = ks->next) {
3191     for (ksp = ks->paths.first; ksp; ksp = ksp->next) {
3192       BLO_read_id_address(reader, id->lib, &ksp->id);
3193     }
3194   }
3195 }
3196
3197 /* NOTE: this assumes that BLO_read_list has already been called on the list */
3198 static void direct_link_keyingsets(BlendDataReader *reader, ListBase *list)
3199 {
3200   KeyingSet *ks;
3201   KS_Path *ksp;
3202
3203   /* link KeyingSet data to KeyingSet again (non ID-libs) */
3204   for (ks = list->first; ks; ks = ks->next) {
3205     /* paths */
3206     BLO_read_list(reader, &ks->paths);
3207
3208     for (ksp = ks->paths.first; ksp; ksp = ksp->next) {
3209       /* rna path */
3210       BLO_read_data_address(reader, &ksp->rna_path);
3211     }
3212   }
3213 }
3214
3215 /* ------- */
3216
3217 static void lib_link_animdata(BlendLibReader *reader, ID *id, AnimData *adt)
3218 {
3219   if (adt == NULL) {
3220     return;
3221   }
3222
3223   /* link action data */
3224   BLO_read_id_address(reader, id->lib, &adt->action);
3225   BLO_read_id_address(reader, id->lib, &adt->tmpact);
3226
3227   /* link drivers */
3228   lib_link_fcurves(reader, id, &adt->drivers);
3229
3230   /* overrides don't have lib-link for now, so no need to do anything */
3231
3232   /* link NLA-data */
3233   lib_link_nladata(reader, id, &adt->nla_tracks);
3234 }
3235
3236 static void direct_link_animdata(BlendDataReader *reader, AnimData *adt)
3237 {
3238   /* NOTE: must have called newdataadr already before doing this... */
3239   if (adt == NULL) {
3240     return;
3241   }
3242
3243   /* link drivers */
3244   BLO_read_list(reader, &adt->drivers);
3245   direct_link_fcurves(reader, &adt->drivers);
3246   adt->driver_array = NULL;
3247
3248   /* link overrides */
3249   // TODO...
3250
3251   /* link NLA-data */
3252   BLO_read_list(reader, &adt->nla_tracks);
3253   direct_link_nladata(reader, &adt->nla_tracks);
3254
3255   /* relink active track/strip - even though strictly speaking this should only be used
3256    * if we're in 'tweaking mode', we need to be able to have this loaded back for
3257    * undo, but also since users may not exit tweakmode before saving (#24535)
3258    */
3259   // TODO: it's not really nice that anyone should be able to save the file in this
3260   //      state, but it's going to be too hard to enforce this single case...
3261   BLO_read_data_address(reader, &adt->act_track);
3262   BLO_read_data_address(reader, &adt->actstrip);
3263 }
3264
3265 /** \} */
3266
3267 /* -------------------------------------------------------------------- */
3268 /** \name Read ID: CacheFiles
3269  * \{ */
3270
3271 static void lib_link_cachefiles(BlendLibReader *UNUSED(reader), CacheFile *UNUSED(cache_file))
3272 {
3273 }
3274
3275 static void direct_link_cachefile(BlendDataReader *reader, CacheFile *cache_file)
3276 {
3277   BLI_listbase_clear(&cache_file->object_paths);
3278   cache_file->handle = NULL;
3279   cache_file->handle_filepath[0] = '\0';
3280   cache_file->handle_readers = NULL;
3281
3282   /* relink animdata */
3283   BLO_read_data_address(reader, &cache_file->adt);
3284   direct_link_animdata(reader, cache_file->adt);
3285 }
3286
3287 /** \} */
3288
3289 /* -------------------------------------------------------------------- */
3290 /** \name Read ID: WorkSpace
3291  * \{ */
3292
3293 static void lib_link_workspaces(BlendLibReader *reader, WorkSpace *workspace)
3294 {
3295   ID *id = (ID *)workspace;
3296
3297   LISTBASE_FOREACH_MUTABLE (WorkSpaceLayout *, layout, &workspace->layouts) {
3298     BLO_read_id_address(reader, id->lib, &layout->screen);
3299
3300     if (layout->screen) {
3301       if (ID_IS_LINKED(id)) {
3302         layout->screen->winid = 0;
3303         if (layout->screen->temp) {
3304           /* delete temp layouts when appending */
3305           BKE_workspace_layout_remove(reader->main, workspace, layout);
3306         }
3307       }
3308     }
3309     else {
3310       /* If we're reading a layout without screen stored, it's useless and we shouldn't keep it
3311        * around. */
3312       BKE_workspace_layout_remove(reader->main, workspace, layout);
3313     }
3314   }
3315 }
3316
3317 static void direct_link_workspace(BlendDataReader *reader, WorkSpace *workspace, const Main *main)
3318 {
3319   BLO_read_list(reader, &workspace->layouts);
3320   BLO_read_list(reader, &workspace->hook_layout_relations);
3321   BLO_read_list(reader, &workspace->owner_ids);
3322   BLO_read_list(reader, &workspace->tools);
3323
3324   LISTBASE_FOREACH (WorkSpaceDataRelation *, relation, &workspace->hook_layout_relations) {
3325     /* data from window - need to access through global oldnew-map */
3326     relation->parent = newglobadr(reader->fd, relation->parent);
3327     BLO_read_data_address(reader, &relation->value);
3328   }
3329
3330   /* Same issue/fix as in direct_link_workspace_link_scene_data: Can't read workspace data
3331    * when reading windows, so have to update windows after/when reading workspaces. */
3332   for (wmWindowManager *wm = main->wm.first; wm; wm = wm->id.next) {
3333     LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
3334       BLO_read_data_address(reader, &win->workspace_hook->act_layout);
3335     }
3336   }
3337
3338   LISTBASE_FOREACH (bToolRef *, tref, &workspace->tools) {
3339     tref->runtime = NULL;
3340     BLO_read_data_address(reader, &tref->properties);
3341     IDP_DirectLinkGroup_OrFree(&tref->properties, reader);
3342   }
3343
3344   workspace->status_text = NULL;
3345
3346   id_us_ensure_real(&workspace->id);
3347 }
3348
3349 static void lib_link_workspace_instance_hook(BlendLibReader *reader,
3350                                              WorkSpaceInstanceHook *hook,
3351                                              ID *id)
3352 {
3353   WorkSpace *workspace = BKE_workspace_active_get(hook);
3354   BLO_read_id_address(reader, id->lib, &workspace);
3355   BKE_workspace_active_set(hook, workspace);
3356 }
3357
3358 /** \} */
3359
3360 /* -------------------------------------------------------------------- */
3361 /** \name Read ID: Node Tree
3362  * \{ */
3363
3364 static void lib_link_node_socket(BlendLibReader *reader, Library *lib, bNodeSocket *sock)
3365 {
3366   IDP_LibLinkProperty(sock->prop, reader);
3367
3368   switch ((eNodeSocketDatatype)sock->type) {
3369     case SOCK_OBJECT: {
3370       bNodeSocketValueObject *default_value = sock->default_value;
3371       BLO_read_id_address(reader, lib, &default_value->value);
3372       break;
3373     }
3374     case SOCK_IMAGE: {
3375       bNodeSocketValueImage *default_value = sock->default_value;
3376       BLO_read_id_address(reader, lib, &default_value->value);
3377       break;
3378     }
3379     case SOCK_FLOAT:
3380     case SOCK_VECTOR:
3381     case SOCK_RGBA:
3382     case SOCK_BOOLEAN:
3383     case SOCK_INT:
3384     case SOCK_STRING:
3385     case __SOCK_MESH:
3386     case SOCK_CUSTOM:
3387     case SOCK_SHADER:
3388     case SOCK_EMITTERS:
3389     case SOCK_EVENTS:
3390     case SOCK_FORCES:
3391     case SOCK_CONTROL_FLOW:
3392       break;
3393   }
3394 }
3395
3396 static void lib_link_node_sockets(BlendLibReader *reader, Library *lib, ListBase *sockets)
3397 {
3398   LISTBASE_FOREACH (bNodeSocket *, sock, sockets) {
3399     lib_link_node_socket(reader, lib, sock);
3400   }
3401 }
3402
3403 /* Single node tree (also used for material/scene trees), ntree is not NULL */
3404 static void lib_link_ntree(BlendLibReader *reader, Library *lib, bNodeTree *ntree)
3405 {
3406   ntree->id.lib = lib;
3407
3408   BLO_read_id_address(reader, lib, &ntree->gpd);
3409
3410   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3411     /* Link ID Properties -- and copy this comment EXACTLY for easy finding
3412      * of library blocks that implement this.*/
3413     IDP_LibLinkProperty(node->prop, reader);
3414
3415     BLO_read_id_address(reader, lib, &node->id);
3416
3417     lib_link_node_sockets(reader, lib, &node->inputs);
3418     lib_link_node_sockets(reader, lib, &node->outputs);
3419   }
3420
3421   lib_link_node_sockets(reader, lib, &ntree->inputs);
3422   lib_link_node_sockets(reader, lib, &ntree->outputs);
3423
3424   /* Set node->typeinfo pointers. This is done in lib linking, after the
3425    * first versioning that can change types still without functions that
3426    * update the typeinfo pointers. Versioning after lib linking needs
3427    * these top be valid. */
3428   ntreeSetTypes(NULL, ntree);
3429
3430   /* For nodes with static socket layout, add/remove sockets as needed
3431    * to match the static layout. */
3432   if (reader->fd->memfile == NULL) {
3433     LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3434       node_verify_socket_templates(ntree, node);
3435     }
3436   }
3437 }
3438
3439 /* library ntree linking after fileread */
3440 static void lib_link_nodetree(BlendLibReader *reader, bNodeTree *ntree)
3441 {
3442   lib_link_ntree(reader, ntree->id.lib, ntree);
3443 }
3444
3445 static void direct_link_node_socket(BlendDataReader *reader, bNodeSocket *sock)
3446 {
3447   BLO_read_data_address(reader, &sock->prop);
3448   IDP_DirectLinkGroup_OrFree(&sock->prop, reader);
3449
3450   BLO_read_data_address(reader, &sock->link);
3451   sock->typeinfo = NULL;
3452   BLO_read_data_address(reader, &sock->storage);
3453   BLO_read_data_address(reader, &sock->default_value);
3454   sock->cache = NULL;
3455 }
3456
3457 /* ntree itself has been read! */
3458 static void direct_link_nodetree(BlendDataReader *reader, bNodeTree *ntree)
3459 {
3460   /* note: writing and reading goes in sync, for speed */
3461   bNode *node;
3462   bNodeSocket *sock;
3463   bNodeLink *link;
3464
3465   ntree->init = 0; /* to set callbacks and force setting types */
3466   ntree->is_updating = false;
3467   ntree->typeinfo = NULL;
3468   ntree->interface_type = NULL;
3469
3470   ntree->progress = NULL;
3471   ntree->execdata = NULL;
3472
3473   BLO_read_data_address(reader, &ntree->adt);
3474   direct_link_animdata(reader, ntree->adt);
3475
3476   BLO_read_list(reader, &ntree->nodes);
3477   for (node = ntree->nodes.first; node; node = node->next) {
3478     node->typeinfo = NULL;
3479
3480     BLO_read_list(reader, &node->inputs);
3481     BLO_read_list(reader, &node->outputs);
3482
3483     BLO_read_data_address(reader, &node->prop);
3484     IDP_DirectLinkGroup_OrFree(&node->prop, reader);
3485
3486     BLO_read_list(reader, &node->internal_links);
3487     for (link = node->internal_links.first; link; link = link->next) {
3488       BLO_read_data_address(reader, &link->fromnode);
3489       BLO_read_data_address(reader, &link->fromsock);
3490       BLO_read_data_address(reader, &link->tonode);
3491       BLO_read_data_address(reader, &link->tosock);
3492     }
3493
3494     if (node->type == CMP_NODE_MOVIEDISTORTION) {
3495       /* Do nothing, this is runtime cache and hence handled by generic code using
3496        * `IDTypeInfo.foreach_cache` callback. */
3497     }
3498     else {
3499       BLO_read_data_address(reader, &node->storage);
3500     }
3501
3502     if (node->storage) {
3503       /* could be handlerized at some point */
3504       switch (node->type) {
3505         case SH_NODE_CURVE_VEC:
3506         case SH_NODE_CURVE_RGB:
3507         case CMP_NODE_TIME:
3508         case CMP_NODE_CURVE_VEC:
3509         case CMP_NODE_CURVE_RGB:
3510         case CMP_NODE_HUECORRECT:
3511         case TEX_NODE_CURVE_RGB:
3512         case TEX_NODE_CURVE_TIME: {
3513           BKE_curvemapping_blend_read(reader, node->storage);
3514           break;
3515         }
3516         case SH_NODE_SCRIPT: {
3517           NodeShaderScript *nss = (NodeShaderScript *)node->storage;
3518           BLO_read_data_address(reader, &nss->bytecode);
3519           break;
3520         }
3521         case SH_NODE_TEX_POINTDENSITY: {
3522           NodeShaderTexPointDensity *npd = (NodeShaderTexPointDensity *)node->storage;
3523           memset(&npd->pd, 0, sizeof(npd->pd));
3524           break;
3525         }
3526         case SH_NODE_TEX_IMAGE: {
3527           NodeTexImage *tex = (NodeTexImage *)node->storage;
3528           tex->iuser.ok = 1;
3529           tex->iuser.scene = NULL;
3530           break;
3531         }
3532         case SH_NODE_TEX_ENVIRONMENT: {
3533           NodeTexEnvironment *tex = (NodeTexEnvironment *)node->storage;
3534           tex->iuser.ok = 1;
3535           tex->iuser.scene = NULL;
3536           break;
3537         }
3538         case CMP_NODE_IMAGE:
3539         case CMP_NODE_R_LAYERS:
3540         case CMP_NODE_VIEWER:
3541         case CMP_NODE_SPLITVIEWER: {
3542           ImageUser *iuser = node->storage;
3543           iuser->ok = 1;
3544           iuser->scene = NULL;
3545           break;
3546         }
3547         case CMP_NODE_CRYPTOMATTE: {
3548           NodeCryptomatte *nc = (NodeCryptomatte *)node->storage;
3549           BLO_read_data_address(reader, &nc->matte_id);
3550           break;
3551         }
3552         case TEX_NODE_IMAGE: {
3553           ImageUser *iuser = node->storage;
3554           iuser->ok = 1;
3555           iuser->scene = NULL;
3556           break;
3557         }
3558         default:
3559           break;
3560       }
3561     }
3562   }
3563   BLO_read_list(reader, &ntree->links);
3564
3565   /* and we connect the rest */
3566   for (node = ntree->nodes.first; node; node = node->next) {
3567     BLO_read_data_address(reader, &node->parent);
3568     node->lasty = 0;
3569
3570     for (sock = node->inputs.first; sock; sock = sock->next) {
3571       direct_link_node_socket(reader, sock);
3572     }
3573     for (sock = node->outputs.first; sock; sock = sock->next) {
3574       direct_link_node_socket(reader, sock);
3575     }
3576   }
3577
3578   /* interface socket lists */
3579   BLO_read_list(reader, &ntree->inputs);
3580   BLO_read_list(reader, &ntree->outputs);
3581   for (sock = ntree->inputs.first; sock; sock = sock->next) {
3582     direct_link_node_socket(reader, sock);
3583   }
3584   for (sock = ntree->outputs.first; sock; sock = sock->next) {
3585     direct_link_node_socket(reader, sock);
3586   }
3587
3588   for (link = ntree->links.first; link; link = link->next) {
3589     BLO_read_data_address(reader, &link->fromnode);
3590     BLO_read_data_address(reader, &link->tonode);
3591     BLO_read_data_address(reader, &link->fromsock);
3592     BLO_read_data_address(reader, &link->tosock);
3593   }
3594
3595   /* TODO, should be dealt by new generic cache handling of IDs... */
3596   ntree->previews = NULL;
3597
3598   /* type verification is in lib-link */
3599 }
3600
3601 /** \} */
3602
3603 /* -------------------------------------------------------------------- */
3604 /** \name Read ID: Armature
3605  * \{ */
3606
3607 /* temp struct used to transport needed info to lib_link_constraint_cb() */
3608 typedef struct tConstraintLinkData {
3609   BlendLibReader *reader;
3610   ID *id;
3611 } tConstraintLinkData;
3612 /* callback function used to relink constraint ID-links */
3613 static void lib_link_constraint_cb(bConstraint *UNUSED(con),
3614                                    ID **idpoin,
3615                                    bool UNUSED(is_reference),
3616                                    void *userdata)
3617 {
3618   tConstraintLinkData *cld = (tConstraintLinkData *)userdata;
3619   BLO_read_id_address(cld->reader, cld->id->lib, idpoin);
3620 }
3621
3622 static void lib_link_constraints(BlendLibReader *reader, ID *id, ListBase *conlist)
3623 {
3624   tConstraintLinkData cld;
3625   bConstraint *con;
3626
3627   /* legacy fixes */
3628   for (con = conlist->first; con; con = con->next) {
3629     /* patch for error introduced by changing constraints (dunno how) */
3630     /* if con->data type changes, dna cannot resolve the pointer! (ton) */
3631     if (con->data == NULL) {
3632       con->type = CONSTRAINT_TYPE_NULL;
3633     }
3634     /* own ipo, all constraints have it */
3635     BLO_read_id_address(reader, id->lib, &con->ipo);  // XXX deprecated - old animation system
3636
3637     /* If linking from a library, clear 'local' library override flag. */
3638     if (id->lib != NULL) {
3639       con->flag &= ~CONSTRAINT_OVERRIDE_LIBRARY_LOCAL;
3640     }
3641   }
3642
3643   /* relink all ID-blocks used by the constraints */
3644   cld.reader = reader;
3645   cld.id = id;
3646
3647   BKE_constraints_id_loop(conlist, lib_link_constraint_cb, &cld);
3648 }
3649
3650 static void direct_link_constraints(BlendDataReader *reader, ListBase *lb)
3651 {
3652   bConstraint *con;
3653
3654   BLO_read_list(reader, lb);
3655   for (con = lb->first; con; con = con->next) {
3656     BLO_read_data_address(reader, &con->data);
3657
3658     switch (con->type) {
3659       case CONSTRAINT_TYPE_PYTHON: {
3660         bPythonConstraint *data = con->data;
3661
3662         BLO_read_list(reader, &data->targets);
3663
3664         BLO_read_data_address(reader, &data->prop);
3665         IDP_DirectLinkGroup_OrFree(&data->prop, reader);
3666         break;
3667       }
3668       case CONSTRAINT_TYPE_ARMATURE: {
3669         bArmatureConstraint *data = con->data;
3670
3671         BLO_read_list(reader, &data->targets);
3672
3673         break;
3674       }
3675       case CONSTRAINT_TYPE_SPLINEIK: {
3676         bSplineIKConstraint *data = con->data;
3677
3678         BLO_read_data_address(reader, &data->points);
3679         break;
3680       }
3681       case CONSTRAINT_TYPE_KINEMATIC: {
3682         bKinematicConstraint *data = con->data;
3683
3684         con->lin_error = 0.f;
3685         con->rot_error = 0.f;
3686
3687         /* version patch for runtime flag, was not cleared in some case */
3688         data->flag &= ~CONSTRAINT_IK_AUTO;
3689         break;
3690       }
3691       case CONSTRAINT_TYPE_CHILDOF: {
3692         /* XXX version patch, in older code this flag wasn't always set, and is inherent to type */
3693         if (con->ownspace == CONSTRAINT_SPACE_POSE) {
3694           con->flag |= CONSTRAINT_SPACEONCE;
3695         }
3696         break;
3697       }
3698       case CONSTRAINT_TYPE_TRANSFORM_CACHE: {
3699         bTransformCacheConstraint *data = con->data;
3700         data->reader = NULL;
3701         data->reader_object_path[0] = '\0';
3702       }
3703     }
3704   }
3705 }
3706
3707 static void lib_link_pose(BlendLibReader *reader, Object *ob, bPose *pose)
3708 {
3709   bArmature *arm = ob->data;
3710
3711   if (!pose || !arm) {
3712     return;
3713   }
3714
3715   /* always rebuild to match proxy or lib changes, but on Undo */
3716   bool rebuild = false;
3717
3718   if (reader->fd->memfile == NULL) {
3719     if (ob->proxy || ob->id.lib != arm->id.lib) {
3720       rebuild = true;
3721     }
3722   }
3723
3724   if (ob->proxy) {
3725     /* sync proxy layer */
3726     if (pose->proxy_layer) {
3727       arm->layer = pose->proxy_layer;
3728     }
3729
3730     /* sync proxy active bone */
3731     if (pose->proxy_act_bone[0]) {
3732       Bone *bone = BKE_armature_find_bone_name(arm, pose->proxy_act_bone);
3733       if (bone) {
3734         arm->act_bone = bone;
3735       }
3736     }
3737   }
3738
3739   LISTBASE_FOREACH (bPoseChannel *, pchan, &pose->chanbase) {
3740     lib_link_constraints(reader, (ID *)ob, &pchan->constraints);
3741
3742     pchan->bone = BKE_armature_find_bone_name(arm, pchan->name);
3743
3744     IDP_LibLinkProperty(pchan->prop, reader);
3745
3746     BLO_read_id_address(reader, arm->id.lib, &pchan->custom);
3747     if (UNLIKELY(pchan->bone == NULL)) {
3748       rebuild = true;
3749     }
3750     else if ((ob->id.lib == NULL) && arm->id.lib) {
3751       /* local pose selection copied to armature, bit hackish */
3752       pchan->bone->flag &= ~BONE_SELECTED;
3753       pchan->bone->flag |= pchan->selectflag;
3754     }
3755   }
3756
3757   if (rebuild) {
3758     DEG_id_tag_update_ex(
3759         reader->main, &ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
3760     BKE_pose_tag_recalc(reader->main, pose);
3761   }
3762 }
3763
3764 static void lib_link_bones(BlendLibReader *reader, Bone *bone)
3765 {
3766   IDP_LibLinkProperty(bone->prop, reader);
3767
3768   LISTBASE_FOREACH (Bone *, curbone, &bone->childbase) {
3769     lib_link_bones(reader, curbone);
3770   }
3771 }
3772
3773 static void lib_link_armature(BlendLibReader *reader, bArmature *arm)
3774 {
3775   LISTBASE_FOREACH (Bone *, curbone, &arm->bonebase) {
3776     lib_link_bones(reader, curbone);
3777   }
3778 }
3779
3780 static void direct_link_bones(BlendDataReader *reader, Bone *bone)
3781 {
3782   Bone *child;
3783
3784   BLO_read_data_address(reader, &bone->parent);
3785   BLO_read_data_address(reader, &bone->prop);
3786   IDP_DirectLinkGroup_OrFree(&bone->prop, reader);
3787
3788   BLO_read_data_address(reader, &bone->bbone_next);
3789   BLO_read_data_address(reader, &bone->bbone_prev);
3790
3791   bone->flag &= ~(BONE_DRAW_ACTIVE | BONE_DRAW_LOCKED_WEIGHT);
3792
3793   BLO_read_list(reader, &bone->childbase);
3794
3795   for (child = bone->childbase.first; child; child = child->next) {
3796     direct_link_bones(reader, child);
3797   }
3798 }
3799
3800 static void direct_link_armature(BlendDataReader *reader, bArmature *arm)
3801 {
3802   Bone *bone;
3803
3804   BLO_read_list(reader, &arm->bonebase);
3805   arm->bonehash = NULL;
3806   arm->edbo = NULL;
3807   /* Must always be cleared (armatures don't have their own edit-data). */
3808   arm->needs_flush_to_id = 0;
3809
3810   BLO_read_data_address(reader, &arm->adt);
3811   direct_link_animdata(reader, arm->adt);
3812
3813   for (bone = arm->bonebase.first; bone; bone = bone->next) {
3814     direct_link_bones(reader, bone);
3815   }
3816
3817   BLO_read_data_address(reader, &arm->act_bone);
3818   arm->act_edbone = NULL;
3819
3820   BKE_armature_bone_hash_make(arm);
3821 }
3822
3823 /** \} */
3824
3825 /* -------------------------------------------------------------------- */
3826 /** \name Read ID: Camera
3827  * \{ */
3828
3829 static void lib_link_camera(BlendLibReader *reader, Camera *ca)
3830 {
3831   BLO_read_id_address(reader, ca->id.lib, &ca->ipo); /* deprecated, for versioning */
3832
3833   BLO_read_id_address(reader, ca->id.lib, &ca->dof_ob); /* deprecated, for versioning */
3834   BLO_read_id_address(reader, ca->id.lib, &ca->dof.focus_object);
3835
3836   LISTBASE_FOREACH (CameraBGImage *, bgpic, &ca->bg_images) {
3837     BLO_read_id_address(reader, ca->id.lib, &bgpic->ima);
3838     BLO_read_id_address(reader, ca->id.lib, &bgpic->clip);
3839   }
3840 }
3841
3842 static void direct_link_camera(BlendDataReader *reader, Camera *ca)
3843 {
3844   BLO_read_data_address(reader, &ca->adt);
3845   direct_link_animdata(reader, ca->adt);
3846
3847   BLO_read_list(reader, &ca->bg_images);
3848
3849   LISTBASE_FOREACH (CameraBGImage *, bgpic, &ca->bg_images) {
3850     bgpic->iuser.ok = 1;
3851     bgpic->iuser.scene = NULL;
3852   }
3853 }
3854
3855 /** \} */
3856
3857 /* -------------------------------------------------------------------- */
3858 /** \name Read ID: Light
3859  * \{ */
3860
3861 static void lib_link_light(BlendLibReader *reader, Light *la)
3862 {
3863   BLO_read_id_address(reader, la->id.lib, &la->ipo);  // XXX deprecated - old animation system
3864 }
3865
3866 static void direct_link_light(BlendDataReader *reader, Light *la)
3867 {
3868   BLO_read_data_address(reader, &la->adt);
3869   direct_link_animdata(reader, la->adt);
3870
3871   BLO_read_data_address(reader, &la->curfalloff);
3872   if (la->curfalloff) {
3873     BKE_curvemapping_blend_read(reader, la->curfalloff);
3874   }
3875
3876   la->preview = direct_link_preview_image(reader, la->preview);
3877 }
3878
3879 /** \} */
3880
3881 /* -------------------------------------------------------------------- */
3882 /** \name Read ID: Shape Keys
3883  * \{ */
3884
3885 void blo_do_versions_key_uidgen(Key *key)
3886 {
3887   KeyBlock *block;
3888
3889   key->uidgen = 1;
3890   for (block = key->block.first; block; block = block->next) {
3891     block->uid = key->uidgen++;
3892   }
3893 }
3894
3895 static void lib_link_key(BlendLibReader *reader, Key *key)
3896 {
3897   BLI_assert((key->id.tag & LIB_TAG_EXTERN) == 0);
3898
3899   BLO_read_id_address(reader, key->id.lib, &key->ipo);  // XXX deprecated - old animation system
3900   BLO_read_id_address(reader, key->id.lib, &key->from);
3901 }
3902
3903 static void switch_endian_keyblock(Key *key, KeyBlock *kb)
3904 {
3905   int elemsize, a, b;
3906   char *data;
3907
3908   elemsize = key->elemsize;
3909   data = kb->data;
3910
3911   for (a = 0; a < kb->totelem; a++) {
3912     const char *cp = key->elemstr;
3913     char *poin = data;
3914
3915     while (cp[0]) {    /* cp[0] == amount */
3916       switch (cp[1]) { /* cp[1] = type */
3917         case IPO_FLOAT:
3918         case IPO_BPOINT:
3919         case IPO_BEZTRIPLE:
3920           b = cp[0];
3921           BLI_endian_switch_float_array((float *)poin, b);
3922           poin += sizeof(float) * b;
3923           break;
3924       }
3925
3926       cp += 2;
3927     }
3928     data += elemsize;
3929   }
3930 }
3931
3932 static void direct_link_key(BlendDataReader *reader, Key *key)
3933 {
3934   KeyBlock *kb;
3935
3936   BLO_read_list(reader, &(key->block));
3937
3938   BLO_read_data_address(reader, &key->adt);
3939   direct_link_animdata(reader, key->adt);
3940
3941   BLO_read_data_address(reader, &key->refkey);
3942
3943   for (kb = key->block.first; kb; kb = kb->next) {
3944     BLO_read_data_address(reader, &kb->data);
3945
3946     if (BLO_read_requires_endian_switch(reader)) {
3947       switch_endian_keyblock(key, kb);
3948     }
3949   }
3950 }
3951
3952 /** \} */
3953
3954 /* -------------------------------------------------------------------- */
3955 /** \name Read ID: Meta Ball
3956  * \{ */
3957
3958 static void lib_link_mball(BlendLibReader *reader, MetaBall *mb)
3959 {
3960   for (int a = 0; a < mb->totcol; a++) {
3961     BLO_read_id_address(reader, mb->id.lib, &mb->mat[a]);
3962   }
3963
3964   BLO_read_id_address(reader, mb->id.lib, &mb->ipo);  // XXX deprecated - old animation system
3965 }
3966
3967 static void direct_link_mball(BlendDataReader *reader, MetaBall *mb)
3968 {
3969   BLO_read_data_address(reader, &mb->adt);
3970   direct_link_animdata(reader, mb->adt);
3971
3972   BLO_read_pointer_array(reader, (void **)&mb->mat);
3973
3974   BLO_read_list(reader, &(mb->elems));
3975
3976   BLI_listbase_clear(&mb->disp);
3977   mb->editelems = NULL;
3978   /* Must always be cleared (meta's don't have their own edit-data). */
3979   mb->needs_flush_to_id = 0;
3980   /*  mb->edit_elems.first= mb->edit_elems.last= NULL;*/
3981   mb->lastelem = NULL;
3982   mb->batch_cache = NULL;
3983 }
3984
3985 /** \} */
3986
3987 /* -------------------------------------------------------------------- */
3988 /** \name Read ID: World
3989  * \{ */
3990
3991 static void lib_link_world(BlendLibReader *reader, World *wrld)
3992 {
3993   BLO_read_id_address(reader, wrld->id.lib, &wrld->ipo);  // XXX deprecated - old animation system
3994 }
3995
3996 static void direct_link_world(BlendDataReader *reader, World *wrld)
3997 {
3998   BLO_read_data_address(reader, &wrld->adt);
3999   direct_link_animdata(reader, wrld->adt);
4000
4001   wrld->preview = direct_link_preview_image(reader, wrld->preview);
4002   BLI_listbase_clear(&wrld->gpumaterial);
4003 }
4004
4005 /** \} */
4006
4007 /* -------------------------------------------------------------------- */
4008 /** \name Read ID: VFont
4009  * \{ */
4010
4011 static void lib_link_vfont(BlendLibReader *UNUSED(reader), VFont *UNUSED(vf))
4012 {
4013 }
4014
4015 static void direct_link_vfont(BlendDataReader *reader, VFont *vf)
4016 {
4017   vf->data = NULL;
4018   vf->temp_pf = NULL;
4019   vf->packedfile = direct_link_packedfile(reader, vf->packedfile);
4020 }
4021
4022 /** \} */
4023
4024 /* -------------------------------------------------------------------- */
4025 /** \name Read ID: Text
4026  * \{ */
4027
4028 static void lib_link_text(BlendLibReader *UNUSED(reader), Text *UNUSED(text))
4029 {
4030 }
4031
4032 static void direct_link_text(BlendDataReader *reader, Text *text)
4033 {
4034   TextLine *ln;
4035
4036   BLO_read_data_address(reader, &text->filepath);
4037
4038   text->compiled = NULL;
4039
4040 #if 0
4041   if (text->flags & TXT_ISEXT) {
4042     BKE_text_reload(text);
4043   }
4044   /* else { */
4045 #endif
4046
4047   BLO_read_list(reader, &text->lines);
4048
4049   BLO_read_data_address(reader, &text->curl);
4050   BLO_read_data_address(reader, &text->sell);
4051
4052   for (ln = text->lines.first; ln; ln = ln->next) {
4053     BLO_read_data_address(reader, &ln->line);
4054     ln->format = NULL;
4055
4056     if (ln->len != (int)strlen(ln->line)) {
4057       printf("Error loading text, line lengths differ\n");
4058       ln->len = strlen(ln->line);
4059     }
4060   }
4061
4062   text->flags = (text->flags) & ~TXT_ISEXT;
4063
4064   id_us_ensure_real(&text->id);
4065 }
4066
4067 /** \} */
4068
4069 /* -------------------------------------------------------------------- */
4070 /** \name Read ID: Image
4071  * \{ */
4072
4073 static void lib_link_image(BlendLibReader *UNUSED(reader), Image *ima)
4074 {
4075   /* Images have some kind of 'main' cache, when NULL we should also clear all others. */
4076   /* Needs to be done *after* cache pointers are restored (call to
4077    * `foreach_cache`/`blo_cache_storage_entry_restore_in_new`), easier for now to do it in
4078    * lib_link... */
4079   if (ima->cache == NULL) {
4080     BKE_image_free_buffers(ima);
4081   }
4082 }
4083
4084 static void direct_link_image(BlendDataReader *reader, Image *ima)
4085 {
4086   ImagePackedFile *imapf;
4087
4088   BLO_read_list(reader, &ima->tiles);
4089
4090   BLO_read_list(reader, &(ima->renderslots));
4091   if (reader->fd->memfile == NULL) {
4092     /* We reset this last render slot index only when actually reading a file, not for undo. */
4093     ima->last_render_slot = ima->render_slot;
4094   }
4095
4096   BLO_read_list(reader, &(ima->views));
4097   BLO_read_list(reader, &(ima->packedfiles));
4098
4099   if (ima->packedfiles.first) {
4100     for (imapf = ima->packedfiles.first; imapf; imapf = imapf->next) {
4101       imapf->packedfile = direct_link_packedfile(reader, imapf->packedfile);
4102     }
4103     ima->packedfile = NULL;
4104   }
4105   else {
4106     ima->packedfile = direct_link_packedfile(reader, ima->packedfile);
4107   }
4108
4109   BLI_listbase_clear(&ima->anims);
4110   ima->preview = direct_link_preview_image(reader, ima->preview);
4111   BLO_read_data_address(reader, &ima->stereo3d_format);
4112   LISTBASE_FOREACH (ImageTile *, tile, &ima->tiles) {
4113     tile->ok = IMA_OK;
4114   }
4115 }
4116
4117 /** \} */
4118
4119 /* -------------------------------------------------------------------- */
4120 /** \name Read ID: Curve
4121  * \{ */
4122
4123 static void lib_link_curve(BlendLibReader *reader, Curve *cu)
4124 {
4125   for (int a = 0; a < cu->totcol; a++) {
4126     BLO_read_id_address(reader, cu->id.lib, &cu->mat[a]);
4127   }
4128
4129   BLO_read_id_address(reader, cu->id.lib, &cu->bevobj);
4130   BLO_read_id_address(reader, cu->id.lib, &cu->taperobj);
4131   BLO_read_id_address(reader, cu->id.lib, &cu->textoncurve);
4132   BLO_read_id_address(reader, cu->id.lib, &cu->vfont);
4133   BLO_read_id_address(reader, cu->id.lib, &cu->vfontb);
4134   BLO_read_id_address(reader, cu->id.lib, &cu->vfonti);
4135   BLO_read_id_address(reader, cu->id.lib, &cu->vfontbi);
4136
4137   BLO_read_id_address(reader, cu->id.lib, &cu->ipo);  // XXX deprecated - old animation system
4138   BLO_read_id_address(reader, cu->id.lib, &cu->key);
4139 }
4140
4141 static void switch_endian_knots(Nurb *nu)
4142 {
4143   if (nu->knotsu) {
4144     BLI_endian_switch_float_array(nu->knotsu, KNOTSU(nu));
4145   }
4146   if (nu->knotsv) {
4147     BLI_endian_switch_float_array(nu->knotsv, KNOTSV(nu));
4148   }
4149 }
4150
4151 static void direct_link_curve(BlendDataReader *reader, Curve *cu)
4152 {
4153   Nurb *nu;
4154   TextBox *tb;
4155
4156   BLO_read_data_address(reader, &cu->adt);
4157   direct_link_animdata(reader, cu->adt);
4158
4159   /* Protect against integer overflow vulnerability. */
4160   CLAMP(cu->len_char32, 0, INT_MAX - 4);
4161
4162   BLO_read_pointer_array(reader, (void **)&cu->mat);
4163
4164   BLO_read_data_address(reader, &cu->str);
4165   BLO_read_data_address(reader, &cu->strinfo);
4166   BLO_read_data_address(reader, &cu->tb);
4167
4168   if (cu->vfont == NULL) {
4169     BLO_read_list(reader, &(cu->nurb));
4170   }
4171   else {
4172     cu->nurb.first = cu->nurb.last = NULL;
4173
4174     tb = MEM_calloc_arrayN(MAXTEXTBOX, sizeof(TextBox), "TextBoxread");
4175     if (cu->tb) {
4176       memcpy(tb, cu->tb, cu->totbox * sizeof(TextBox));
4177       MEM_freeN(cu->tb);
4178       cu->tb = tb;
4179     }
4180     else {
4181       cu->totbox = 1;
4182       cu->actbox = 1;
4183       cu->tb = tb;
4184       cu->tb[0].w = cu->linewidth;
4185     }
4186     if (cu->wordspace == 0.0f) {
4187       cu->wordspace = 1.0f;
4188     }
4189   }
4190
4191   cu->editnurb = NULL;
4192   cu->editfont = NULL;
4193   cu->batch_cache = NULL;
4194
4195   for (nu = cu->nurb.first; nu; nu = nu->next) {
4196     BLO_read_data_address(reader, &nu->bezt);
4197     BLO_read_data_address(reader, &nu->bp);
4198     BLO_read_data_address(reader, &nu->knotsu);
4199     BLO_read_data_address(reader, &nu->knotsv);
4200     if (cu->vfont == NULL) {
4201       nu->charidx = 0;
4202     }
4203
4204     if (BLO_read_requires_endian_switch(reader)) {
4205       switch_endian_knots(nu);
4206     }
4207   }
4208   cu->texflag &= ~CU_AUTOSPACE_EVALUATED;
4209 }
4210
4211 /** \} */
4212
4213 /* -------------------------------------------------------------------- */
4214 /** \name Read ID: Texture
4215  * \{ */
4216
4217 static void lib_link_texture(BlendLibReader *reader, Tex *tex)
4218 {
4219   BLO_read_id_address(reader, tex->id.lib, &tex->ima);
4220   BLO_read_id_address(reader, tex->id.lib, &tex->ipo);  // XXX deprecated - old animation system
4221 }
4222
4223 static void direct_link_texture(BlendDataReader *reader, Tex *tex)
4224 {
4225   BLO_read_data_address(reader, &tex->adt);
4226   direct_link_animdata(reader, tex->adt);
4227
4228   BLO_read_data_address(reader, &tex->coba);
4229
4230   tex->preview = direct_link_preview_image(reader, tex->preview);
4231
4232   tex->iuser.ok = 1;
4233   tex->iuser.scene = NULL;
4234 }
4235
4236 /** \} */
4237
4238 /* -------------------------------------------------------------------- */
4239 /** \name Read ID: Material
4240  * \{ */
4241
4242 static void lib_link_material(BlendLibReader *reader, Material *ma)
4243 {
4244   BLO_read_id_address(reader, ma->id.lib, &ma->ipo);  // XXX deprecated - old animation system
4245
4246   /* relink grease pencil settings */
4247   if (ma->gp_style != NULL) {
4248     MaterialGPencilStyle *gp_style = ma->gp_style;
4249     if (gp_style->sima != NULL) {
4250       BLO_read_id_address(reader, ma->id.lib, &gp_style->sima);
4251     }
4252     if (gp_style->ima != NULL) {
4253       BLO_read_id_address(reader, ma->id.lib, &gp_style->ima);
4254     }
4255   }
4256 }
4257
4258 static void direct_link_material(BlendDataReader *reader, Material *ma)
4259 {
4260   BLO_read_data_address(reader, &ma->adt);
4261   direct_link_animdata(reader, ma->adt);
4262
4263   ma->texpaintslot = NULL;
4264
4265   ma->preview = direct_link_preview_image(reader, ma->preview);
4266   BLI_listbase_clear(&ma->gpumaterial);
4267
4268   BLO_read_data_address(reader, &ma->gp_style);
4269 }
4270
4271 /** \} */
4272
4273 /* -------------------------------------------------------------------- */
4274 /** \name Read ID: Particle Settings
4275  * \{ */
4276
4277 /* update this also to writefile.c */
4278 static const char *ptcache_data_struct[] = {
4279     "",          // BPHYS_DATA_INDEX
4280     "",          // BPHYS_DATA_LOCATION
4281     "",          // BPHYS_DATA_VELOCITY
4282     "",          // BPHYS_DATA_ROTATION
4283     "",          // BPHYS_DATA_AVELOCITY / BPHYS_DATA_XCONST */
4284     "",          // BPHYS_DATA_SIZE:
4285     "",          // BPHYS_DATA_TIMES:
4286     "BoidData",  // case BPHYS_DATA_BOIDS:
4287 };
4288
4289 static void direct_link_pointcache_cb(BlendDataReader *reader, void *data)
4290 {
4291   PTCacheMem *pm = data;
4292   PTCacheExtra *extra;
4293   int i;
4294   for (i = 0; i < BPHYS_TOT_DATA; i++) {
4295     BLO_read_data_address(reader, &pm->data[i]);
4296
4297     /* the cache saves non-struct data without DNA */
4298     if (pm->data[i] && ptcache_data_struct[i][0] == '\0' &&
4299         BLO_read_requires_endian_switch(reader)) {
4300       /* data_size returns bytes. */
4301       int tot = (BKE_ptcache_data_size(i) * pm->totpoint) / sizeof(int);
4302
4303       int *poin = pm->data[i];
4304
4305       BLI_endian_switch_int32_array(poin, tot);
4306     }
4307   }
4308
4309   BLO_read_list(reader, &pm->extradata);
4310
4311   for (extra = pm->extradata.first; extra; extra = extra->next) {
4312     BLO_read_data_address(reader, &extra->data);
4313   }
4314 }
4315
4316 static void direct_link_pointcache(BlendDataReader *reader, PointCache *cache)
4317 {
4318   if ((cache->flag & PTCACHE_DISK_CACHE) == 0) {
4319     BLO_read_list_cb(reader, &cache->mem_cache, direct_link_pointcache_cb);
4320   }
4321   else {
4322     BLI_listbase_clear(&cache->mem_cache);
4323   }
4324
4325   cache->flag &= ~PTCACHE_SIMULATION_VALID;
4326   cache->simframe = 0;
4327   cache->edit = NULL;
4328   cache->free_edit = NULL;
4329   cache->cached_frames = NULL;
4330   cache->cached_frames_len = 0;
4331 }
4332
4333 static void direct_link_pointcache_list(BlendDataReader *reader,
4334                                         ListBase *ptcaches,
4335                                         PointCache **ocache,
4336                                         int force_disk)
4337 {
4338   if (ptcaches->first) {
4339     PointCache *cache = NULL;
4340     BLO_read_list(reader, ptcaches);
4341     for (cache = ptcaches->first; cache; cache = cache->next) {
4342       direct_link_pointcache(reader, cache);
4343       if (force_disk) {
4344         cache->flag |= PTCACHE_DISK_CACHE;
4345         cache->step = 1;
4346       }
4347     }
4348
4349     BLO_read_data_address(reader, ocache);
4350   }
4351   else if (*ocache) {
4352     /* old "single" caches need to be linked too */
4353     BLO_read_data_address(reader, ocache);
4354     direct_link_pointcache(reader, *ocache);
4355     if (force_disk) {
4356       (*ocache)->flag |= PTCACHE_DISK_CACHE;
4357       (*ocache)->step = 1;
4358     }
4359
4360     ptcaches->first = ptcaches->last = *ocache;
4361   }
4362 }
4363
4364 static void lib_link_partdeflect(BlendLibReader *reader, ID *id, PartDeflect *pd)
4365 {
4366   if (pd && pd->tex) {
4367     BLO_read_id_address(reader, id->lib, &pd->tex);