source/blender/blenloader/intern/readfile.c

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