de6e5a80912ec27a8b242da40a2509d4d2535013
[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 doesnt 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 ist'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 /* this function ensures that reports are printed,
275  * in the case of libraray linking errors this is important!
276  *
277  * bit kludge but better then doubling up on prints,
278  * we could alternatively have a versions of a report function which forces printing - campbell
279  */
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) (1 << (onm)->capacity_exp)
328 #define MAP_CAPACITY(onm) (1 << ((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 incase '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 datablock 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 datablock itself to 'main' Main, since libraries are **never** linked data.
680    * Fixes bug where you could end with all ID_LI datablocks having the same name... */
681   lib = BKE_libblock_alloc(mainlist->first, ID_LI, BLI_path_basename(filepath), 0);
682   lib->id.us = ID_FAKE_USERS(
683       lib); /* Important, consistency with main ID reading code from read_libblock(). */
684   BLI_strncpy(lib->name, filepath, sizeof(lib->name));
685   BLI_strncpy(lib->filepath, name1, sizeof(lib->filepath));
686
687   m->curlib = lib;
688
689   read_file_version(fd, m);
690
691   if (G.debug & G_DEBUG) {
692     printf("blo_find_main: added new lib %s\n", filepath);
693   }
694   return m;
695 }
696
697 /** \} */
698
699 /* -------------------------------------------------------------------- */
700 /** \name File Parsing
701  * \{ */
702
703 static void switch_endian_bh4(BHead4 *bhead)
704 {
705   /* the ID_.. codes */
706   if ((bhead->code & 0xFFFF) == 0) {
707     bhead->code >>= 16;
708   }
709
710   if (bhead->code != ENDB) {
711     BLI_endian_switch_int32(&bhead->len);
712     BLI_endian_switch_int32(&bhead->SDNAnr);
713     BLI_endian_switch_int32(&bhead->nr);
714   }
715 }
716
717 static void switch_endian_bh8(BHead8 *bhead)
718 {
719   /* the ID_.. codes */
720   if ((bhead->code & 0xFFFF) == 0) {
721     bhead->code >>= 16;
722   }
723
724   if (bhead->code != ENDB) {
725     BLI_endian_switch_int32(&bhead->len);
726     BLI_endian_switch_int32(&bhead->SDNAnr);
727     BLI_endian_switch_int32(&bhead->nr);
728   }
729 }
730
731 static void bh4_from_bh8(BHead *bhead, BHead8 *bhead8, int do_endian_swap)
732 {
733   BHead4 *bhead4 = (BHead4 *)bhead;
734   int64_t old;
735
736   bhead4->code = bhead8->code;
737   bhead4->len = bhead8->len;
738
739   if (bhead4->code != ENDB) {
740     /* perform a endian swap on 64bit pointers, otherwise the pointer might map to zero
741      * 0x0000000000000000000012345678 would become 0x12345678000000000000000000000000
742      */
743     if (do_endian_swap) {
744       BLI_endian_switch_int64(&bhead8->old);
745     }
746
747     /* this patch is to avoid a long long being read from not-eight aligned positions
748      * is necessary on any modern 64bit architecture) */
749     memcpy(&old, &bhead8->old, 8);
750     bhead4->old = (int)(old >> 3);
751
752     bhead4->SDNAnr = bhead8->SDNAnr;
753     bhead4->nr = bhead8->nr;
754   }
755 }
756
757 static void bh8_from_bh4(BHead *bhead, BHead4 *bhead4)
758 {
759   BHead8 *bhead8 = (BHead8 *)bhead;
760
761   bhead8->code = bhead4->code;
762   bhead8->len = bhead4->len;
763
764   if (bhead8->code != ENDB) {
765     bhead8->old = bhead4->old;
766     bhead8->SDNAnr = bhead4->SDNAnr;
767     bhead8->nr = bhead4->nr;
768   }
769 }
770
771 static BHeadN *get_bhead(FileData *fd)
772 {
773   BHeadN *new_bhead = NULL;
774   int readsize;
775
776   if (fd) {
777     if (!fd->is_eof) {
778       /* initializing to zero isn't strictly needed but shuts valgrind up
779        * since uninitialized memory gets compared */
780       BHead8 bhead8 = {0};
781       BHead4 bhead4 = {0};
782       BHead bhead = {0};
783
784       /* First read the bhead structure.
785        * Depending on the platform the file was written on this can
786        * be a big or little endian BHead4 or BHead8 structure.
787        *
788        * As usual 'ENDB' (the last *partial* bhead of the file)
789        * needs some special handling. We don't want to EOF just yet.
790        */
791       if (fd->flags & FD_FLAGS_FILE_POINTSIZE_IS_4) {
792         bhead4.code = DATA;
793         readsize = fd->read(fd, &bhead4, sizeof(bhead4));
794
795         if (readsize == sizeof(bhead4) || bhead4.code == ENDB) {
796           if (fd->flags & FD_FLAGS_SWITCH_ENDIAN) {
797             switch_endian_bh4(&bhead4);
798           }
799
800           if (fd->flags & FD_FLAGS_POINTSIZE_DIFFERS) {
801             bh8_from_bh4(&bhead, &bhead4);
802           }
803           else {
804             /* MIN2 is only to quiet '-Warray-bounds' compiler warning. */
805             BLI_assert(sizeof(bhead) == sizeof(bhead4));
806             memcpy(&bhead, &bhead4, MIN2(sizeof(bhead), sizeof(bhead4)));
807           }
808         }
809         else {
810           fd->is_eof = true;
811           bhead.len = 0;
812         }
813       }
814       else {
815         bhead8.code = DATA;
816         readsize = fd->read(fd, &bhead8, sizeof(bhead8));
817
818         if (readsize == sizeof(bhead8) || bhead8.code == ENDB) {
819           if (fd->flags & FD_FLAGS_SWITCH_ENDIAN) {
820             switch_endian_bh8(&bhead8);
821           }
822
823           if (fd->flags & FD_FLAGS_POINTSIZE_DIFFERS) {
824             bh4_from_bh8(&bhead, &bhead8, (fd->flags & FD_FLAGS_SWITCH_ENDIAN));
825           }
826           else {
827             /* MIN2 is only to quiet '-Warray-bounds' compiler warning. */
828             BLI_assert(sizeof(bhead) == sizeof(bhead8));
829             memcpy(&bhead, &bhead8, MIN2(sizeof(bhead), sizeof(bhead8)));
830           }
831         }
832         else {
833           fd->is_eof = true;
834           bhead.len = 0;
835         }
836       }
837
838       /* make sure people are not trying to pass bad blend files */
839       if (bhead.len < 0) {
840         fd->is_eof = true;
841       }
842
843       /* bhead now contains the (converted) bhead structure. Now read
844        * the associated data and put everything in a BHeadN (creative naming !)
845        */
846       if (fd->is_eof) {
847         /* pass */
848       }
849 #ifdef USE_BHEAD_READ_ON_DEMAND
850       else if (fd->seek != NULL && BHEAD_USE_READ_ON_DEMAND(&bhead)) {
851         /* Delay reading bhead content. */
852         new_bhead = MEM_mallocN(sizeof(BHeadN), "new_bhead");
853         if (new_bhead) {
854           new_bhead->next = new_bhead->prev = NULL;
855           new_bhead->file_offset = fd->file_offset;
856           new_bhead->has_data = false;
857           new_bhead->bhead = bhead;
858           off64_t seek_new = fd->seek(fd, bhead.len, SEEK_CUR);
859           if (seek_new == -1) {
860             fd->is_eof = true;
861             MEM_freeN(new_bhead);
862             new_bhead = NULL;
863           }
864           BLI_assert(fd->file_offset == seek_new);
865         }
866         else {
867           fd->is_eof = true;
868         }
869       }
870 #endif
871       else {
872         new_bhead = MEM_mallocN(sizeof(BHeadN) + bhead.len, "new_bhead");
873         if (new_bhead) {
874           new_bhead->next = new_bhead->prev = NULL;
875 #ifdef USE_BHEAD_READ_ON_DEMAND
876           new_bhead->file_offset = 0; /* don't seek. */
877           new_bhead->has_data = true;
878 #endif
879           new_bhead->bhead = bhead;
880
881           readsize = fd->read(fd, new_bhead + 1, bhead.len);
882
883           if (readsize != bhead.len) {
884             fd->is_eof = true;
885             MEM_freeN(new_bhead);
886             new_bhead = NULL;
887           }
888         }
889         else {
890           fd->is_eof = true;
891         }
892       }
893     }
894   }
895
896   /* We've read a new block. Now add it to the list
897    * of blocks.
898    */
899   if (new_bhead) {
900     BLI_addtail(&fd->bhead_list, new_bhead);
901   }
902
903   return new_bhead;
904 }
905
906 BHead *blo_bhead_first(FileData *fd)
907 {
908   BHeadN *new_bhead;
909   BHead *bhead = NULL;
910
911   /* Rewind the file
912    * Read in a new block if necessary
913    */
914   new_bhead = fd->bhead_list.first;
915   if (new_bhead == NULL) {
916     new_bhead = get_bhead(fd);
917   }
918
919   if (new_bhead) {
920     bhead = &new_bhead->bhead;
921   }
922
923   return bhead;
924 }
925
926 BHead *blo_bhead_prev(FileData *UNUSED(fd), BHead *thisblock)
927 {
928   BHeadN *bheadn = BHEADN_FROM_BHEAD(thisblock);
929   BHeadN *prev = bheadn->prev;
930
931   return (prev) ? &prev->bhead : NULL;
932 }
933
934 BHead *blo_bhead_next(FileData *fd, BHead *thisblock)
935 {
936   BHeadN *new_bhead = NULL;
937   BHead *bhead = NULL;
938
939   if (thisblock) {
940     /* bhead is actually a sub part of BHeadN
941      * We calculate the BHeadN pointer from the BHead pointer below */
942     new_bhead = BHEADN_FROM_BHEAD(thisblock);
943
944     /* get the next BHeadN. If it doesn't exist we read in the next one */
945     new_bhead = new_bhead->next;
946     if (new_bhead == NULL) {
947       new_bhead = get_bhead(fd);
948     }
949   }
950
951   if (new_bhead) {
952     /* here we do the reverse:
953      * go from the BHeadN pointer to the BHead pointer */
954     bhead = &new_bhead->bhead;
955   }
956
957   return bhead;
958 }
959
960 #ifdef USE_BHEAD_READ_ON_DEMAND
961 static bool blo_bhead_read_data(FileData *fd, BHead *thisblock, void *buf)
962 {
963   bool success = true;
964   BHeadN *new_bhead = BHEADN_FROM_BHEAD(thisblock);
965   BLI_assert(new_bhead->has_data == false && new_bhead->file_offset != 0);
966   off64_t offset_backup = fd->file_offset;
967   if (UNLIKELY(fd->seek(fd, new_bhead->file_offset, SEEK_SET) == -1)) {
968     success = false;
969   }
970   else {
971     if (fd->read(fd, buf, new_bhead->bhead.len) != new_bhead->bhead.len) {
972       success = false;
973     }
974   }
975   if (fd->seek(fd, offset_backup, SEEK_SET) == -1) {
976     success = false;
977   }
978   return success;
979 }
980
981 static BHead *blo_bhead_read_full(FileData *fd, BHead *thisblock)
982 {
983   BHeadN *new_bhead = BHEADN_FROM_BHEAD(thisblock);
984   BHeadN *new_bhead_data = MEM_mallocN(sizeof(BHeadN) + new_bhead->bhead.len, "new_bhead");
985   new_bhead_data->bhead = new_bhead->bhead;
986   new_bhead_data->file_offset = new_bhead->file_offset;
987   new_bhead_data->has_data = true;
988   if (!blo_bhead_read_data(fd, thisblock, new_bhead_data + 1)) {
989     MEM_freeN(new_bhead_data);
990     return NULL;
991   }
992   return &new_bhead_data->bhead;
993 }
994 #endif /* USE_BHEAD_READ_ON_DEMAND */
995
996 /* Warning! Caller's responsibility to ensure given bhead **is** and ID one! */
997 const char *blo_bhead_id_name(const FileData *fd, const BHead *bhead)
998 {
999   return (const char *)POINTER_OFFSET(bhead, sizeof(*bhead) + fd->id_name_offs);
1000 }
1001
1002 static void decode_blender_header(FileData *fd)
1003 {
1004   char header[SIZEOFBLENDERHEADER], num[4];
1005   int readsize;
1006
1007   /* read in the header data */
1008   readsize = fd->read(fd, header, sizeof(header));
1009
1010   if (readsize == sizeof(header) && STREQLEN(header, "BLENDER", 7) && ELEM(header[7], '_', '-') &&
1011       ELEM(header[8], 'v', 'V') &&
1012       (isdigit(header[9]) && isdigit(header[10]) && isdigit(header[11]))) {
1013     fd->flags |= FD_FLAGS_FILE_OK;
1014
1015     /* what size are pointers in the file ? */
1016     if (header[7] == '_') {
1017       fd->flags |= FD_FLAGS_FILE_POINTSIZE_IS_4;
1018       if (sizeof(void *) != 4) {
1019         fd->flags |= FD_FLAGS_POINTSIZE_DIFFERS;
1020       }
1021     }
1022     else {
1023       if (sizeof(void *) != 8) {
1024         fd->flags |= FD_FLAGS_POINTSIZE_DIFFERS;
1025       }
1026     }
1027
1028     /* is the file saved in a different endian
1029      * than we need ?
1030      */
1031     if (((header[8] == 'v') ? L_ENDIAN : B_ENDIAN) != ENDIAN_ORDER) {
1032       fd->flags |= FD_FLAGS_SWITCH_ENDIAN;
1033     }
1034
1035     /* get the version number */
1036     memcpy(num, header + 9, 3);
1037     num[3] = 0;
1038     fd->fileversion = atoi(num);
1039   }
1040 }
1041
1042 /**
1043  * \return Success if the file is read correctly, else set \a r_error_message.
1044  */
1045 static bool read_file_dna(FileData *fd, const char **r_error_message)
1046 {
1047   BHead *bhead;
1048   int subversion = 0;
1049
1050   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
1051     if (bhead->code == GLOB) {
1052       /* Before this, the subversion didn't exist in 'FileGlobal' so the subversion
1053        * value isn't accessible for the purpose of DNA versioning in this case. */
1054       if (fd->fileversion <= 242) {
1055         continue;
1056       }
1057       /* We can't use read_global because this needs 'DNA1' to be decoded,
1058        * however the first 4 chars are _always_ the subversion. */
1059       FileGlobal *fg = (void *)&bhead[1];
1060       BLI_STATIC_ASSERT(offsetof(FileGlobal, subvstr) == 0, "Must be first: subvstr")
1061       char num[5];
1062       memcpy(num, fg->subvstr, 4);
1063       num[4] = 0;
1064       subversion = atoi(num);
1065     }
1066     else if (bhead->code == DNA1) {
1067       const bool do_endian_swap = (fd->flags & FD_FLAGS_SWITCH_ENDIAN) != 0;
1068
1069       fd->filesdna = DNA_sdna_from_data(
1070           &bhead[1], bhead->len, do_endian_swap, true, r_error_message);
1071       if (fd->filesdna) {
1072         blo_do_versions_dna(fd->filesdna, fd->fileversion, subversion);
1073         fd->compflags = DNA_struct_get_compareflags(fd->filesdna, fd->memsdna);
1074         /* used to retrieve ID names from (bhead+1) */
1075         fd->id_name_offs = DNA_elem_offset(fd->filesdna, "ID", "char", "name[]");
1076
1077         return true;
1078       }
1079       else {
1080         return false;
1081       }
1082     }
1083     else if (bhead->code == ENDB) {
1084       break;
1085     }
1086   }
1087
1088   *r_error_message = "Missing DNA block";
1089   return false;
1090 }
1091
1092 static int *read_file_thumbnail(FileData *fd)
1093 {
1094   BHead *bhead;
1095   int *blend_thumb = NULL;
1096
1097   for (bhead = blo_bhead_first(fd); bhead; bhead = blo_bhead_next(fd, bhead)) {
1098     if (bhead->code == TEST) {
1099       const bool do_endian_swap = (fd->flags & FD_FLAGS_SWITCH_ENDIAN) != 0;
1100       int *data = (int *)(bhead + 1);
1101
1102       if (bhead->len < (2 * sizeof(int))) {
1103         break;
1104       }
1105
1106       if (do_endian_swap) {
1107         BLI_endian_switch_int32(&data[0]);
1108         BLI_endian_switch_int32(&data[1]);
1109       }
1110
1111       const int width = data[0];
1112       const int height = data[1];
1113       if (!BLEN_THUMB_MEMSIZE_IS_VALID(width, height)) {
1114         break;
1115       }
1116       if (bhead->len < BLEN_THUMB_MEMSIZE_FILE(width, height)) {
1117         break;
1118       }
1119
1120       blend_thumb = data;
1121       break;
1122     }
1123     else if (bhead->code != REND) {
1124       /* Thumbnail is stored in TEST immediately after first REND... */
1125       break;
1126     }
1127   }
1128
1129   return blend_thumb;
1130 }
1131
1132 /** \} */
1133
1134 /* -------------------------------------------------------------------- */
1135 /** \name File Data API
1136  * \{ */
1137
1138 /* Regular file reading. */
1139
1140 static int fd_read_data_from_file(FileData *filedata, void *buffer, uint size)
1141 {
1142   int readsize = read(filedata->filedes, buffer, size);
1143
1144   if (readsize < 0) {
1145     readsize = EOF;
1146   }
1147   else {
1148     filedata->file_offset += readsize;
1149   }
1150
1151   return (readsize);
1152 }
1153
1154 static off64_t fd_seek_data_from_file(FileData *filedata, off64_t offset, int whence)
1155 {
1156   filedata->file_offset = lseek(filedata->filedes, offset, whence);
1157   return filedata->file_offset;
1158 }
1159
1160 /* GZip file reading. */
1161
1162 static int fd_read_gzip_from_file(FileData *filedata, void *buffer, uint size)
1163 {
1164   int readsize = gzread(filedata->gzfiledes, buffer, size);
1165
1166   if (readsize < 0) {
1167     readsize = EOF;
1168   }
1169   else {
1170     filedata->file_offset += readsize;
1171   }
1172
1173   return (readsize);
1174 }
1175
1176 /* Memory reading. */
1177
1178 static int fd_read_from_memory(FileData *filedata, void *buffer, uint size)
1179 {
1180   /* don't read more bytes then there are available in the buffer */
1181   int readsize = (int)MIN2(size, (uint)(filedata->buffersize - filedata->file_offset));
1182
1183   memcpy(buffer, filedata->buffer + filedata->file_offset, readsize);
1184   filedata->file_offset += readsize;
1185
1186   return (readsize);
1187 }
1188
1189 /* MemFile reading. */
1190
1191 static int fd_read_from_memfile(FileData *filedata, void *buffer, uint size)
1192 {
1193   static size_t seek = SIZE_MAX; /* the current position */
1194   static size_t offset = 0;      /* size of previous chunks */
1195   static MemFileChunk *chunk = NULL;
1196   size_t chunkoffset, readsize, totread;
1197
1198   if (size == 0) {
1199     return 0;
1200   }
1201
1202   if (seek != (size_t)filedata->file_offset) {
1203     chunk = filedata->memfile->chunks.first;
1204     seek = 0;
1205
1206     while (chunk) {
1207       if (seek + chunk->size > (size_t)filedata->file_offset) {
1208         break;
1209       }
1210       seek += chunk->size;
1211       chunk = chunk->next;
1212     }
1213     offset = seek;
1214     seek = filedata->file_offset;
1215   }
1216
1217   if (chunk) {
1218     totread = 0;
1219
1220     do {
1221       /* first check if it's on the end if current chunk */
1222       if (seek - offset == chunk->size) {
1223         offset += chunk->size;
1224         chunk = chunk->next;
1225       }
1226
1227       /* debug, should never happen */
1228       if (chunk == NULL) {
1229         printf("illegal read, chunk zero\n");
1230         return 0;
1231       }
1232
1233       chunkoffset = seek - offset;
1234       readsize = size - totread;
1235
1236       /* data can be spread over multiple chunks, so clamp size
1237        * to within this chunk, and then it will read further in
1238        * the next chunk */
1239       if (chunkoffset + readsize > chunk->size) {
1240         readsize = chunk->size - chunkoffset;
1241       }
1242
1243       memcpy(POINTER_OFFSET(buffer, totread), chunk->buf + chunkoffset, readsize);
1244       totread += readsize;
1245       filedata->file_offset += readsize;
1246       seek += readsize;
1247     } while (totread < size);
1248
1249     return totread;
1250   }
1251
1252   return 0;
1253 }
1254
1255 static FileData *filedata_new(void)
1256 {
1257   FileData *fd = MEM_callocN(sizeof(FileData), "FileData");
1258
1259   fd->filedes = -1;
1260   fd->gzfiledes = NULL;
1261
1262   fd->memsdna = DNA_sdna_current_get();
1263
1264   fd->datamap = oldnewmap_new();
1265   fd->globmap = oldnewmap_new();
1266   fd->libmap = oldnewmap_new();
1267
1268   return fd;
1269 }
1270
1271 static FileData *blo_decode_and_check(FileData *fd, ReportList *reports)
1272 {
1273   decode_blender_header(fd);
1274
1275   if (fd->flags & FD_FLAGS_FILE_OK) {
1276     const char *error_message = NULL;
1277     if (read_file_dna(fd, &error_message) == false) {
1278       BKE_reportf(
1279           reports, RPT_ERROR, "Failed to read blend file '%s': %s", fd->relabase, error_message);
1280       blo_filedata_free(fd);
1281       fd = NULL;
1282     }
1283   }
1284   else {
1285     BKE_reportf(
1286         reports, RPT_ERROR, "Failed to read blend file '%s', not a blend file", fd->relabase);
1287     blo_filedata_free(fd);
1288     fd = NULL;
1289   }
1290
1291   return fd;
1292 }
1293
1294 static FileData *blo_filedata_from_file_descriptor(const char *filepath,
1295                                                    ReportList *reports,
1296                                                    int file)
1297 {
1298   FileDataReadFn *read_fn = NULL;
1299   FileDataSeekFn *seek_fn = NULL; /* Optional. */
1300
1301   gzFile gzfile = (gzFile)Z_NULL;
1302
1303   char header[7];
1304
1305   /* Regular file. */
1306   errno = 0;
1307   if (read(file, header, sizeof(header)) != sizeof(header)) {
1308     BKE_reportf(reports,
1309                 RPT_WARNING,
1310                 "Unable to read '%s': %s",
1311                 filepath,
1312                 errno ? strerror(errno) : TIP_("insufficient content"));
1313     return NULL;
1314   }
1315   else {
1316     lseek(file, 0, SEEK_SET);
1317   }
1318
1319   /* Regular file. */
1320   if (memcmp(header, "BLENDER", sizeof(header)) == 0) {
1321     read_fn = fd_read_data_from_file;
1322     seek_fn = fd_seek_data_from_file;
1323   }
1324
1325   /* Gzip file. */
1326   errno = 0;
1327   if ((read_fn == NULL) &&
1328       /* Check header magic. */
1329       (header[0] == 0x1f && header[1] == 0x8b)) {
1330     gzfile = BLI_gzopen(filepath, "rb");
1331     if (gzfile == (gzFile)Z_NULL) {
1332       BKE_reportf(reports,
1333                   RPT_WARNING,
1334                   "Unable to open '%s': %s",
1335                   filepath,
1336                   errno ? strerror(errno) : TIP_("unknown error reading file"));
1337       return NULL;
1338     }
1339     else {
1340       /* 'seek_fn' is too slow for gzip, don't set it. */
1341       read_fn = fd_read_gzip_from_file;
1342       /* Caller must close. */
1343       file = -1;
1344     }
1345   }
1346
1347   if (read_fn == NULL) {
1348     BKE_reportf(reports, RPT_WARNING, "Unrecognized file format '%s'", filepath);
1349     return NULL;
1350   }
1351
1352   FileData *fd = filedata_new();
1353
1354   fd->filedes = file;
1355   fd->gzfiledes = gzfile;
1356
1357   fd->read = read_fn;
1358   fd->seek = seek_fn;
1359
1360   return fd;
1361 }
1362
1363 static FileData *blo_filedata_from_file_open(const char *filepath, ReportList *reports)
1364 {
1365   errno = 0;
1366   const int file = BLI_open(filepath, O_BINARY | O_RDONLY, 0);
1367   if (file == -1) {
1368     BKE_reportf(reports,
1369                 RPT_WARNING,
1370                 "Unable to open '%s': %s",
1371                 filepath,
1372                 errno ? strerror(errno) : TIP_("unknown error reading file"));
1373     return NULL;
1374   }
1375   FileData *fd = blo_filedata_from_file_descriptor(filepath, reports, file);
1376   if ((fd == NULL) || (fd->filedes == -1)) {
1377     close(file);
1378   }
1379   return fd;
1380 }
1381
1382 /* cannot be called with relative paths anymore! */
1383 /* on each new library added, it now checks for the current FileData and expands relativeness */
1384 FileData *blo_filedata_from_file(const char *filepath, ReportList *reports)
1385 {
1386   FileData *fd = blo_filedata_from_file_open(filepath, reports);
1387   if (fd != NULL) {
1388     /* needed for library_append and read_libraries */
1389     BLI_strncpy(fd->relabase, filepath, sizeof(fd->relabase));
1390
1391     return blo_decode_and_check(fd, reports);
1392   }
1393   return NULL;
1394 }
1395
1396 /**
1397  * Same as blo_filedata_from_file(), but does not reads DNA data, only header.
1398  * Use it for light access (e.g. thumbnail reading).
1399  */
1400 static FileData *blo_filedata_from_file_minimal(const char *filepath)
1401 {
1402   FileData *fd = blo_filedata_from_file_open(filepath, NULL);
1403   if (fd != NULL) {
1404     decode_blender_header(fd);
1405     if (fd->flags & FD_FLAGS_FILE_OK) {
1406       return fd;
1407     }
1408     blo_filedata_free(fd);
1409   }
1410   return NULL;
1411 }
1412
1413 static int fd_read_gzip_from_memory(FileData *filedata, void *buffer, uint size)
1414 {
1415   int err;
1416
1417   filedata->strm.next_out = (Bytef *)buffer;
1418   filedata->strm.avail_out = size;
1419
1420   // Inflate another chunk.
1421   err = inflate(&filedata->strm, Z_SYNC_FLUSH);
1422
1423   if (err == Z_STREAM_END) {
1424     return 0;
1425   }
1426   else if (err != Z_OK) {
1427     printf("fd_read_gzip_from_memory: zlib error\n");
1428     return 0;
1429   }
1430
1431   filedata->file_offset += size;
1432
1433   return (size);
1434 }
1435
1436 static int fd_read_gzip_from_memory_init(FileData *fd)
1437 {
1438
1439   fd->strm.next_in = (Bytef *)fd->buffer;
1440   fd->strm.avail_in = fd->buffersize;
1441   fd->strm.total_out = 0;
1442   fd->strm.zalloc = Z_NULL;
1443   fd->strm.zfree = Z_NULL;
1444
1445   if (inflateInit2(&fd->strm, (16 + MAX_WBITS)) != Z_OK) {
1446     return 0;
1447   }
1448
1449   fd->read = fd_read_gzip_from_memory;
1450
1451   return 1;
1452 }
1453
1454 FileData *blo_filedata_from_memory(const void *mem, int memsize, ReportList *reports)
1455 {
1456   if (!mem || memsize < SIZEOFBLENDERHEADER) {
1457     BKE_report(reports, RPT_WARNING, (mem) ? TIP_("Unable to read") : TIP_("Unable to open"));
1458     return NULL;
1459   }
1460   else {
1461     FileData *fd = filedata_new();
1462     const char *cp = mem;
1463
1464     fd->buffer = mem;
1465     fd->buffersize = memsize;
1466
1467     /* test if gzip */
1468     if (cp[0] == 0x1f && cp[1] == 0x8b) {
1469       if (0 == fd_read_gzip_from_memory_init(fd)) {
1470         blo_filedata_free(fd);
1471         return NULL;
1472       }
1473     }
1474     else {
1475       fd->read = fd_read_from_memory;
1476     }
1477
1478     fd->flags |= FD_FLAGS_NOT_MY_BUFFER;
1479
1480     return blo_decode_and_check(fd, reports);
1481   }
1482 }
1483
1484 FileData *blo_filedata_from_memfile(MemFile *memfile, ReportList *reports)
1485 {
1486   if (!memfile) {
1487     BKE_report(reports, RPT_WARNING, "Unable to open blend <memory>");
1488     return NULL;
1489   }
1490   else {
1491     FileData *fd = filedata_new();
1492     fd->memfile = memfile;
1493
1494     fd->read = fd_read_from_memfile;
1495     fd->flags |= FD_FLAGS_NOT_MY_BUFFER;
1496
1497     return blo_decode_and_check(fd, reports);
1498   }
1499 }
1500
1501 void blo_filedata_free(FileData *fd)
1502 {
1503   if (fd) {
1504     if (fd->filedes != -1) {
1505       close(fd->filedes);
1506     }
1507
1508     if (fd->gzfiledes != NULL) {
1509       gzclose(fd->gzfiledes);
1510     }
1511
1512     if (fd->strm.next_in) {
1513       if (inflateEnd(&fd->strm) != Z_OK) {
1514         printf("close gzip stream error\n");
1515       }
1516     }
1517
1518     if (fd->buffer && !(fd->flags & FD_FLAGS_NOT_MY_BUFFER)) {
1519       MEM_freeN((void *)fd->buffer);
1520       fd->buffer = NULL;
1521     }
1522
1523     /* Free all BHeadN data blocks */
1524 #ifndef NDEBUG
1525     BLI_freelistN(&fd->bhead_list);
1526 #else
1527     /* Sanity check we're not keeping memory we don't need. */
1528     LISTBASE_FOREACH_MUTABLE (BHeadN *, new_bhead, &fd->bhead_list) {
1529       if (fd->seek != NULL && BHEAD_USE_READ_ON_DEMAND(&new_bhead->bhead)) {
1530         BLI_assert(new_bhead->has_data == 0);
1531       }
1532       MEM_freeN(new_bhead);
1533     }
1534 #endif
1535
1536     if (fd->filesdna) {
1537       DNA_sdna_free(fd->filesdna);
1538     }
1539     if (fd->compflags) {
1540       MEM_freeN((void *)fd->compflags);
1541     }
1542
1543     if (fd->datamap) {
1544       oldnewmap_free(fd->datamap);
1545     }
1546     if (fd->globmap) {
1547       oldnewmap_free(fd->globmap);
1548     }
1549     if (fd->imamap) {
1550       oldnewmap_free(fd->imamap);
1551     }
1552     if (fd->movieclipmap) {
1553       oldnewmap_free(fd->movieclipmap);
1554     }
1555     if (fd->scenemap) {
1556       oldnewmap_free(fd->scenemap);
1557     }
1558     if (fd->soundmap) {
1559       oldnewmap_free(fd->soundmap);
1560     }
1561     if (fd->packedmap) {
1562       oldnewmap_free(fd->packedmap);
1563     }
1564     if (fd->libmap && !(fd->flags & FD_FLAGS_NOT_MY_LIBMAP)) {
1565       oldnewmap_free(fd->libmap);
1566     }
1567     if (fd->bheadmap) {
1568       MEM_freeN(fd->bheadmap);
1569     }
1570
1571 #ifdef USE_GHASH_BHEAD
1572     if (fd->bhead_idname_hash) {
1573       BLI_ghash_free(fd->bhead_idname_hash, NULL, NULL);
1574     }
1575 #endif
1576
1577     MEM_freeN(fd);
1578   }
1579 }
1580
1581 /** \} */
1582
1583 /* -------------------------------------------------------------------- */
1584 /** \name Public Utilities
1585  * \{ */
1586
1587 /**
1588  * Check whether given path ends with a blend file compatible extension
1589  * (`.blend`, `.ble` or `.blend.gz`).
1590  *
1591  * \param str: The path to check.
1592  * \return true is this path ends with a blender file extension.
1593  */
1594 bool BLO_has_bfile_extension(const char *str)
1595 {
1596   const char *ext_test[4] = {".blend", ".ble", ".blend.gz", NULL};
1597   return BLI_path_extension_check_array(str, ext_test);
1598 }
1599
1600 /**
1601  * Try to explode given path into its 'library components'
1602  * (i.e. a .blend file, id type/group, and data-block itself).
1603  *
1604  * \param path: the full path to explode.
1605  * \param r_dir: the string that'll contain path up to blend file itself ('library' path).
1606  * WARNING! Must be #FILE_MAX_LIBEXTRA long (it also stores group and name strings)!
1607  * \param r_group: the string that'll contain 'group' part of the path, if any. May be NULL.
1608  * \param r_name: the string that'll contain data's name part of the path, if any. May be NULL.
1609  * \return true if path contains a blend file.
1610  */
1611 bool BLO_library_path_explode(const char *path, char *r_dir, char **r_group, char **r_name)
1612 {
1613   /* We might get some data names with slashes,
1614    * so we have to go up in path until we find blend file itself,
1615    * then we now next path item is group, and everything else is data name. */
1616   char *slash = NULL, *prev_slash = NULL, c = '\0';
1617
1618   r_dir[0] = '\0';
1619   if (r_group) {
1620     *r_group = NULL;
1621   }
1622   if (r_name) {
1623     *r_name = NULL;
1624   }
1625
1626   /* if path leads to an existing directory, we can be sure we're not (in) a library */
1627   if (BLI_is_dir(path)) {
1628     return false;
1629   }
1630
1631   strcpy(r_dir, path);
1632
1633   while ((slash = (char *)BLI_last_slash(r_dir))) {
1634     char tc = *slash;
1635     *slash = '\0';
1636     if (BLO_has_bfile_extension(r_dir) && BLI_is_file(r_dir)) {
1637       break;
1638     }
1639     else if (STREQ(r_dir, BLO_EMBEDDED_STARTUP_BLEND)) {
1640       break;
1641     }
1642
1643     if (prev_slash) {
1644       *prev_slash = c;
1645     }
1646     prev_slash = slash;
1647     c = tc;
1648   }
1649
1650   if (!slash) {
1651     return false;
1652   }
1653
1654   if (slash[1] != '\0') {
1655     BLI_assert(strlen(slash + 1) < BLO_GROUP_MAX);
1656     if (r_group) {
1657       *r_group = slash + 1;
1658     }
1659   }
1660
1661   if (prev_slash && (prev_slash[1] != '\0')) {
1662     BLI_assert(strlen(prev_slash + 1) < MAX_ID_NAME - 2);
1663     if (r_name) {
1664       *r_name = prev_slash + 1;
1665     }
1666   }
1667
1668   return true;
1669 }
1670
1671 /**
1672  * Does a very light reading of given .blend file to extract its stored thumbnail.
1673  *
1674  * \param filepath: The path of the file to extract thumbnail from.
1675  * \return The raw thumbnail
1676  * (MEM-allocated, as stored in file, use #BKE_main_thumbnail_to_imbuf()
1677  * to convert it to ImBuf image).
1678  */
1679 BlendThumbnail *BLO_thumbnail_from_file(const char *filepath)
1680 {
1681   FileData *fd;
1682   BlendThumbnail *data = NULL;
1683   int *fd_data;
1684
1685   fd = blo_filedata_from_file_minimal(filepath);
1686   fd_data = fd ? read_file_thumbnail(fd) : NULL;
1687
1688   if (fd_data) {
1689     const int width = fd_data[0];
1690     const int height = fd_data[1];
1691     if (BLEN_THUMB_MEMSIZE_IS_VALID(width, height)) {
1692       const size_t sz = BLEN_THUMB_MEMSIZE(width, height);
1693       data = MEM_mallocN(sz, __func__);
1694       if (data) {
1695         BLI_assert((sz - sizeof(*data)) ==
1696                    (BLEN_THUMB_MEMSIZE_FILE(width, height) - (sizeof(*fd_data) * 2)));
1697         data->width = width;
1698         data->height = height;
1699         memcpy(data->rect, &fd_data[2], sz - sizeof(*data));
1700       }
1701     }
1702   }
1703
1704   blo_filedata_free(fd);
1705
1706   return data;
1707 }
1708
1709 /** \} */
1710
1711 /* -------------------------------------------------------------------- */
1712 /** \name Old/New Pointer Map
1713  * \{ */
1714
1715 static void *newdataadr(FileData *fd, const void *adr) /* only direct databocks */
1716 {
1717   return oldnewmap_lookup_and_inc(fd->datamap, adr, true);
1718 }
1719
1720 static void *newdataadr_no_us(FileData *fd, const void *adr) /* only direct databocks */
1721 {
1722   return oldnewmap_lookup_and_inc(fd->datamap, adr, false);
1723 }
1724
1725 static void *newglobadr(FileData *fd, const void *adr) /* direct datablocks with global linking */
1726 {
1727   return oldnewmap_lookup_and_inc(fd->globmap, adr, true);
1728 }
1729
1730 static void *newimaadr(FileData *fd, const void *adr) /* used to restore image data after undo */
1731 {
1732   if (fd->imamap && adr) {
1733     return oldnewmap_lookup_and_inc(fd->imamap, adr, true);
1734   }
1735   return NULL;
1736 }
1737
1738 static void *newsceadr(FileData *fd, const void *adr) /* used to restore scene data after undo */
1739 {
1740   if (fd->scenemap && adr) {
1741     return oldnewmap_lookup_and_inc(fd->scenemap, adr, true);
1742   }
1743   return NULL;
1744 }
1745
1746 static void *newmclipadr(FileData *fd,
1747                          const void *adr) /* used to restore movie clip data after undo */
1748 {
1749   if (fd->movieclipmap && adr) {
1750     return oldnewmap_lookup_and_inc(fd->movieclipmap, adr, true);
1751   }
1752   return NULL;
1753 }
1754
1755 static void *newsoundadr(FileData *fd, const void *adr) /* used to restore sound data after undo */
1756 {
1757   if (fd->soundmap && adr) {
1758     return oldnewmap_lookup_and_inc(fd->soundmap, adr, true);
1759   }
1760   return NULL;
1761 }
1762
1763 static void *newpackedadr(FileData *fd,
1764                           const void *adr) /* used to restore packed data after undo */
1765 {
1766   if (fd->packedmap && adr) {
1767     return oldnewmap_lookup_and_inc(fd->packedmap, adr, true);
1768   }
1769
1770   return oldnewmap_lookup_and_inc(fd->datamap, adr, true);
1771 }
1772
1773 static void *newlibadr(FileData *fd, const void *lib, const void *adr) /* only lib data */
1774 {
1775   return oldnewmap_liblookup(fd->libmap, adr, lib);
1776 }
1777
1778 void *blo_do_versions_newlibadr(FileData *fd, const void *lib, const void *adr) /* only lib data */
1779 {
1780   return newlibadr(fd, lib, adr);
1781 }
1782
1783 static void *newlibadr_us(FileData *fd,
1784                           const void *lib,
1785                           const void *adr) /* increases user number */
1786 {
1787   ID *id = newlibadr(fd, lib, adr);
1788
1789   id_us_plus_no_lib(id);
1790
1791   return id;
1792 }
1793
1794 void *blo_do_versions_newlibadr_us(FileData *fd,
1795                                    const void *lib,
1796                                    const void *adr) /* increases user number */
1797 {
1798   return newlibadr_us(fd, lib, adr);
1799 }
1800
1801 static void *newlibadr_real_us(FileData *fd,
1802                                const void *lib,
1803                                const void *adr) /* ensures real user */
1804 {
1805   ID *id = newlibadr(fd, lib, adr);
1806
1807   id_us_ensure_real(id);
1808
1809   return id;
1810 }
1811
1812 static void change_link_placeholder_to_real_ID_pointer_fd(FileData *fd, const void *old, void *new)
1813 {
1814   for (int i = 0; i < fd->libmap->nentries; i++) {
1815     OldNew *entry = &fd->libmap->entries[i];
1816
1817     if (old == entry->newp && entry->nr == ID_LINK_PLACEHOLDER) {
1818       entry->newp = new;
1819       if (new) {
1820         entry->nr = GS(((ID *)new)->name);
1821       }
1822     }
1823   }
1824 }
1825
1826 static void change_link_placeholder_to_real_ID_pointer(ListBase *mainlist,
1827                                                        FileData *basefd,
1828                                                        void *old,
1829                                                        void *new)
1830 {
1831   Main *mainptr;
1832
1833   for (mainptr = mainlist->first; mainptr; mainptr = mainptr->next) {
1834     FileData *fd;
1835
1836     if (mainptr->curlib) {
1837       fd = mainptr->curlib->filedata;
1838     }
1839     else {
1840       fd = basefd;
1841     }
1842
1843     if (fd) {
1844       change_link_placeholder_to_real_ID_pointer_fd(fd, old, new);
1845     }
1846   }
1847 }
1848
1849 /* lib linked proxy objects point to our local data, we need
1850  * to clear that pointer before reading the undo memfile since
1851  * the object might be removed, it is set again in reading
1852  * if the local object still exists.
1853  * This is only valid for local proxy objects though, linked ones should not be affected here.
1854  */
1855 void blo_clear_proxy_pointers_from_lib(Main *oldmain)
1856 {
1857   Object *ob = oldmain->objects.first;
1858
1859   for (; ob; ob = ob->id.next) {
1860     if (ob->id.lib != NULL && ob->proxy_from != NULL && ob->proxy_from->id.lib == NULL) {
1861       ob->proxy_from = NULL;
1862     }
1863   }
1864 }
1865
1866 void blo_make_scene_pointer_map(FileData *fd, Main *oldmain)
1867 {
1868   Scene *sce = oldmain->scenes.first;
1869
1870   fd->scenemap = oldnewmap_new();
1871
1872   for (; sce; sce = sce->id.next) {
1873     if (sce->eevee.light_cache) {
1874       struct LightCache *light_cache = sce->eevee.light_cache;
1875       oldnewmap_insert(fd->scenemap, light_cache, light_cache, 0);
1876     }
1877   }
1878 }
1879
1880 void blo_end_scene_pointer_map(FileData *fd, Main *oldmain)
1881 {
1882   OldNew *entry = fd->scenemap->entries;
1883   Scene *sce = oldmain->scenes.first;
1884   int i;
1885
1886   /* used entries were restored, so we put them to zero */
1887   for (i = 0; i < fd->scenemap->nentries; i++, entry++) {
1888     if (entry->nr > 0) {
1889       entry->newp = NULL;
1890     }
1891   }
1892
1893   for (; sce; sce = sce->id.next) {
1894     sce->eevee.light_cache = newsceadr(fd, sce->eevee.light_cache);
1895   }
1896 }
1897
1898 void blo_make_image_pointer_map(FileData *fd, Main *oldmain)
1899 {
1900   Image *ima = oldmain->images.first;
1901   Scene *sce = oldmain->scenes.first;
1902   int a;
1903
1904   fd->imamap = oldnewmap_new();
1905
1906   for (; ima; ima = ima->id.next) {
1907     if (ima->cache) {
1908       oldnewmap_insert(fd->imamap, ima->cache, ima->cache, 0);
1909     }
1910     for (a = 0; a < TEXTARGET_COUNT; a++) {
1911       if (ima->gputexture[a]) {
1912         oldnewmap_insert(fd->imamap, ima->gputexture[a], ima->gputexture[a], 0);
1913       }
1914     }
1915     if (ima->rr) {
1916       oldnewmap_insert(fd->imamap, ima->rr, ima->rr, 0);
1917     }
1918     LISTBASE_FOREACH (RenderSlot *, slot, &ima->renderslots) {
1919       if (slot->render) {
1920         oldnewmap_insert(fd->imamap, slot->render, slot->render, 0);
1921       }
1922     }
1923   }
1924   for (; sce; sce = sce->id.next) {
1925     if (sce->nodetree && sce->nodetree->previews) {
1926       bNodeInstanceHashIterator iter;
1927       NODE_INSTANCE_HASH_ITER (iter, sce->nodetree->previews) {
1928         bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
1929         oldnewmap_insert(fd->imamap, preview, preview, 0);
1930       }
1931     }
1932   }
1933 }
1934
1935 /* set old main image ibufs to zero if it has been restored */
1936 /* this works because freeing old main only happens after this call */
1937 void blo_end_image_pointer_map(FileData *fd, Main *oldmain)
1938 {
1939   OldNew *entry = fd->imamap->entries;
1940   Image *ima = oldmain->images.first;
1941   Scene *sce = oldmain->scenes.first;
1942   int i;
1943
1944   /* used entries were restored, so we put them to zero */
1945   for (i = 0; i < fd->imamap->nentries; i++, entry++) {
1946     if (entry->nr > 0) {
1947       entry->newp = NULL;
1948     }
1949   }
1950
1951   for (; ima; ima = ima->id.next) {
1952     ima->cache = newimaadr(fd, ima->cache);
1953     if (ima->cache == NULL) {
1954       ima->gpuflag = 0;
1955       for (i = 0; i < TEXTARGET_COUNT; i++) {
1956         ima->gputexture[i] = NULL;
1957       }
1958       ima->rr = NULL;
1959     }
1960     LISTBASE_FOREACH (RenderSlot *, slot, &ima->renderslots) {
1961       slot->render = newimaadr(fd, slot->render);
1962     }
1963
1964     for (i = 0; i < TEXTARGET_COUNT; i++) {
1965       ima->gputexture[i] = newimaadr(fd, ima->gputexture[i]);
1966     }
1967     ima->rr = newimaadr(fd, ima->rr);
1968   }
1969   for (; sce; sce = sce->id.next) {
1970     if (sce->nodetree && sce->nodetree->previews) {
1971       bNodeInstanceHash *new_previews = BKE_node_instance_hash_new("node previews");
1972       bNodeInstanceHashIterator iter;
1973
1974       /* reconstruct the preview hash, only using remaining pointers */
1975       NODE_INSTANCE_HASH_ITER (iter, sce->nodetree->previews) {
1976         bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
1977         if (preview) {
1978           bNodePreview *new_preview = newimaadr(fd, preview);
1979           if (new_preview) {
1980             bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
1981             BKE_node_instance_hash_insert(new_previews, key, new_preview);
1982           }
1983         }
1984       }
1985       BKE_node_instance_hash_free(sce->nodetree->previews, NULL);
1986       sce->nodetree->previews = new_previews;
1987     }
1988   }
1989 }
1990
1991 void blo_make_movieclip_pointer_map(FileData *fd, Main *oldmain)
1992 {
1993   MovieClip *clip = oldmain->movieclips.first;
1994   Scene *sce = oldmain->scenes.first;
1995
1996   fd->movieclipmap = oldnewmap_new();
1997
1998   for (; clip; clip = clip->id.next) {
1999     if (clip->cache) {
2000       oldnewmap_insert(fd->movieclipmap, clip->cache, clip->cache, 0);
2001     }
2002
2003     if (clip->tracking.camera.intrinsics) {
2004       oldnewmap_insert(
2005           fd->movieclipmap, clip->tracking.camera.intrinsics, clip->tracking.camera.intrinsics, 0);
2006     }
2007   }
2008
2009   for (; sce; sce = sce->id.next) {
2010     if (sce->nodetree) {
2011       bNode *node;
2012       for (node = sce->nodetree->nodes.first; node; node = node->next) {
2013         if (node->type == CMP_NODE_MOVIEDISTORTION) {
2014           oldnewmap_insert(fd->movieclipmap, node->storage, node->storage, 0);
2015         }
2016       }
2017     }
2018   }
2019 }
2020
2021 /* set old main movie clips caches to zero if it has been restored */
2022 /* this works because freeing old main only happens after this call */
2023 void blo_end_movieclip_pointer_map(FileData *fd, Main *oldmain)
2024 {
2025   OldNew *entry = fd->movieclipmap->entries;
2026   MovieClip *clip = oldmain->movieclips.first;
2027   Scene *sce = oldmain->scenes.first;
2028   int i;
2029
2030   /* used entries were restored, so we put them to zero */
2031   for (i = 0; i < fd->movieclipmap->nentries; i++, entry++) {
2032     if (entry->nr > 0) {
2033       entry->newp = NULL;
2034     }
2035   }
2036
2037   for (; clip; clip = clip->id.next) {
2038     clip->cache = newmclipadr(fd, clip->cache);
2039     clip->tracking.camera.intrinsics = newmclipadr(fd, clip->tracking.camera.intrinsics);
2040   }
2041
2042   for (; sce; sce = sce->id.next) {
2043     if (sce->nodetree) {
2044       bNode *node;
2045       for (node = sce->nodetree->nodes.first; node; node = node->next) {
2046         if (node->type == CMP_NODE_MOVIEDISTORTION) {
2047           node->storage = newmclipadr(fd, node->storage);
2048         }
2049       }
2050     }
2051   }
2052 }
2053
2054 void blo_make_sound_pointer_map(FileData *fd, Main *oldmain)
2055 {
2056   bSound *sound = oldmain->sounds.first;
2057
2058   fd->soundmap = oldnewmap_new();
2059
2060   for (; sound; sound = sound->id.next) {
2061     if (sound->waveform) {
2062       oldnewmap_insert(fd->soundmap, sound->waveform, sound->waveform, 0);
2063     }
2064   }
2065 }
2066
2067 /* set old main sound caches to zero if it has been restored */
2068 /* this works because freeing old main only happens after this call */
2069 void blo_end_sound_pointer_map(FileData *fd, Main *oldmain)
2070 {
2071   OldNew *entry = fd->soundmap->entries;
2072   bSound *sound = oldmain->sounds.first;
2073   int i;
2074
2075   /* used entries were restored, so we put them to zero */
2076   for (i = 0; i < fd->soundmap->nentries; i++, entry++) {
2077     if (entry->nr > 0) {
2078       entry->newp = NULL;
2079     }
2080   }
2081
2082   for (; sound; sound = sound->id.next) {
2083     sound->waveform = newsoundadr(fd, sound->waveform);
2084   }
2085 }
2086
2087 /* XXX disabled this feature - packed files also belong in temp saves and quit.blend,
2088  * to make restore work. */
2089
2090 static void insert_packedmap(FileData *fd, PackedFile *pf)
2091 {
2092   oldnewmap_insert(fd->packedmap, pf, pf, 0);
2093   oldnewmap_insert(fd->packedmap, pf->data, pf->data, 0);
2094 }
2095
2096 void blo_make_packed_pointer_map(FileData *fd, Main *oldmain)
2097 {
2098   Image *ima;
2099   VFont *vfont;
2100   bSound *sound;
2101   Library *lib;
2102
2103   fd->packedmap = oldnewmap_new();
2104
2105   for (ima = oldmain->images.first; ima; ima = ima->id.next) {
2106     ImagePackedFile *imapf;
2107
2108     if (ima->packedfile) {
2109       insert_packedmap(fd, ima->packedfile);
2110     }
2111
2112     for (imapf = ima->packedfiles.first; imapf; imapf = imapf->next) {
2113       if (imapf->packedfile) {
2114         insert_packedmap(fd, imapf->packedfile);
2115       }
2116     }
2117   }
2118
2119   for (vfont = oldmain->fonts.first; vfont; vfont = vfont->id.next) {
2120     if (vfont->packedfile) {
2121       insert_packedmap(fd, vfont->packedfile);
2122     }
2123   }
2124
2125   for (sound = oldmain->sounds.first; sound; sound = sound->id.next) {
2126     if (sound->packedfile) {
2127       insert_packedmap(fd, sound->packedfile);
2128     }
2129   }
2130
2131   for (lib = oldmain->libraries.first; lib; lib = lib->id.next) {
2132     if (lib->packedfile) {
2133       insert_packedmap(fd, lib->packedfile);
2134     }
2135   }
2136 }
2137
2138 /* set old main packed data to zero if it has been restored */
2139 /* this works because freeing old main only happens after this call */
2140 void blo_end_packed_pointer_map(FileData *fd, Main *oldmain)
2141 {
2142   Image *ima;
2143   VFont *vfont;
2144   bSound *sound;
2145   Library *lib;
2146   OldNew *entry = fd->packedmap->entries;
2147   int i;
2148
2149   /* used entries were restored, so we put them to zero */
2150   for (i = 0; i < fd->packedmap->nentries; i++, entry++) {
2151     if (entry->nr > 0) {
2152       entry->newp = NULL;
2153     }
2154   }
2155
2156   for (ima = oldmain->images.first; ima; ima = ima->id.next) {
2157     ImagePackedFile *imapf;
2158
2159     ima->packedfile = newpackedadr(fd, ima->packedfile);
2160
2161     for (imapf = ima->packedfiles.first; imapf; imapf = imapf->next) {
2162       imapf->packedfile = newpackedadr(fd, imapf->packedfile);
2163     }
2164   }
2165
2166   for (vfont = oldmain->fonts.first; vfont; vfont = vfont->id.next) {
2167     vfont->packedfile = newpackedadr(fd, vfont->packedfile);
2168   }
2169
2170   for (sound = oldmain->sounds.first; sound; sound = sound->id.next) {
2171     sound->packedfile = newpackedadr(fd, sound->packedfile);
2172   }
2173
2174   for (lib = oldmain->libraries.first; lib; lib = lib->id.next) {
2175     lib->packedfile = newpackedadr(fd, lib->packedfile);
2176   }
2177 }
2178
2179 /* undo file support: add all library pointers in lookup */
2180 void blo_add_library_pointer_map(ListBase *old_mainlist, FileData *fd)
2181 {
2182   Main *ptr = old_mainlist->first;
2183   ListBase *lbarray[MAX_LIBARRAY];
2184
2185   for (ptr = ptr->next; ptr; ptr = ptr->next) {
2186     int i = set_listbasepointers(ptr, lbarray);
2187     while (i--) {
2188       ID *id;
2189       for (id = lbarray[i]->first; id; id = id->next) {
2190         oldnewmap_insert(fd->libmap, id, id, GS(id->name));
2191       }
2192     }
2193   }
2194
2195   fd->old_mainlist = old_mainlist;
2196 }
2197
2198 /** \} */
2199
2200 /* -------------------------------------------------------------------- */
2201 /** \name DNA Struct Loading
2202  * \{ */
2203
2204 static void switch_endian_structs(const struct SDNA *filesdna, BHead *bhead)
2205 {
2206   int blocksize, nblocks;
2207   char *data;
2208
2209   data = (char *)(bhead + 1);
2210   blocksize = filesdna->types_size[filesdna->structs[bhead->SDNAnr][0]];
2211
2212   nblocks = bhead->nr;
2213   while (nblocks--) {
2214     DNA_struct_switch_endian(filesdna, bhead->SDNAnr, data);
2215
2216     data += blocksize;
2217   }
2218 }
2219
2220 static void *read_struct(FileData *fd, BHead *bh, const char *blockname)
2221 {
2222   void *temp = NULL;
2223
2224   if (bh->len) {
2225 #ifdef USE_BHEAD_READ_ON_DEMAND
2226     BHead *bh_orig = bh;
2227 #endif
2228
2229     /* switch is based on file dna */
2230     if (bh->SDNAnr && (fd->flags & FD_FLAGS_SWITCH_ENDIAN)) {
2231 #ifdef USE_BHEAD_READ_ON_DEMAND
2232       if (BHEADN_FROM_BHEAD(bh)->has_data == false) {
2233         bh = blo_bhead_read_full(fd, bh);
2234         if (UNLIKELY(bh == NULL)) {
2235           fd->flags &= ~FD_FLAGS_FILE_OK;
2236           return NULL;
2237         }
2238       }
2239 #endif
2240       switch_endian_structs(fd->filesdna, bh);
2241     }
2242
2243     if (fd->compflags[bh->SDNAnr] != SDNA_CMP_REMOVED) {
2244       if (fd->compflags[bh->SDNAnr] == SDNA_CMP_NOT_EQUAL) {
2245 #ifdef USE_BHEAD_READ_ON_DEMAND
2246         if (BHEADN_FROM_BHEAD(bh)->has_data == false) {
2247           bh = blo_bhead_read_full(fd, bh);
2248           if (UNLIKELY(bh == NULL)) {
2249             fd->flags &= ~FD_FLAGS_FILE_OK;
2250             return NULL;
2251           }
2252         }
2253 #endif
2254         temp = DNA_struct_reconstruct(
2255             fd->memsdna, fd->filesdna, fd->compflags, bh->SDNAnr, bh->nr, (bh + 1));
2256       }
2257       else {
2258         /* SDNA_CMP_EQUAL */
2259         temp = MEM_mallocN(bh->len, blockname);
2260 #ifdef USE_BHEAD_READ_ON_DEMAND
2261         if (BHEADN_FROM_BHEAD(bh)->has_data) {
2262           memcpy(temp, (bh + 1), bh->len);
2263         }
2264         else {
2265           /* Instead of allocating the bhead, then copying it,
2266            * read the data from the file directly into the memory. */
2267           if (UNLIKELY(!blo_bhead_read_data(fd, bh, temp))) {
2268             fd->flags &= ~FD_FLAGS_FILE_OK;
2269             MEM_freeN(temp);
2270             temp = NULL;
2271           }
2272         }
2273 #else
2274         memcpy(temp, (bh + 1), bh->len);
2275 #endif
2276       }
2277     }
2278 #ifdef USE_BHEAD_READ_ON_DEMAND
2279     if (bh_orig != bh) {
2280       MEM_freeN(BHEADN_FROM_BHEAD(bh));
2281     }
2282 #endif
2283   }
2284
2285   return temp;
2286 }
2287
2288 typedef void (*link_list_cb)(FileData *fd, void *data);
2289
2290 static void link_list_ex(FileData *fd, ListBase *lb, link_list_cb callback) /* only direct data */
2291 {
2292   Link *ln, *prev;
2293
2294   if (BLI_listbase_is_empty(lb)) {
2295     return;
2296   }
2297
2298   lb->first = newdataadr(fd, lb->first);
2299   if (callback != NULL) {
2300     callback(fd, lb->first);
2301   }
2302   ln = lb->first;
2303   prev = NULL;
2304   while (ln) {
2305     ln->next = newdataadr(fd, ln->next);
2306     if (ln->next != NULL && callback != NULL) {
2307       callback(fd, ln->next);
2308     }
2309     ln->prev = prev;
2310     prev = ln;
2311     ln = ln->next;
2312   }
2313   lb->last = prev;
2314 }
2315
2316 static void link_list(FileData *fd, ListBase *lb) /* only direct data */
2317 {
2318   link_list_ex(fd, lb, NULL);
2319 }
2320
2321 static void link_glob_list(FileData *fd, ListBase *lb) /* for glob data */
2322 {
2323   Link *ln, *prev;
2324   void *poin;
2325
2326   if (BLI_listbase_is_empty(lb)) {
2327     return;
2328   }
2329   poin = newdataadr(fd, lb->first);
2330   if (lb->first) {
2331     oldnewmap_insert(fd->globmap, lb->first, poin, 0);
2332   }
2333   lb->first = poin;
2334
2335   ln = lb->first;
2336   prev = NULL;
2337   while (ln) {
2338     poin = newdataadr(fd, ln->next);
2339     if (ln->next) {
2340       oldnewmap_insert(fd->globmap, ln->next, poin, 0);
2341     }
2342     ln->next = poin;
2343     ln->prev = prev;
2344     prev = ln;
2345     ln = ln->next;
2346   }
2347   lb->last = prev;
2348 }
2349
2350 static void test_pointer_array(FileData *fd, void **mat)
2351 {
2352   int64_t *lpoin, *lmat;
2353   int *ipoin, *imat;
2354   size_t len;
2355
2356   /* manually convert the pointer array in
2357    * the old dna format to a pointer array in
2358    * the new dna format.
2359    */
2360   if (*mat) {
2361     len = MEM_allocN_len(*mat) / fd->filesdna->pointer_size;
2362
2363     if (fd->filesdna->pointer_size == 8 && fd->memsdna->pointer_size == 4) {
2364       ipoin = imat = MEM_malloc_arrayN(len, 4, "newmatar");
2365       lpoin = *mat;
2366
2367       while (len-- > 0) {
2368         if ((fd->flags & FD_FLAGS_SWITCH_ENDIAN)) {
2369           BLI_endian_switch_int64(lpoin);
2370         }
2371         *ipoin = (int)((*lpoin) >> 3);
2372         ipoin++;
2373         lpoin++;
2374       }
2375       MEM_freeN(*mat);
2376       *mat = imat;
2377     }
2378
2379     if (fd->filesdna->pointer_size == 4 && fd->memsdna->pointer_size == 8) {
2380       lpoin = lmat = MEM_malloc_arrayN(len, 8, "newmatar");
2381       ipoin = *mat;
2382
2383       while (len-- > 0) {
2384         *lpoin = *ipoin;
2385         ipoin++;
2386         lpoin++;
2387       }
2388       MEM_freeN(*mat);
2389       *mat = lmat;
2390     }
2391   }
2392 }
2393
2394 /** \} */
2395
2396 /* -------------------------------------------------------------------- */
2397 /** \name Read ID Properties
2398  * \{ */
2399
2400 static void IDP_DirectLinkProperty(IDProperty *prop, int switch_endian, FileData *fd);
2401 static void IDP_LibLinkProperty(IDProperty *prop, FileData *fd);
2402
2403 static void IDP_DirectLinkIDPArray(IDProperty *prop, int switch_endian, FileData *fd)
2404 {
2405   IDProperty *array;
2406   int i;
2407
2408   /* since we didn't save the extra buffer, set totallen to len */
2409   prop->totallen = prop->len;
2410   prop->data.pointer = newdataadr(fd, prop->data.pointer);
2411
2412   array = (IDProperty *)prop->data.pointer;
2413
2414   /* note!, idp-arrays didn't exist in 2.4x, so the pointer will be cleared
2415    * theres not really anything we can do to correct this, at least don't crash */
2416   if (array == NULL) {
2417     prop->len = 0;
2418     prop->totallen = 0;
2419   }
2420
2421   for (i = 0; i < prop->len; i++) {
2422     IDP_DirectLinkProperty(&array[i], switch_endian, fd);
2423   }
2424 }
2425
2426 static void IDP_DirectLinkArray(IDProperty *prop, int switch_endian, FileData *fd)
2427 {
2428   IDProperty **array;
2429   int i;
2430
2431   /* since we didn't save the extra buffer, set totallen to len */
2432   prop->totallen = prop->len;
2433   prop->data.pointer = newdataadr(fd, prop->data.pointer);
2434
2435   if (prop->subtype == IDP_GROUP) {
2436     test_pointer_array(fd, prop->data.pointer);
2437     array = prop->data.pointer;
2438
2439     for (i = 0; i < prop->len; i++) {
2440       IDP_DirectLinkProperty(array[i], switch_endian, fd);
2441     }
2442   }
2443   else if (prop->subtype == IDP_DOUBLE) {
2444     if (switch_endian) {
2445       BLI_endian_switch_double_array(prop->data.pointer, prop->len);
2446     }
2447   }
2448   else {
2449     if (switch_endian) {
2450       /* also used for floats */
2451       BLI_endian_switch_int32_array(prop->data.pointer, prop->len);
2452     }
2453   }
2454 }
2455
2456 static void IDP_DirectLinkString(IDProperty *prop, FileData *fd)
2457 {
2458   /*since we didn't save the extra string buffer, set totallen to len.*/
2459   prop->totallen = prop->len;
2460   prop->data.pointer = newdataadr(fd, prop->data.pointer);
2461 }
2462
2463 static void IDP_DirectLinkGroup(IDProperty *prop, int switch_endian, FileData *fd)
2464 {
2465   ListBase *lb = &prop->data.group;
2466   IDProperty *loop;
2467
2468   link_list(fd, lb);
2469
2470   /*Link child id properties now*/
2471   for (loop = prop->data.group.first; loop; loop = loop->next) {
2472     IDP_DirectLinkProperty(loop, switch_endian, fd);
2473   }
2474 }
2475
2476 static void IDP_DirectLinkProperty(IDProperty *prop, int switch_endian, FileData *fd)
2477 {
2478   switch (prop->type) {
2479     case IDP_GROUP:
2480       IDP_DirectLinkGroup(prop, switch_endian, fd);
2481       break;
2482     case IDP_STRING:
2483       IDP_DirectLinkString(prop, fd);
2484       break;
2485     case IDP_ARRAY:
2486       IDP_DirectLinkArray(prop, switch_endian, fd);
2487       break;
2488     case IDP_IDPARRAY:
2489       IDP_DirectLinkIDPArray(prop, switch_endian, fd);
2490       break;
2491     case IDP_DOUBLE:
2492       /* erg, stupid doubles.  since I'm storing them
2493        * in the same field as int val; val2 in the
2494        * IDPropertyData struct, they have to deal with
2495        * endianness specifically
2496        *
2497        * in theory, val and val2 would've already been swapped
2498        * if switch_endian is true, so we have to first unswap
2499        * them then reswap them as a single 64-bit entity.
2500        */
2501
2502       if (switch_endian) {
2503         BLI_endian_switch_int32(&prop->data.val);
2504         BLI_endian_switch_int32(&prop->data.val2);
2505         BLI_endian_switch_int64((int64_t *)&prop->data.val);
2506       }
2507       break;
2508     case IDP_INT:
2509     case IDP_FLOAT:
2510     case IDP_ID:
2511       break; /* Nothing special to do here. */
2512     default:
2513       /* Unknown IDP type, nuke it (we cannot handle unknown types everywhere in code,
2514        * IDP are way too polymorphic to do it safely. */
2515       printf(
2516           "%s: found unknown IDProperty type %d, reset to Integer one !\n", __func__, prop->type);
2517       /* Note: we do not attempt to free unknown prop, we have no way to know how to do that! */
2518       prop->type = IDP_INT;
2519       prop->subtype = 0;
2520       IDP_Int(prop) = 0;
2521   }
2522 }
2523
2524 #define IDP_DirectLinkGroup_OrFree(prop, switch_endian, fd) \
2525   _IDP_DirectLinkGroup_OrFree(prop, switch_endian, fd, __func__)
2526
2527 static void _IDP_DirectLinkGroup_OrFree(IDProperty **prop,
2528                                         int switch_endian,
2529                                         FileData *fd,
2530                                         const char *caller_func_id)
2531 {
2532   if (*prop) {
2533     if ((*prop)->type == IDP_GROUP) {
2534       IDP_DirectLinkGroup(*prop, switch_endian, fd);
2535     }
2536     else {
2537       /* corrupt file! */
2538       printf("%s: found non group data, freeing type %d!\n", caller_func_id, (*prop)->type);
2539       /* don't risk id, data's likely corrupt. */
2540       // IDP_FreePropertyContent(*prop);
2541       *prop = NULL;
2542     }
2543   }
2544 }
2545
2546 static void IDP_LibLinkProperty(IDProperty *prop, FileData *fd)
2547 {
2548   if (!prop) {
2549     return;
2550   }
2551
2552   switch (prop->type) {
2553     case IDP_ID: /* PointerProperty */
2554     {
2555       void *newaddr = newlibadr_us(fd, NULL, IDP_Id(prop));
2556       if (IDP_Id(prop) && !newaddr && G.debug) {
2557         printf("Error while loading \"%s\". Data not found in file!\n", prop->name);
2558       }
2559       prop->data.pointer = newaddr;
2560       break;
2561     }
2562     case IDP_IDPARRAY: /* CollectionProperty */
2563     {
2564       IDProperty *idp_array = IDP_IDPArray(prop);
2565       for (int i = 0; i < prop->len; i++) {
2566         IDP_LibLinkProperty(&(idp_array[i]), fd);
2567       }
2568       break;
2569     }
2570     case IDP_GROUP: /* PointerProperty */
2571     {
2572       for (IDProperty *loop = prop->data.group.first; loop; loop = loop->next) {
2573         IDP_LibLinkProperty(loop, fd);
2574       }
2575       break;
2576     }
2577     default:
2578       break; /* Nothing to do for other IDProps. */
2579   }
2580 }
2581
2582 /** \} */
2583
2584 /* -------------------------------------------------------------------- */
2585 /** \name Read Image Preview
2586  * \{ */
2587
2588 static PreviewImage *direct_link_preview_image(FileData *fd, PreviewImage *old_prv)
2589 {
2590   PreviewImage *prv = newdataadr(fd, old_prv);
2591
2592   if (prv) {
2593     int i;
2594     for (i = 0; i < NUM_ICON_SIZES; ++i) {
2595       if (prv->rect[i]) {
2596         prv->rect[i] = newdataadr(fd, prv->rect[i]);
2597       }
2598       prv->gputexture[i] = NULL;
2599     }
2600     prv->icon_id = 0;
2601     prv->tag = 0;
2602   }
2603
2604   return prv;
2605 }
2606
2607 /** \} */
2608
2609 /* -------------------------------------------------------------------- */
2610 /** \name Read ID
2611  * \{ */
2612
2613 static void lib_link_id(FileData *fd, Main *main)
2614 {
2615   ListBase *lbarray[MAX_LIBARRAY];
2616   int base_count, i;
2617
2618   base_count = set_listbasepointers(main, lbarray);
2619
2620   for (i = 0; i < base_count; i++) {
2621     ListBase *lb = lbarray[i];
2622     ID *id;
2623
2624     for (id = lb->first; id; id = id->next) {
2625       if (id->override_static) {
2626         id->override_static->reference = newlibadr_us(fd, id->lib, id->override_static->reference);
2627         id->override_static->storage = newlibadr_us(fd, id->lib, id->override_static->storage);
2628       }
2629     }
2630   }
2631 }
2632
2633 static void direct_link_id_override_property_operation_cb(FileData *fd, void *data)
2634 {
2635   IDOverrideStaticPropertyOperation *opop = data;
2636
2637   opop->subitem_reference_name = newdataadr(fd, opop->subitem_reference_name);
2638   opop->subitem_local_name = newdataadr(fd, opop->subitem_local_name);
2639 }
2640
2641 static void direct_link_id_override_property_cb(FileData *fd, void *data)
2642 {
2643   IDOverrideStaticProperty *op = data;
2644
2645   op->rna_path = newdataadr(fd, op->rna_path);
2646   link_list_ex(fd, &op->operations, direct_link_id_override_property_operation_cb);
2647 }
2648
2649 static void direct_link_id(FileData *fd, ID *id)
2650 {
2651   /*link direct data of ID properties*/
2652   if (id->properties) {
2653     id->properties = newdataadr(fd, id->properties);
2654     /* this case means the data was written incorrectly, it should not happen */
2655     IDP_DirectLinkGroup_OrFree(&id->properties, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd);
2656   }
2657   id->py_instance = NULL;
2658
2659   /* That way datablock reading not going through main read_libblock()
2660    * function are still in a clear tag state.
2661    * (glowering at certain nodetree fake datablock here...). */
2662   id->tag = 0;
2663
2664   /* Link direct data of overrides. */
2665   if (id->override_static) {
2666     id->override_static = newdataadr(fd, id->override_static);
2667     link_list_ex(fd, &id->override_static->properties, direct_link_id_override_property_cb);
2668   }
2669
2670   DrawDataList *drawdata = DRW_drawdatalist_from_id(id);
2671   if (drawdata) {
2672     BLI_listbase_clear((ListBase *)drawdata);
2673   }
2674 }
2675
2676 /** \} */
2677
2678 /* -------------------------------------------------------------------- */
2679 /** \name Read CurveMapping
2680  * \{ */
2681
2682 /* cuma itself has been read! */
2683 static void direct_link_curvemapping(FileData *fd, CurveMapping *cumap)
2684 {
2685   int a;
2686
2687   /* flag seems to be able to hang? Maybe old files... not bad to clear anyway */
2688   cumap->flag &= ~CUMA_PREMULLED;
2689
2690   for (a = 0; a < CM_TOT; a++) {
2691     cumap->cm[a].curve = newdataadr(fd, cumap->cm[a].curve);
2692     cumap->cm[a].table = NULL;
2693     cumap->cm[a].premultable = NULL;
2694   }
2695 }
2696
2697 /** \} */
2698
2699 /* -------------------------------------------------------------------- */
2700 /** \name Read ID: Brush
2701  * \{ */
2702
2703 /* library brush linking after fileread */
2704 static void lib_link_brush(FileData *fd, Main *main)
2705 {
2706   /* only link ID pointers */
2707   for (Brush *brush = main->brushes.first; brush; brush = brush->id.next) {
2708     if (brush->id.tag & LIB_TAG_NEED_LINK) {
2709       IDP_LibLinkProperty(brush->id.properties, fd);
2710
2711       /* brush->(mask_)mtex.obj is ignored on purpose? */
2712       brush->mtex.tex = newlibadr_us(fd, brush->id.lib, brush->mtex.tex);
2713       brush->mask_mtex.tex = newlibadr_us(fd, brush->id.lib, brush->mask_mtex.tex);
2714       brush->clone.image = newlibadr(fd, brush->id.lib, brush->clone.image);
2715       brush->toggle_brush = newlibadr(fd, brush->id.lib, brush->toggle_brush);
2716       brush->paint_curve = newlibadr_us(fd, brush->id.lib, brush->paint_curve);
2717
2718       /* link default grease pencil palette */
2719       if (brush->gpencil_settings != NULL) {
2720         if (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED) {
2721           brush->gpencil_settings->material = newlibadr_us(
2722               fd, brush->id.lib, brush->gpencil_settings->material);
2723
2724           if (!brush->gpencil_settings->material) {
2725             brush->gpencil_settings->flag &= ~GP_BRUSH_MATERIAL_PINNED;
2726           }
2727         }
2728         else {
2729           brush->gpencil_settings->material = NULL;
2730         }
2731       }
2732
2733       brush->id.tag &= ~LIB_TAG_NEED_LINK;
2734     }
2735   }
2736 }
2737
2738 static void direct_link_brush(FileData *fd, Brush *brush)
2739 {
2740   /* brush itself has been read */
2741
2742   /* fallof curve */
2743   brush->curve = newdataadr(fd, brush->curve);
2744
2745   brush->gradient = newdataadr(fd, brush->gradient);
2746
2747   if (brush->curve) {
2748     direct_link_curvemapping(fd, brush->curve);
2749   }
2750   else {
2751     BKE_brush_curve_preset(brush, CURVE_PRESET_SHARP);
2752   }
2753
2754   /* grease pencil */
2755   brush->gpencil_settings = newdataadr(fd, brush->gpencil_settings);
2756   if (brush->gpencil_settings != NULL) {
2757     brush->gpencil_settings->curve_sensitivity = newdataadr(
2758         fd, brush->gpencil_settings->curve_sensitivity);
2759     brush->gpencil_settings->curve_strength = newdataadr(fd,
2760                                                          brush->gpencil_settings->curve_strength);
2761     brush->gpencil_settings->curve_jitter = newdataadr(fd, brush->gpencil_settings->curve_jitter);
2762
2763     if (brush->gpencil_settings->curve_sensitivity) {
2764       direct_link_curvemapping(fd, brush->gpencil_settings->curve_sensitivity);
2765     }
2766
2767     if (brush->gpencil_settings->curve_strength) {
2768       direct_link_curvemapping(fd, brush->gpencil_settings->curve_strength);
2769     }
2770
2771     if (brush->gpencil_settings->curve_jitter) {
2772       direct_link_curvemapping(fd, brush->gpencil_settings->curve_jitter);
2773     }
2774   }
2775
2776   brush->preview = NULL;
2777   brush->icon_imbuf = NULL;
2778 }
2779
2780 /** \} */
2781
2782 /* -------------------------------------------------------------------- */
2783 /** \name Read ID: Palette
2784  * \{ */
2785
2786 static void lib_link_palette(FileData *fd, Main *main)
2787 {
2788   /* only link ID pointers */
2789   for (Palette *palette = main->palettes.first; palette; palette = palette->id.next) {
2790     if (palette->id.tag & LIB_TAG_NEED_LINK) {
2791       IDP_LibLinkProperty(palette->id.properties, fd);
2792
2793       palette->id.tag &= ~LIB_TAG_NEED_LINK;
2794     }
2795   }
2796 }
2797
2798 static void direct_link_palette(FileData *fd, Palette *palette)
2799 {
2800
2801   /* palette itself has been read */
2802   link_list(fd, &palette->colors);
2803 }
2804
2805 static void lib_link_paint_curve(FileData *fd, Main *main)
2806 {
2807   /* only link ID pointers */
2808   for (PaintCurve *pc = main->paintcurves.first; pc; pc = pc->id.next) {
2809     if (pc->id.tag & LIB_TAG_NEED_LINK) {
2810       IDP_LibLinkProperty(pc->id.properties, fd);
2811
2812       pc->id.tag &= ~LIB_TAG_NEED_LINK;
2813     }
2814   }
2815 }
2816
2817 static void direct_link_paint_curve(FileData *fd, PaintCurve *pc)
2818 {
2819   pc->points = newdataadr(fd, pc->points);
2820 }
2821
2822 /** \} */
2823
2824 /* -------------------------------------------------------------------- */
2825 /** \name Read PackedFile
2826  * \{ */
2827
2828 static PackedFile *direct_link_packedfile(FileData *fd, PackedFile *oldpf)
2829 {
2830   PackedFile *pf = newpackedadr(fd, oldpf);
2831
2832   if (pf) {
2833     pf->data = newpackedadr(fd, pf->data);
2834   }
2835
2836   return pf;
2837 }
2838
2839 /** \} */
2840
2841 /* -------------------------------------------------------------------- */
2842 /** \name Read Animation (legacy for version patching)
2843  * \{ */
2844
2845 // XXX deprecated - old animation system
2846 static void lib_link_ipo(FileData *fd, Main *main)
2847 {
2848   Ipo *ipo;
2849
2850   for (ipo = main->ipo.first; ipo; ipo = ipo->id.next) {
2851     if (ipo->id.tag & LIB_TAG_NEED_LINK) {
2852       IpoCurve *icu;
2853       for (icu = ipo->curve.first; icu; icu = icu->next) {
2854         if (icu->driver) {
2855           icu->driver->ob = newlibadr(fd, ipo->id.lib, icu->driver->ob);
2856         }
2857       }
2858       ipo->id.tag &= ~LIB_TAG_NEED_LINK;
2859     }
2860   }
2861 }
2862
2863 // XXX deprecated - old animation system
2864 static void direct_link_ipo(FileData *fd, Ipo *ipo)
2865 {
2866   IpoCurve *icu;
2867
2868   link_list(fd, &(ipo->curve));
2869
2870   for (icu = ipo->curve.first; icu; icu = icu->next) {
2871     icu->bezt = newdataadr(fd, icu->bezt);
2872     icu->bp = newdataadr(fd, icu->bp);
2873     icu->driver = newdataadr(fd, icu->driver);
2874   }
2875 }
2876
2877 // XXX deprecated - old animation system
2878 static void lib_link_nlastrips(FileData *fd, ID *id, ListBase *striplist)
2879 {
2880   bActionStrip *strip;
2881   bActionModifier *amod;
2882
2883   for (strip = striplist->first; strip; strip = strip->next) {
2884     strip->object = newlibadr(fd, id->lib, strip->object);
2885     strip->act = newlibadr_us(fd, id->lib, strip->act);
2886     strip->ipo = newlibadr(fd, id->lib, strip->ipo);
2887     for (amod = strip->modifiers.first; amod; amod = amod->next) {
2888       amod->ob = newlibadr(fd, id->lib, amod->ob);
2889     }
2890   }
2891 }
2892
2893 // XXX deprecated - old animation system
2894 static void direct_link_nlastrips(FileData *fd, ListBase *strips)
2895 {
2896   bActionStrip *strip;
2897
2898   link_list(fd, strips);
2899
2900   for (strip = strips->first; strip; strip = strip->next) {
2901     link_list(fd, &strip->modifiers);
2902   }
2903 }
2904
2905 // XXX deprecated - old animation system
2906 static void lib_link_constraint_channels(FileData *fd, ID *id, ListBase *chanbase)
2907 {
2908   bConstraintChannel *chan;
2909
2910   for (chan = chanbase->first; chan; chan = chan->next) {
2911     chan->ipo = newlibadr_us(fd, id->lib, chan->ipo);
2912   }
2913 }
2914
2915 /** \} */
2916
2917 /* -------------------------------------------------------------------- */
2918 /** \name Read ID: Action
2919  * \{ */
2920
2921 static void lib_link_fmodifiers(FileData *fd, ID *id, ListBase *list)
2922 {
2923   FModifier *fcm;
2924
2925   for (fcm = list->first; fcm; fcm = fcm->next) {
2926     /* data for specific modifiers */
2927     switch (fcm->type) {
2928       case FMODIFIER_TYPE_PYTHON: {
2929         FMod_Python *data = (FMod_Python *)fcm->data;
2930         data->script = newlibadr(fd, id->lib, data->script);
2931
2932         break;
2933       }
2934     }
2935   }
2936 }
2937
2938 static void lib_link_fcurves(FileData *fd, ID *id, ListBase *list)
2939 {
2940   FCurve *fcu;
2941
2942   if (list == NULL) {
2943     return;
2944   }
2945
2946   /* relink ID-block references... */
2947   for (fcu = list->first; fcu; fcu = fcu->next) {
2948     /* driver data */
2949     if (fcu->driver) {
2950       ChannelDriver *driver = fcu->driver;
2951       DriverVar *dvar;
2952
2953       for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
2954         DRIVER_TARGETS_LOOPER_BEGIN (dvar) {
2955           /* only relink if still used */
2956           if (tarIndex < dvar->num_targets) {
2957             dtar->id = newlibadr(fd, id->lib, dtar->id);
2958           }
2959           else {
2960             dtar->id = NULL;
2961           }
2962         }
2963         DRIVER_TARGETS_LOOPER_END;
2964       }
2965     }
2966
2967     /* modifiers */
2968     lib_link_fmodifiers(fd, id, &fcu->modifiers);
2969   }
2970 }
2971
2972 /* NOTE: this assumes that link_list has already been called on the list */
2973 static void direct_link_fmodifiers(FileData *fd, ListBase *list, FCurve *curve)
2974 {
2975   FModifier *fcm;
2976
2977   for (fcm = list->first; fcm; fcm = fcm->next) {
2978     /* relink general data */
2979     fcm->data = newdataadr(fd, fcm->data);
2980     fcm->curve = curve;
2981
2982     /* do relinking of data for specific types */
2983     switch (fcm->type) {
2984       case FMODIFIER_TYPE_GENERATOR: {
2985         FMod_Generator *data = (FMod_Generator *)fcm->data;
2986
2987         data->coefficients = newdataadr(fd, data->coefficients);
2988
2989         if (fd->flags & FD_FLAGS_SWITCH_ENDIAN) {
2990           BLI_endian_switch_float_array(data->coefficients, data->arraysize);
2991         }
2992
2993         break;
2994       }
2995       case FMODIFIER_TYPE_ENVELOPE: {
2996         FMod_Envelope *data = (FMod_Envelope *)fcm->data;
2997
2998         data->data = newdataadr(fd, data->data);
2999
3000         break;
3001       }
3002       case FMODIFIER_TYPE_PYTHON: {
3003         FMod_Python *data = (FMod_Python *)fcm->data;
3004
3005         data->prop = newdataadr(fd, data->prop);
3006         IDP_DirectLinkGroup_OrFree(&data->prop, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd);
3007
3008         break;
3009       }
3010     }
3011   }
3012 }
3013
3014 /* NOTE: this assumes that link_list has already been called on the list */
3015 static void direct_link_fcurves(FileData *fd, ListBase *list)
3016 {
3017   FCurve *fcu;
3018
3019   /* link F-Curve data to F-Curve again (non ID-libs) */
3020   for (fcu = list->first; fcu; fcu = fcu->next) {
3021     /* curve data */
3022     fcu->bezt = newdataadr(fd, fcu->bezt);
3023     fcu->fpt = newdataadr(fd, fcu->fpt);
3024
3025     /* rna path */
3026     fcu->rna_path = newdataadr(fd, fcu->rna_path);
3027
3028     /* group */
3029     fcu->grp = newdataadr(fd, fcu->grp);
3030
3031     /* clear disabled flag - allows disabled drivers to be tried again ([#32155]),
3032      * but also means that another method for "reviving disabled F-Curves" exists
3033      */
3034     fcu->flag &= ~FCURVE_DISABLED;
3035
3036     /* driver */
3037     fcu->driver = newdataadr(fd, fcu->driver);
3038     if (fcu->driver) {
3039       ChannelDriver *driver = fcu->driver;
3040       DriverVar *dvar;
3041
3042       /* Compiled expression data will need to be regenerated
3043        * (old pointer may still be set here). */
3044       driver->expr_comp = NULL;
3045       driver->expr_simple = NULL;
3046
3047       /* give the driver a fresh chance - the operating environment may be different now
3048        * (addons, etc. may be different) so the driver namespace may be sane now [#32155]
3049        */
3050       driver->flag &= ~DRIVER_FLAG_INVALID;
3051
3052       /* relink variables, targets and their paths */
3053       link_list(fd, &driver->variables);
3054       for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
3055         DRIVER_TARGETS_LOOPER_BEGIN (dvar) {
3056           /* only relink the targets being used */
3057           if (tarIndex < dvar->num_targets) {
3058             dtar->rna_path = newdataadr(fd, dtar->rna_path);
3059           }
3060           else {
3061             dtar->rna_path = NULL;
3062           }
3063         }
3064         DRIVER_TARGETS_LOOPER_END;
3065       }
3066     }
3067
3068     /* modifiers */
3069     link_list(fd, &fcu->modifiers);
3070     direct_link_fmodifiers(fd, &fcu->modifiers, fcu);
3071   }
3072 }
3073
3074 static void lib_link_action(FileData *fd, Main *main)
3075 {
3076   for (bAction *act = main->actions.first; act; act = act->id.next) {
3077     if (act->id.tag & LIB_TAG_NEED_LINK) {
3078       IDP_LibLinkProperty(act->id.properties, fd);
3079
3080       // XXX deprecated - old animation system <<<
3081       for (bActionChannel *chan = act->chanbase.first; chan; chan = chan->next) {
3082         chan->ipo = newlibadr_us(fd, act->id.lib, chan->ipo);
3083         lib_link_constraint_channels(fd, &act->id, &chan->constraintChannels);
3084       }
3085       // >>> XXX deprecated - old animation system
3086
3087       lib_link_fcurves(fd, &act->id, &act->curves);
3088
3089       for (TimeMarker *marker = act->markers.first; marker; marker = marker->next) {
3090         if (marker->camera) {
3091           marker->camera = newlibadr(fd, act->id.lib, marker->camera);
3092         }
3093       }
3094
3095       act->id.tag &= ~LIB_TAG_NEED_LINK;
3096     }
3097   }
3098 }
3099
3100 static void direct_link_action(FileData *fd, bAction *act)
3101 {
3102   bActionChannel *achan;  // XXX deprecated - old animation system
3103   bActionGroup *agrp;
3104
3105   link_list(fd, &act->curves);
3106   link_list(fd, &act->chanbase);  // XXX deprecated - old animation system
3107   link_list(fd, &act->groups);
3108   link_list(fd, &act->markers);
3109
3110   // XXX deprecated - old animation system <<<
3111   for (achan = act->chanbase.first; achan; achan = achan->next) {
3112     achan->grp = newdataadr(fd, achan->grp);
3113
3114     link_list(fd, &achan->constraintChannels);
3115   }
3116   // >>> XXX deprecated - old animation system
3117
3118   direct_link_fcurves(fd, &act->curves);
3119
3120   for (agrp = act->groups.first; agrp; agrp = agrp->next) {
3121     agrp->channels.first = newdataadr(fd, agrp->channels.first);
3122     agrp->channels.last = newdataadr(fd, agrp->channels.last);
3123   }
3124 }
3125
3126 static void lib_link_nladata_strips(FileData *fd, ID *id, ListBase *list)
3127 {
3128   NlaStrip *strip;
3129
3130   for (strip = list->first; strip; strip = strip->next) {
3131     /* check strip's children */
3132     lib_link_nladata_strips(fd, id, &strip->strips);
3133
3134     /* check strip's F-Curves */
3135     lib_link_fcurves(fd, id, &strip->fcurves);
3136
3137     /* reassign the counted-reference to action */
3138     strip->act = newlibadr_us(fd, id->lib, strip->act);
3139
3140     /* fix action id-root (i.e. if it comes from a pre 2.57 .blend file) */
3141     if ((strip->act) && (strip->act->idroot == 0)) {
3142       strip->act->idroot = GS(id->name);
3143     }
3144   }
3145 }
3146
3147 static void lib_link_nladata(FileData *fd, ID *id, ListBase *list)
3148 {
3149   NlaTrack *nlt;
3150
3151   /* we only care about the NLA strips inside the tracks */
3152   for (nlt = list->first; nlt; nlt = nlt->next) {
3153     lib_link_nladata_strips(fd, id, &nlt->strips);
3154   }
3155 }
3156
3157 /* This handles Animato NLA-Strips linking
3158  * NOTE: this assumes that link_list has already been called on the list
3159  */
3160 static void direct_link_nladata_strips(FileData *fd, ListBase *list)
3161 {
3162   NlaStrip *strip;
3163
3164   for (strip = list->first; strip; strip = strip->next) {
3165     /* strip's child strips */
3166     link_list(fd, &strip->strips);
3167     direct_link_nladata_strips(fd, &strip->strips);
3168
3169     /* strip's F-Curves */
3170     link_list(fd, &strip->fcurves);
3171     direct_link_fcurves(fd, &strip->fcurves);
3172
3173     /* strip's F-Modifiers */
3174     link_list(fd, &strip->modifiers);
3175     direct_link_fmodifiers(fd, &strip->modifiers, NULL);
3176   }
3177 }
3178
3179 /* NOTE: this assumes that link_list has already been called on the list */
3180 static void direct_link_nladata(FileData *fd, ListBase *list)
3181 {
3182   NlaTrack *nlt;
3183
3184   for (nlt = list->first; nlt; nlt = nlt->next) {
3185     /* relink list of strips */
3186     link_list(fd, &nlt->strips);
3187
3188     /* relink strip data */
3189     direct_link_nladata_strips(fd, &nlt->strips);
3190   }
3191 }
3192
3193 /* ------- */
3194
3195 static void lib_link_keyingsets(FileData *fd, ID *id, ListBase *list)
3196 {
3197   KeyingSet *ks;
3198   KS_Path *ksp;
3199
3200   /* here, we're only interested in the ID pointer stored in some of the paths */
3201   for (ks = list->first; ks; ks = ks->next) {
3202     for (ksp = ks->paths.first; ksp; ksp = ksp->next) {
3203       ksp->id = newlibadr(fd, id->lib, ksp->id);
3204     }
3205   }
3206 }
3207
3208 /* NOTE: this assumes that link_list has already been called on the list */
3209 static void direct_link_keyingsets(FileData *fd, ListBase *list)
3210 {
3211   KeyingSet *ks;
3212   KS_Path *ksp;
3213
3214   /* link KeyingSet data to KeyingSet again (non ID-libs) */
3215   for (ks = list->first; ks; ks = ks->next) {
3216     /* paths */
3217     link_list(fd, &ks->paths);
3218
3219     for (ksp = ks->paths.first; ksp; ksp = ksp->next) {
3220       /* rna path */
3221       ksp->rna_path = newdataadr(fd, ksp->rna_path);
3222     }
3223   }
3224 }
3225
3226 /* ------- */
3227
3228 static void lib_link_animdata(FileData *fd, ID *id, AnimData *adt)
3229 {
3230   if (adt == NULL) {
3231     return;
3232   }
3233
3234   /* link action data */
3235   adt->action = newlibadr_us(fd, id->lib, adt->action);
3236   adt->tmpact = newlibadr_us(fd, id->lib, adt->tmpact);
3237
3238   /* fix action id-roots (i.e. if they come from a pre 2.57 .blend file) */
3239   if ((adt->action) && (adt->action->idroot == 0)) {
3240     adt->action->idroot = GS(id->name);
3241   }
3242   if ((adt->tmpact) && (adt->tmpact->idroot == 0)) {
3243     adt->tmpact->idroot = GS(id->name);
3244   }
3245
3246   /* link drivers */
3247   lib_link_fcurves(fd, id, &adt->drivers);
3248
3249   /* overrides don't have lib-link for now, so no need to do anything */
3250
3251   /* link NLA-data */
3252   lib_link_nladata(fd, id, &adt->nla_tracks);
3253 }
3254
3255 static void direct_link_animdata(FileData *fd, AnimData *adt)
3256 {
3257   /* NOTE: must have called newdataadr already before doing this... */
3258   if (adt == NULL) {
3259     return;
3260   }
3261
3262   /* link drivers */
3263   link_list(fd, &adt->drivers);
3264   direct_link_fcurves(fd, &adt->drivers);
3265   adt->driver_array = NULL;
3266
3267   /* link overrides */
3268   // TODO...
3269
3270   /* link NLA-data */
3271   link_list(fd, &adt->nla_tracks);
3272   direct_link_nladata(fd, &adt->nla_tracks);
3273
3274   /* relink active track/strip - even though strictly speaking this should only be used
3275    * if we're in 'tweaking mode', we need to be able to have this loaded back for
3276    * undo, but also since users may not exit tweakmode before saving (#24535)
3277    */
3278   // TODO: it's not really nice that anyone should be able to save the file in this
3279   //      state, but it's going to be too hard to enforce this single case...
3280   adt->act_track = newdataadr(fd, adt->act_track);
3281   adt->actstrip = newdataadr(fd, adt->actstrip);
3282 }
3283
3284 /** \} */
3285
3286 /* -------------------------------------------------------------------- */
3287 /** \name Read ID: CacheFiles
3288  * \{ */
3289
3290 static void lib_link_cachefiles(FileData *fd, Main *bmain)
3291 {
3292   /* only link ID pointers */
3293   for (CacheFile *cache_file = bmain->cachefiles.first; cache_file;
3294        cache_file = cache_file->id.next) {
3295     if (cache_file->id.tag & LIB_TAG_NEED_LINK) {
3296       IDP_LibLinkProperty(cache_file->id.properties, fd);
3297       lib_link_animdata(fd, &cache_file->id, cache_file->adt);
3298
3299       cache_file->id.tag &= ~LIB_TAG_NEED_LINK;
3300     }
3301   }
3302 }
3303
3304 static void direct_link_cachefile(FileData *fd, CacheFile *cache_file)
3305 {
3306   BLI_listbase_clear(&cache_file->object_paths);
3307   cache_file->handle = NULL;
3308   cache_file->handle_filepath[0] = '\0';
3309   cache_file->handle_readers = NULL;
3310
3311   /* relink animdata */
3312   cache_file->adt = newdataadr(fd, cache_file->adt);
3313   direct_link_animdata(fd, cache_file->adt);
3314 }
3315
3316 /** \} */
3317
3318 /* -------------------------------------------------------------------- */
3319 /** \name Read ID: WorkSpace
3320  * \{ */
3321
3322 static void lib_link_workspaces(FileData *fd, Main *bmain)
3323 {
3324   for (WorkSpace *workspace = bmain->workspaces.first; workspace; workspace = workspace->id.next) {
3325     ListBase *layouts = BKE_workspace_layouts_get(workspace);
3326     ID *id = (ID *)workspace;
3327
3328     if ((id->tag & LIB_TAG_NEED_LINK) == 0) {
3329       continue;
3330     }
3331     IDP_LibLinkProperty(id->properties, fd);
3332     id_us_ensure_real(id);
3333
3334     for (WorkSpaceLayout *layout = layouts->first, *layout_next; layout; layout = layout_next) {
3335       layout->screen = newlibadr_us(fd, id->lib, layout->screen);
3336
3337       layout_next = layout->next;
3338       if (layout->screen) {
3339         if (ID_IS_LINKED(id)) {
3340           layout->screen->winid = 0;
3341           if (layout->screen->temp) {
3342             /* delete temp layouts when appending */
3343             BKE_workspace_layout_remove(bmain, workspace, layout);
3344           }
3345         }
3346       }
3347     }
3348
3349     id->tag &= ~LIB_TAG_NEED_LINK;
3350   }
3351 }
3352
3353 static void direct_link_workspace(FileData *fd, WorkSpace *workspace, const Main *main)
3354 {
3355   link_list(fd, BKE_workspace_layouts_get(workspace));
3356   link_list(fd, &workspace->hook_layout_relations);
3357   link_list(fd, &workspace->owner_ids);
3358   link_list(fd, &workspace->tools);
3359
3360   for (WorkSpaceDataRelation *relation = workspace->hook_layout_relations.first; relation;
3361        relation = relation->next) {
3362     relation->parent = newglobadr(
3363         fd, relation->parent); /* data from window - need to access through global oldnew-map */
3364     relation->value = newdataadr(fd, relation->value);
3365   }
3366
3367   /* Same issue/fix as in direct_link_workspace_link_scene_data: Can't read workspace data
3368    * when reading windows, so have to update windows after/when reading workspaces. */
3369   for (wmWindowManager *wm = main->wm.first; wm; wm = wm->id.next) {
3370     for (wmWindow *win = wm->windows.first; win; win = win->next) {
3371       WorkSpaceLayout *act_layout = newdataadr(
3372           fd, BKE_workspace_active_layout_get(win->workspace_hook));
3373       if (act_layout) {
3374         BKE_workspace_active_layout_set(win->workspace_hook, act_layout);
3375       }
3376     }
3377   }
3378
3379   for (bToolRef *tref = workspace->tools.first; tref; tref = tref->next) {
3380     tref->runtime = NULL;
3381     tref->properties = newdataadr(fd, tref->properties);
3382     IDP_DirectLinkGroup_OrFree(&tref->properties, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd);
3383   }
3384
3385   workspace->status_text = NULL;
3386 }
3387
3388 static void lib_link_workspace_instance_hook(FileData *fd, WorkSpaceInstanceHook *hook, ID *id)
3389 {
3390   WorkSpace *workspace = BKE_workspace_active_get(hook);
3391   BKE_workspace_active_set(hook, newlibadr(fd, id->lib, workspace));
3392 }
3393
3394 /** \} */
3395
3396 /* -------------------------------------------------------------------- */
3397 /** \name Read ID: Node Tree
3398  * \{ */
3399
3400 /* Single node tree (also used for material/scene trees), ntree is not NULL */
3401 static void lib_link_ntree(FileData *fd, ID *id, bNodeTree *ntree)
3402 {
3403   IDP_LibLinkProperty(ntree->id.properties, fd);
3404   lib_link_animdata(fd, &ntree->id, ntree->adt);
3405
3406   ntree->gpd = newlibadr_us(fd, id->lib, ntree->gpd);
3407
3408   for (bNode *node = ntree->nodes.first; node; node = node->next) {
3409     /* Link ID Properties -- and copy this comment EXACTLY for easy finding
3410      * of library blocks that implement this.*/
3411     IDP_LibLinkProperty(node->prop, fd);
3412
3413     node->id = newlibadr_us(fd, id->lib, node->id);
3414
3415     for (bNodeSocket *sock = node->inputs.first; sock; sock = sock->next) {
3416       IDP_LibLinkProperty(sock->prop, fd);
3417     }
3418     for (bNodeSocket *sock = node->outputs.first; sock; sock = sock->next) {
3419       IDP_LibLinkProperty(sock->prop, fd);
3420     }
3421   }
3422
3423   for (bNodeSocket *sock = ntree->inputs.first; sock; sock = sock->next) {
3424     IDP_LibLinkProperty(sock->prop, fd);
3425   }
3426   for (bNodeSocket *sock = ntree->outputs.first; sock; sock = sock->next) {
3427     IDP_LibLinkProperty(sock->prop, fd);
3428   }
3429
3430   /* Set node->typeinfo pointers. This is done in lib linking, after the
3431    * first versioning that can change types still without functions that
3432    * update the typeinfo pointers. Versioning after lib linking needs
3433    * these top be valid. */
3434   ntreeSetTypes(NULL, ntree);
3435
3436   /* For nodes with static socket layout, add/remove sockets as needed
3437    * to match the static layout. */
3438   if (fd->memfile == NULL) {
3439     for (bNode *node = ntree->nodes.first; node; node = node->next) {
3440       node_verify_socket_templates(ntree, node);
3441     }
3442   }
3443 }
3444
3445 /* library ntree linking after fileread */
3446 static void lib_link_nodetree(FileData *fd, Main *main)
3447 {
3448   /* only link ID pointers */
3449   for (bNodeTree *ntree = main->nodetrees.first; ntree; ntree = ntree->id.next) {
3450     if (ntree->id.tag & LIB_TAG_NEED_LINK) {
3451       lib_link_ntree(fd, &ntree->id, ntree);
3452
3453       ntree->id.tag &= ~LIB_TAG_NEED_LINK;
3454     }
3455   }
3456 }
3457
3458 static void direct_link_node_socket(FileData *fd, bNodeSocket *sock)
3459 {
3460   sock->prop = newdataadr(fd, sock->prop);
3461   IDP_DirectLinkGroup_OrFree(&sock->prop, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd);
3462
3463   sock->link = newdataadr(fd, sock->link);
3464   sock->typeinfo = NULL;
3465   sock->storage = newdataadr(fd, sock->storage);
3466   sock->default_value = newdataadr(fd, sock->default_value);
3467   sock->cache = NULL;
3468 }
3469
3470 /* ntree itself has been read! */
3471 static void direct_link_nodetree(FileData *fd, bNodeTree *ntree)
3472 {
3473   /* note: writing and reading goes in sync, for speed */
3474   bNode *node;
3475   bNodeSocket *sock;
3476   bNodeLink *link;
3477
3478   ntree->init = 0; /* to set callbacks and force setting types */
3479   ntree->is_updating = false;
3480   ntree->typeinfo = NULL;
3481   ntree->interface_type = NULL;
3482
3483   ntree->progress = NULL;
3484   ntree->execdata = NULL;
3485   ntree->duplilock = NULL;
3486
3487   ntree->adt = newdataadr(fd, ntree->adt);
3488   direct_link_animdata(fd, ntree->adt);
3489
3490   ntree->id.recalc &= ~ID_RECALC_ALL;
3491
3492   link_list(fd, &ntree->nodes);
3493   for (node = ntree->nodes.first; node; node = node->next) {
3494     node->typeinfo = NULL;
3495
3496     link_list(fd, &node->inputs);
3497     link_list(fd, &node->outputs);
3498
3499     node->prop = newdataadr(fd, node->prop);
3500     IDP_DirectLinkGroup_OrFree(&node->prop, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd);
3501
3502     link_list(fd, &node->internal_links);
3503     for (link = node->internal_links.first; link; link = link->next) {
3504       link->fromnode = newdataadr(fd, link->fromnode);
3505       link->fromsock = newdataadr(fd, link->fromsock);
3506       link->tonode = newdataadr(fd, link->tonode);
3507       link->tosock = newdataadr(fd, link->tosock);
3508     }
3509
3510     if (node->type == CMP_NODE_MOVIEDISTORTION) {
3511       node->storage = newmclipadr(fd, node->storage);
3512     }
3513     else {
3514       node->storage = newdataadr(fd, node->storage);
3515     }
3516
3517     if (node->storage) {
3518       /* could be handlerized at some point */
3519       if (ntree->type == NTREE_SHADER) {
3520         if (node->type == SH_NODE_CURVE_VEC || node->type == SH_NODE_CURVE_RGB) {
3521           direct_link_curvemapping(fd, node->storage);
3522         }
3523         else if (node->type == SH_NODE_SCRIPT) {
3524           NodeShaderScript *nss = (NodeShaderScript *)node->storage;
3525           nss->bytecode = newdataadr(fd, nss->bytecode);
3526         }
3527         else if (node->type == SH_NODE_TEX_POINTDENSITY) {
3528           NodeShaderTexPointDensity *npd = (NodeShaderTexPointDensity *)node->storage;
3529           memset(&npd->pd, 0, sizeof(npd->pd));
3530         }
3531         else if (node->type == SH_NODE_TEX_IMAGE) {
3532           NodeTexImage *tex = (NodeTexImage *)node->storage;
3533           tex->iuser.ok = 1;
3534           tex->iuser.scene = NULL;
3535         }
3536         else if (node->type == SH_NODE_TEX_ENVIRONMENT) {
3537           NodeTexEnvironment *tex = (NodeTexEnvironment *)node->storage;
3538           tex->iuser.ok = 1;
3539           tex->iuser.scene = NULL;
3540         }
3541       }
3542       else if (ntree->type == NTREE_COMPOSIT) {
3543         if (ELEM(node->type,
3544                  CMP_NODE_TIME,
3545                  CMP_NODE_CURVE_VEC,
3546                  CMP_NODE_CURVE_RGB,
3547                  CMP_NODE_HUECORRECT)) {
3548           direct_link_curvemapping(fd, node->storage);
3549         }
3550         else if (ELEM(node->type,
3551                       CMP_NODE_IMAGE,
3552                       CMP_NODE_R_LAYERS,
3553                       CMP_NODE_VIEWER,
3554                       CMP_NODE_SPLITVIEWER)) {
3555           ImageUser *iuser = node->storage;
3556           iuser->ok = 1;
3557           iuser->scene = NULL;
3558         }
3559         else if (node->type == CMP_NODE_CRYPTOMATTE) {
3560           NodeCryptomatte *nc = (NodeCryptomatte *)node->storage;
3561           nc->matte_id = newdataadr(fd, nc->matte_id);
3562         }
3563       }
3564       else if (ntree->type == NTREE_TEXTURE) {
3565         if (node->type == TEX_NODE_CURVE_RGB || node->type == TEX_NODE_CURVE_TIME) {
3566           direct_link_curvemapping(fd, node->storage);
3567         }
3568         else if (node->type == TEX_NODE_IMAGE) {
3569           ImageUser *iuser = node->storage;
3570           iuser->ok = 1;
3571           iuser->scene = NULL;
3572         }
3573       }
3574     }
3575   }
3576   link_list(fd, &ntree->links);
3577
3578   /* and we connect the rest */
3579   for (node = ntree->nodes.first; node; node = node->next) {
3580     node->parent = newdataadr(fd, node->parent);
3581     node->lasty = 0;
3582
3583     for (sock = node->inputs.first; sock; sock = sock->next) {
3584       direct_link_node_socket(fd, sock);
3585     }
3586     for (sock = node->outputs.first; sock; sock = sock->next) {
3587       direct_link_node_socket(fd, sock);
3588     }
3589   }
3590
3591   /* interface socket lists */
3592   link_list(fd, &ntree->inputs);
3593   link_list(fd, &ntree->outputs);
3594   for (sock = ntree->inputs.first; sock; sock = sock->next) {
3595     direct_link_node_socket(fd, sock);
3596   }
3597   for (sock = ntree->outputs.first; sock; sock = sock->next) {
3598     direct_link_node_socket(fd, sock);
3599   }
3600
3601   for (link = ntree->links.first; link; link = link->next) {
3602     link->fromnode = newdataadr(fd, link->fromnode);
3603     link->tonode = newdataadr(fd, link->tonode);
3604     link->fromsock = newdataadr(fd, link->fromsock);
3605     link->tosock = newdataadr(fd, link->tosock);
3606   }
3607
3608 #if 0
3609   if (ntree->previews) {
3610     bNodeInstanceHash *new_previews = BKE_node_instance_hash_new("node previews");
3611     bNodeInstanceHashIterator iter;
3612
3613     NODE_INSTANCE_HASH_ITER(iter, ntree->previews) {
3614       bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
3615       if (preview) {
3616         bNodePreview *new_preview = newimaadr(fd, preview);
3617         if (new_preview) {
3618           bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
3619           BKE_node_instance_hash_insert(new_previews, key, new_preview);
3620         }
3621       }
3622     }
3623     BKE_node_instance_hash_free(ntree->previews, NULL);
3624     ntree->previews = new_previews;
3625   }
3626 #else
3627   /* XXX TODO */
3628   ntree->previews = NULL;
3629 #endif
3630
3631   /* type verification is in lib-link */
3632 }
3633
3634 /** \} */
3635
3636 /* -------------------------------------------------------------------- */
3637 /** \name Read ID: Armature
3638  * \{ */
3639
3640 /* temp struct used to transport needed info to lib_link_constraint_cb() */
3641 typedef struct tConstraintLinkData {
3642   FileData *fd;
3643   ID *id;
3644 } tConstraintLinkData;
3645 /* callback function used to relink constraint ID-links */
3646 static void lib_link_constraint_cb(bConstraint *UNUSED(con),
3647                                    ID **idpoin,
3648                                    bool is_reference,
3649                                    void *userdata)
3650 {
3651   tConstraintLinkData *cld = (tConstraintLinkData *)userdata;
3652
3653   /* for reference types, we need to increment the usercounts on load... */
3654   if (is_reference) {
3655     /* reference type - with usercount */
3656     *idpoin = newlibadr_us(cld->fd, cld->id->lib, *idpoin);
3657   }
3658   else {
3659     /* target type - no usercount needed */
3660     *idpoin = newlibadr(cld->fd, cld->id->lib, *idpoin);
3661   }
3662 }
3663
3664 static void lib_link_constraints(FileData *fd, ID *id, ListBase *conlist)
3665 {
3666   tConstraintLinkData cld;
3667   bConstraint *con;
3668
3669   /* legacy fixes */
3670   for (con = conlist->first; con; con = con->next) {
3671     /* patch for error introduced by changing constraints (dunno how) */
3672     /* if con->data type changes, dna cannot resolve the pointer! (ton) */
3673     if (con->data == NULL) {
3674       con->type = CONSTRAINT_TYPE_NULL;
3675     }
3676     /* own ipo, all constraints have it */
3677     con->ipo = newlibadr_us(fd, id->lib, con->ipo);  // XXX deprecated - old animation system
3678
3679     /* If linking from a library, clear 'local' static override flag. */
3680     if (id->lib != NULL) {
3681       con->flag &= ~CONSTRAINT_STATICOVERRIDE_LOCAL;
3682     }
3683   }
3684
3685   /* relink all ID-blocks used by the constraints */
3686   cld.fd = fd;
3687   cld.id = id;
3688
3689   BKE_constraints_id_loop(conlist, lib_link_constraint_cb, &cld);
3690 }
3691
3692 static void direct_link_constraints(FileData *fd, ListBase *lb)
3693 {
3694   bConstraint *con;
3695
3696   link_list(fd, lb);
3697   for (con = lb->first; con; con = con->next) {
3698     con->data = newdataadr(fd, con->data);
3699
3700     switch (con->type) {
3701       case CONSTRAINT_TYPE_PYTHON: {
3702         bPythonConstraint *data = con->data;
3703
3704         link_list(fd, &data->targets);
3705
3706         data->prop = newdataadr(fd, data->prop);
3707         IDP_DirectLinkGroup_OrFree(&data->prop, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd);
3708         break;
3709       }
3710       case CONSTRAINT_TYPE_ARMATURE: {
3711         bArmatureConstraint *data = con->data;
3712
3713         link_list(fd, &data->targets);
3714
3715         break;
3716       }
3717       case CONSTRAINT_TYPE_SPLINEIK: {
3718         bSplineIKConstraint *data = con->data;
3719
3720         data->points = newdataadr(fd, data->points);
3721         break;
3722       }
3723       case CONSTRAINT_TYPE_KINEMATIC: {
3724         bKinematicConstraint *data = con->data;
3725
3726         con->lin_error = 0.f;
3727         con->rot_error = 0.f;
3728
3729         /* version patch for runtime flag, was not cleared in some case */
3730         data->flag &= ~CONSTRAINT_IK_AUTO;
3731         break;
3732       }
3733       case CONSTRAINT_TYPE_CHILDOF: {
3734         /* XXX version patch, in older code this flag wasn't always set, and is inherent to type */
3735         if (con->ownspace == CONSTRAINT_SPACE_POSE) {
3736           con->flag |= CONSTRAINT_SPACEONCE;
3737         }
3738         break;
3739       }
3740       case CONSTRAINT_TYPE_TRANSFORM_CACHE: {
3741         bTransformCacheConstraint *data = con->data;
3742         data->reader = NULL;
3743         data->reader_object_path[0] = '\0';
3744       }
3745     }
3746   }
3747 }
3748
3749 static void lib_link_pose(FileData *fd, Main *bmain, Object *ob, bPose *pose)
3750 {
3751   bArmature *arm = ob->data;
3752
3753   if (!pose || !arm) {
3754     return;
3755   }
3756
3757   /* always rebuild to match proxy or lib changes, but on Undo */
3758   bool rebuild = false;
3759
3760   if (fd->memfile == NULL) {
3761     if (ob->proxy || ob->id.lib != arm->id.lib) {
3762       rebuild = true;
3763     }
3764   }
3765
3766   if (ob->proxy) {
3767     /* sync proxy layer */
3768     if (pose->proxy_layer) {
3769       arm->layer = pose->proxy_layer;
3770     }
3771
3772     /* sync proxy active bone */
3773     if (pose->proxy_act_bone[0]) {
3774       Bone *bone = BKE_armature_find_bone_name(arm, pose->proxy_act_bone);
3775       if (bone) {
3776         arm->act_bone = bone;
3777       }
3778     }
3779   }
3780
3781   for (bPoseChannel *pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
3782     lib_link_constraints(fd, (ID *)ob, &pchan->constraints);
3783
3784     pchan->bone = BKE_armature_find_bone_name(arm, pchan->name);
3785
3786     IDP_LibLinkProperty(pchan->prop, fd);
3787
3788     pchan->custom = newlibadr_us(fd, arm->id.lib, pchan->custom);
3789     if (UNLIKELY(pchan->bone == NULL)) {
3790       rebuild = true;
3791     }
3792     else if ((ob->id.lib == NULL) && arm->id.lib) {