source/blender/blenkernel/intern/packedFile.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  19  * All rights reserved.
  20  *
  21  * The Original Code is: all of this file.
  22  *
  23  * Contributor(s): none yet.
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 /** \file blender/blenkernel/intern/packedFile.c
  29  *  \ingroup bke
  30  */
  31
  32
  33 #include <stdio.h>
  34 #include <fcntl.h>
  35 #include <sys/stat.h>
  36
  37 #ifndef WIN32
  38 #include <unistd.h>
  39 #else
  40 #include <io.h>
  41 #endif
  42 #include <string.h>
  43 #include "MEM_guardedalloc.h"
  44
  45 #include "DNA_image_types.h"
  46 #include "DNA_ID.h"
  47 #include "DNA_packedFile_types.h"
  48 #include "DNA_sound_types.h"
  49 #include "DNA_vfont_types.h"
  50
  51 #include "BLI_blenlib.h"
  52 #include "BLI_utildefines.h"
  53
  54 #include "BKE_font.h"
  55 #include "BKE_global.h"
  56 #include "BKE_image.h"
  57 #include "BKE_main.h"
  58 #include "BKE_packedFile.h"
  59 #include "BKE_report.h"
  60 #include "BKE_sound.h"
  61
  62 int seekPackedFile(PackedFile *pf, int offset, int whence)
  63 {
  64         int oldseek = -1, seek = 0;
  65
  66         if (pf) {
  67                 oldseek = pf->seek;
  68                 switch (whence) {
  69                         case SEEK_CUR:
  70                                 seek = oldseek + offset;
  71                                 break;
  72                         case SEEK_END:
  73                                 seek = pf->size + offset;
  74                                 break;
  75                         case SEEK_SET:
  76                                 seek = offset;
  77                                 break;
  78                         default:
  79                                 oldseek = -1;
  80                                 break;
  81                 }
  82                 if (seek < 0) {
  83                         seek = 0;
  84                 }
  85                 else if (seek > pf->size) {
  86                         seek = pf->size;
  87                 }
  88                 pf->seek = seek;
  89         }
  90
  91         return(oldseek);
  92 }
  93
  94 void rewindPackedFile(PackedFile *pf)
  95 {
  96         seekPackedFile(pf, 0, SEEK_SET);
  97 }
  98
  99 int readPackedFile(PackedFile *pf, void *data, int size)
 100 {
 101         if ((pf != NULL) && (size >= 0) && (data != NULL)) {
 102                 if (size + pf->seek > pf->size) {
 103                         size = pf->size - pf->seek;
 104                 }
 105
 106                 if (size > 0) {
 107                         memcpy(data, ((char *) pf->data) + pf->seek, size);
 108                 }
 109                 else {
 110                         size = 0;
 111                 }
 112
 113                 pf->seek += size;
 114         }
 115         else {
 116                 size = -1;
 117         }
 118
 119         return(size);
 120 }
 121
 122 int countPackedFiles(Main *bmain)
 123 {
 124         Image *ima;
 125         VFont *vf;
 126         bSound *sound;
 127         int count = 0;
 128
 129         /* let's check if there are packed files... */
 130         for (ima = bmain->image.first; ima; ima = ima->id.next)
 131                 if (BKE_image_has_packedfile(ima))
 132                         count ++;
 133
 134         for (vf = bmain->vfont.first; vf; vf = vf->id.next)
 135                 if (vf->packedfile)
 136                         count++;
 137
 138         for (sound = bmain->sound.first; sound; sound = sound->id.next)
 139                 if (sound->packedfile)
 140                         count++;
 141
 142         return count;
 143 }
 144
 145 void freePackedFile(PackedFile *pf)
 146 {
 147         if (pf) {
 148                 MEM_freeN(pf->data);
 149                 MEM_freeN(pf);
 150         }
 151         else
 152                 printf("freePackedFile: Trying to free a NULL pointer\n");
 153 }
 154
 155 PackedFile *dupPackedFile(const PackedFile *pf_src)
 156 {
 157         PackedFile *pf_dst;
 158
 159         pf_dst       = MEM_dupallocN(pf_src);
 160         pf_dst->data = MEM_dupallocN(pf_src->data);
 161
 162         return pf_dst;
 163 }
 164
 165 PackedFile *newPackedFileMemory(void *mem, int memlen)
 166 {
 167         PackedFile *pf = MEM_callocN(sizeof(*pf), "PackedFile");
 168         pf->data = mem;
 169         pf->size = memlen;
 170
 171         return pf;
 172 }
 173
 174 PackedFile *newPackedFile(ReportList *reports, const char *filename, const char *basepath)
 175 {
 176         PackedFile *pf = NULL;
 177         int file, filelen;
 178         char name[FILE_MAX];
 179         void *data;
 180
 181         /* render result has no filename and can be ignored
 182          * any other files with no name can be ignored too */
 183         if (filename[0] == '\0')
 184                 return NULL;
 185
 186         //XXX waitcursor(1);
 187
 188         /* convert relative filenames to absolute filenames */
 189
 190         BLI_strncpy(name, filename, sizeof(name));
 191         BLI_path_abs(name, basepath);
 192
 193         /* open the file
 194          * and create a PackedFile structure */
 195
 196         file = BLI_open(name, O_BINARY | O_RDONLY, 0);
 197         if (file == -1) {
 198                 BKE_reportf(reports, RPT_ERROR, "Unable to pack file, source path '%s' not found", name);
 199         }
 200         else {
 201                 filelen = BLI_file_descriptor_size(file);
 202
 203                 if (filelen == 0) {
 204                         /* MEM_mallocN complains about MEM_mallocN(0, "bla");
 205                          * we don't care.... */
 206                         data = MEM_mallocN(1, "packFile");
 207                 }
 208                 else {
 209                         data = MEM_mallocN(filelen, "packFile");
 210                 }
 211                 if (read(file, data, filelen) == filelen) {
 212                         pf = newPackedFileMemory(data, filelen);
 213                 }
 214                 else {
 215                         MEM_freeN(data);
 216                 }
 217
 218                 close(file);
 219         }
 220
 221         //XXX waitcursor(0);
 222
 223         return (pf);
 224 }
 225
 226 /* no libraries for now */
 227 void packAll(Main *bmain, ReportList *reports, bool verbose)
 228 {
 229         Image *ima;
 230         VFont *vfont;
 231         bSound *sound;
 232         int tot = 0;
 233
 234         for (ima = bmain->image.first; ima; ima = ima->id.next) {
 235                 if (BKE_image_has_packedfile(ima) == false && !ID_IS_LINKED(ima)) {
 236                         if (ima->source == IMA_SRC_FILE) {
 237                                 BKE_image_packfiles(reports, ima, ID_BLEND_PATH(bmain, &ima->id));
 238                                 tot ++;
 239                         }
 240                         else if (BKE_image_is_animated(ima) && verbose) {
 241                                 BKE_reportf(reports, RPT_WARNING, "Image '%s' skipped, movies and image sequences not supported",
 242                                             ima->id.name + 2);
 243                         }
 244                 }
 245         }
 246
 247         for (vfont = bmain->vfont.first; vfont; vfont = vfont->id.next) {
 248                 if (vfont->packedfile == NULL && !ID_IS_LINKED(vfont) && BKE_vfont_is_builtin(vfont) == false) {
 249                         vfont->packedfile = newPackedFile(reports, vfont->name, bmain->name);
 250                         tot ++;
 251                 }
 252         }
 253
 254         for (sound = bmain->sound.first; sound; sound = sound->id.next) {
 255                 if (sound->packedfile == NULL && !ID_IS_LINKED(sound)) {
 256                         sound->packedfile = newPackedFile(reports, sound->name, bmain->name);
 257                         tot++;
 258                 }
 259         }
 260
 261         if (tot > 0)
 262                 BKE_reportf(reports, RPT_INFO, "Packed %d files", tot);
 263         else if (verbose)
 264                 BKE_report(reports, RPT_INFO, "No new files have been packed");
 265 }
 266
 267
 268 #if 0
 269
 270 // attempt to create a function that generates an unique filename
 271 // this will work when all funtions in fileops.c understand relative filenames...
 272
 273 static char *find_new_name(char *name)
 274 {
 275         char tempname[FILE_MAX];
 276         char *newname;
 277         size_t len;
 278
 279         if (fop_exists(name)) {
 280                 for (number = 1; number <= 999; number++) {
 281                         BLI_snprintf(tempname, sizeof(tempname), "%s.%03d", name, number);
 282                         if (!fop_exists(tempname)) {
 283                                 break;
 284                         }
 285                 }
 286         }
 287         len = strlen(tempname) + 1;
 288         newname = MEM_mallocN(len, "find_new_name");
 289         memcpy(newname, tempname, len * sizeof(char));
 290         return newname;
 291 }
 292 #endif
 293
 294 int writePackedFile(ReportList *reports, const char *filename, PackedFile *pf, int guimode)
 295 {
 296         int file, number;
 297         int ret_value = RET_OK;
 298         bool remove_tmp = false;
 299         char name[FILE_MAX];
 300         char tempname[FILE_MAX];
 301 /*      void *data; */
 302
 303         if (guimode) {} //XXX  waitcursor(1);
 304
 305         BLI_strncpy(name, filename, sizeof(name));
 306         BLI_path_abs(name, G.main->name);
 307
 308         if (BLI_exists(name)) {
 309                 for (number = 1; number <= 999; number++) {
 310                         BLI_snprintf(tempname, sizeof(tempname), "%s.%03d_", name, number);
 311                         if (!BLI_exists(tempname)) {
 312                                 if (BLI_copy(name, tempname) == RET_OK) {
 313                                         remove_tmp = true;
 314                                 }
 315                                 break;
 316                         }
 317                 }
 318         }
 319
 320         /* make sure the path to the file exists... */
 321         BLI_make_existing_file(name);
 322
 323         file = BLI_open(name, O_BINARY + O_WRONLY + O_CREAT + O_TRUNC, 0666);
 324         if (file == -1) {
 325                 BKE_reportf(reports, RPT_ERROR, "Error creating file '%s'", name);
 326                 ret_value = RET_ERROR;
 327         }
 328         else {
 329                 if (write(file, pf->data, pf->size) != pf->size) {
 330                         BKE_reportf(reports, RPT_ERROR, "Error writing file '%s'", name);
 331                         ret_value = RET_ERROR;
 332                 }
 333                 else {
 334                         BKE_reportf(reports, RPT_INFO, "Saved packed file to: %s", name);
 335                 }
 336
 337                 close(file);
 338         }
 339
 340         if (remove_tmp) {
 341                 if (ret_value == RET_ERROR) {
 342                         if (BLI_rename(tempname, name) != 0) {
 343                                 BKE_reportf(reports, RPT_ERROR, "Error restoring temp file (check files '%s' '%s')", tempname, name);
 344                         }
 345                 }
 346                 else {
 347                         if (BLI_delete(tempname, false, false) != 0) {
 348                                 BKE_reportf(reports, RPT_ERROR, "Error deleting '%s' (ignored)", tempname);
 349                         }
 350                 }
 351         }
 352
 353         if (guimode) {} //XXX waitcursor(0);
 354
 355         return (ret_value);
 356 }
 357
 358 /*
 359  * This function compares a packed file to a 'real' file.
 360  * It returns an integer indicating if:
 361  *
 362  * PF_EQUAL             - the packed file and original file are identical
 363  * PF_DIFFERENT - the packed file and original file differ
 364  * PF_NOFILE    - the original file doens't exist
 365  */
 366
 367 int checkPackedFile(const char *filename, PackedFile *pf)
 368 {
 369         BLI_stat_t st;
 370         int ret_val, i, len, file;
 371         char buf[4096];
 372         char name[FILE_MAX];
 373
 374         BLI_strncpy(name, filename, sizeof(name));
 375         BLI_path_abs(name, G.main->name);
 376
 377         if (BLI_stat(name, &st) == -1) {
 378                 ret_val = PF_NOFILE;
 379         }
 380         else if (st.st_size != pf->size) {
 381                 ret_val = PF_DIFFERS;
 382         }
 383         else {
 384                 /* we'll have to compare the two... */
 385
 386                 file = BLI_open(name, O_BINARY | O_RDONLY, 0);
 387                 if (file == -1) {
 388                         ret_val = PF_NOFILE;
 389                 }
 390                 else {
 391                         ret_val = PF_EQUAL;
 392
 393                         for (i = 0; i < pf->size; i += sizeof(buf)) {
 394                                 len = pf->size - i;
 395                                 if (len > sizeof(buf)) {
 396                                         len = sizeof(buf);
 397                                 }
 398
 399                                 if (read(file, buf, len) != len) {
 400                                         /* read error ... */
 401                                         ret_val = PF_DIFFERS;
 402                                         break;
 403                                 }
 404                                 else {
 405                                         if (memcmp(buf, ((char *)pf->data) + i, len)) {
 406                                                 ret_val = PF_DIFFERS;
 407                                                 break;
 408                                         }
 409                                 }
 410                         }
 411
 412                         close(file);
 413                 }
 414         }
 415
 416         return(ret_val);
 417 }
 418
 419 /**
 420  * unpackFile() looks at the existing files (abs_name, local_name) and a packed file.
 421  *
 422  * It returns a char *to the existing file name / new file name or NULL when
 423  * there was an error or when the user decides to cancel the operation.
 424  *
 425  * \warning 'abs_name' may be relative still! (use a "//" prefix) be sure to run #BLI_path_abs on it first.
 426  */
 427 char *unpackFile(ReportList *reports, const char *abs_name, const char *local_name, PackedFile *pf, int how)
 428 {
 429         char *newname = NULL;
 430         const char *temp = NULL;
 431
 432         if (pf != NULL) {
 433                 switch (how) {
 434                         case -1:
 435                         case PF_KEEP:
 436                                 break;
 437                         case PF_REMOVE:
 438                                 temp = abs_name;
 439                                 break;
 440                         case PF_USE_LOCAL:
 441                         {
 442                                 char temp_abs[FILE_MAX];
 443
 444                                 BLI_strncpy(temp_abs, local_name, sizeof(temp_abs));
 445                                 BLI_path_abs(temp_abs, G.main->name);
 446
 447                                 /* if file exists use it */
 448                                 if (BLI_exists(temp_abs)) {
 449                                         temp = local_name;
 450                                         break;
 451                                 }
 452                                 /* else create it */
 453                                 ATTR_FALLTHROUGH;
 454                         }
 455                         case PF_WRITE_LOCAL:
 456                                 if (writePackedFile(reports, local_name, pf, 1) == RET_OK) {
 457                                         temp = local_name;
 458                                 }
 459                                 break;
 460                         case PF_USE_ORIGINAL:
 461                         {
 462                                 char temp_abs[FILE_MAX];
 463
 464                                 BLI_strncpy(temp_abs, abs_name, sizeof(temp_abs));
 465                                 BLI_path_abs(temp_abs, G.main->name);
 466
 467                                 /* if file exists use it */
 468                                 if (BLI_exists(temp_abs)) {
 469                                         BKE_reportf(reports, RPT_INFO, "Use existing file (instead of packed): %s", abs_name);
 470                                         temp = abs_name;
 471                                         break;
 472                                 }
 473                                 /* else create it */
 474                                 ATTR_FALLTHROUGH;
 475                         }
 476                         case PF_WRITE_ORIGINAL:
 477                                 if (writePackedFile(reports, abs_name, pf, 1) == RET_OK) {
 478                                         temp = abs_name;
 479                                 }
 480                                 break;
 481                         default:
 482                                 printf("unpackFile: unknown return_value %d\n", how);
 483                                 break;
 484                 }
 485
 486                 if (temp) {
 487                         newname = BLI_strdup(temp);
 488                 }
 489         }
 490
 491         return newname;
 492 }
 493
 494 static void unpack_generate_paths(
 495         const char *name, ID *id, char *r_abspath, char *r_relpath, size_t abspathlen, size_t relpathlen)
 496 {
 497         char tempname[FILE_MAX];
 498         char tempdir[FILE_MAXDIR];
 499
 500         BLI_split_dirfile(name, tempdir, tempname, sizeof(tempdir), sizeof(tempname));
 501
 502         if (tempname[0] == '\0') {
 503                 /* Note: we do not have any real way to re-create extension out of data... */
 504                 BLI_strncpy(tempname, id->name + 2, sizeof(tempname));
 505                 printf("%s\n", tempname);
 506                 BLI_filename_make_safe(tempname);
 507                 printf("%s\n", tempname);
 508         }
 509
 510         if (tempdir[0] == '\0') {
 511                 /* Fallback to relative dir. */
 512                 BLI_strncpy(tempdir, "//", sizeof(tempdir));
 513         }
 514
 515         switch (GS(id->name)) {
 516                 case ID_VF:
 517                         BLI_snprintf(r_relpath, relpathlen, "//fonts/%s", tempname);
 518                         break;
 519                 case ID_SO:
 520                         BLI_snprintf(r_relpath, relpathlen, "//sounds/%s", tempname);
 521                         break;
 522                 case ID_IM:
 523                         BLI_snprintf(r_relpath, relpathlen, "//textures/%s", tempname);
 524                         break;
 525                 default:
 526                         break;
 527         }
 528
 529         {
 530                 size_t len = BLI_strncpy_rlen(r_abspath, tempdir, abspathlen);
 531                 BLI_strncpy(r_abspath + len, tempname, abspathlen - len);
 532         }
 533 }
 534
 535 int unpackVFont(ReportList *reports, VFont *vfont, int how)
 536 {
 537         char localname[FILE_MAX], absname[FILE_MAX];
 538         char *newname;
 539         int ret_value = RET_ERROR;
 540
 541         if (vfont != NULL) {
 542                 unpack_generate_paths(vfont->name, (ID *)vfont, absname, localname, sizeof(absname), sizeof(localname));
 543                 newname = unpackFile(reports, absname, localname, vfont->packedfile, how);
 544                 if (newname != NULL) {
 545                         ret_value = RET_OK;
 546                         freePackedFile(vfont->packedfile);
 547                         vfont->packedfile = NULL;
 548                         BLI_strncpy(vfont->name, newname, sizeof(vfont->name));
 549                         MEM_freeN(newname);
 550                 }
 551         }
 552
 553         return (ret_value);
 554 }
 555
 556 int unpackSound(Main *bmain, ReportList *reports, bSound *sound, int how)
 557 {
 558         char localname[FILE_MAX], absname[FILE_MAX];
 559         char *newname;
 560         int ret_value = RET_ERROR;
 561
 562         if (sound != NULL) {
 563                 unpack_generate_paths(sound->name, (ID *)sound, absname, localname, sizeof(absname), sizeof(localname));
 564                 newname = unpackFile(reports, absname, localname, sound->packedfile, how);
 565                 if (newname != NULL) {
 566                         BLI_strncpy(sound->name, newname, sizeof(sound->name));
 567                         MEM_freeN(newname);
 568
 569                         freePackedFile(sound->packedfile);
 570                         sound->packedfile = NULL;
 571
 572                         BKE_sound_load(bmain, sound);
 573
 574                         ret_value = RET_OK;
 575                 }
 576         }
 577
 578         return(ret_value);
 579 }
 580
 581 int unpackImage(ReportList *reports, Image *ima, int how)
 582 {
 583         int ret_value = RET_ERROR;
 584
 585         if (ima != NULL) {
 586                 while (ima->packedfiles.last) {
 587                         char localname[FILE_MAX], absname[FILE_MAX];
 588                         char *newname;
 589                         ImagePackedFile *imapf = ima->packedfiles.last;
 590
 591                         unpack_generate_paths(imapf->filepath, (ID *)ima, absname, localname, sizeof(absname), sizeof(localname));
 592                         newname = unpackFile(reports, absname, localname, imapf->packedfile, how);
 593
 594                         if (newname != NULL) {
 595                                 ImageView *iv;
 596
 597                                 ret_value = ret_value == RET_ERROR ? RET_ERROR : RET_OK;
 598                                 freePackedFile(imapf->packedfile);
 599                                 imapf->packedfile = NULL;
 600
 601                                 /* update the new corresponding view filepath */
 602                                 iv = BLI_findstring(&ima->views, imapf->filepath, offsetof(ImageView, filepath));
 603                                 if (iv) {
 604                                         BLI_strncpy(iv->filepath, newname, sizeof(imapf->filepath));
 605                                 }
 606
 607                                 /* keep the new name in the image for non-pack specific reasons */
 608                                 if (how != PF_REMOVE) {
 609                                         BLI_strncpy(ima->name, newname, sizeof(imapf->filepath));
 610                                 }
 611                                 MEM_freeN(newname);
 612                         }
 613                         else {
 614                                 ret_value = RET_ERROR;
 615                         }
 616
 617                         BLI_remlink(&ima->packedfiles, imapf);
 618                         MEM_freeN(imapf);
 619                 }
 620         }
 621
 622         if (ret_value == RET_OK) {
 623                 BKE_image_signal(ima, NULL, IMA_SIGNAL_RELOAD);
 624         }
 625
 626         return(ret_value);
 627 }
 628
 629 int unpackLibraries(Main *bmain, ReportList *reports)
 630 {
 631         Library *lib;
 632         char *newname;
 633         int ret_value = RET_ERROR;
 634
 635         for (lib = bmain->library.first; lib; lib = lib->id.next) {
 636                 if (lib->packedfile && lib->name[0]) {
 637
 638                         newname = unpackFile(reports, lib->filepath, lib->filepath, lib->packedfile, PF_WRITE_ORIGINAL);
 639                         if (newname != NULL) {
 640                                 ret_value = RET_OK;
 641
 642                                 printf("Unpacked .blend library: %s\n", newname);
 643
 644                                 freePackedFile(lib->packedfile);
 645                                 lib->packedfile = NULL;
 646
 647                                 MEM_freeN(newname);
 648                         }
 649                 }
 650         }
 651
 652         return(ret_value);
 653 }
 654
 655 void packLibraries(Main *bmain, ReportList *reports)
 656 {
 657         Library *lib;
 658
 659         /* test for relativenss */
 660         for (lib = bmain->library.first; lib; lib = lib->id.next)
 661                 if (!BLI_path_is_rel(lib->name))
 662                         break;
 663
 664         if (lib) {
 665                 BKE_reportf(reports, RPT_ERROR, "Cannot pack absolute file: '%s'", lib->name);
 666                 return;
 667         }
 668
 669         for (lib = bmain->library.first; lib; lib = lib->id.next)
 670                 if (lib->packedfile == NULL)
 671                         lib->packedfile = newPackedFile(reports, lib->name, bmain->name);
 672 }
 673
 674 void unpackAll(Main *bmain, ReportList *reports, int how)
 675 {
 676         Image *ima;
 677         VFont *vf;
 678         bSound *sound;
 679
 680         for (ima = bmain->image.first; ima; ima = ima->id.next)
 681                 if (BKE_image_has_packedfile(ima))
 682                         unpackImage(reports, ima, how);
 683
 684         for (vf = bmain->vfont.first; vf; vf = vf->id.next)
 685                 if (vf->packedfile)
 686                         unpackVFont(reports, vf, how);
 687
 688         for (sound = bmain->sound.first; sound; sound = sound->id.next)
 689                 if (sound->packedfile)
 690                         unpackSound(bmain, reports, sound, how);
 691 }
 692
 693 /* ID should be not NULL, return 1 if there's a packed file */
 694 bool BKE_pack_check(ID *id)
 695 {
 696         switch (GS(id->name)) {
 697                 case ID_IM:
 698                 {
 699                         Image *ima = (Image *)id;
 700                         return BKE_image_has_packedfile(ima);
 701                 }
 702                 case ID_VF:
 703                 {
 704                         VFont *vf = (VFont *)id;
 705                         return vf->packedfile != NULL;
 706                 }
 707                 case ID_SO:
 708                 {
 709                         bSound *snd = (bSound *)id;
 710                         return snd->packedfile != NULL;
 711                 }
 712                 case ID_LI:
 713                 {
 714                         Library *li = (Library *)id;
 715                         return li->packedfile != NULL;
 716                 }
 717                 default:
 718                         break;
 719         }
 720         return false;
 721 }
 722
 723 /* ID should be not NULL */
 724 void BKE_unpack_id(Main *bmain, ID *id, ReportList *reports, int how)
 725 {
 726         switch (GS(id->name)) {
 727                 case ID_IM:
 728                 {
 729                         Image *ima = (Image *)id;
 730                         if (BKE_image_has_packedfile(ima)) {
 731                                 unpackImage(reports, ima, how);
 732                         }
 733                         break;
 734                 }
 735                 case ID_VF:
 736                 {
 737                         VFont *vf = (VFont *)id;
 738                         if (vf->packedfile) {
 739                                 unpackVFont(reports, vf, how);
 740                         }
 741                         break;
 742                 }
 743                 case ID_SO:
 744                 {
 745                         bSound *snd = (bSound *)id;
 746                         if (snd->packedfile) {
 747                                 unpackSound(bmain, reports, snd, how);
 748                         }
 749                         break;
 750                 }
 751                 case ID_LI:
 752                 {
 753                         Library *li = (Library *)id;
 754                         BKE_reportf(reports, RPT_ERROR, "Cannot unpack individual Library file, '%s'", li->name);
 755                         break;
 756                 }
 757                 default:
 758                         break;
 759         }
 760 }