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