libs/loaders/GP_Loader.c

   1 /*****************************************************************************
   2  * This file is part of gfxprim library.                                     *
   3  *                                                                           *
   4  * Gfxprim is free software; you can redistribute it and/or                  *
   5  * modify it under the terms of the GNU Lesser General Public                *
   6  * License as published by the Free Software Foundation; either              *
   7  * version 2.1 of the License, or (at your option) any later version.        *
   8  *                                                                           *
   9  * Gfxprim 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 GNU         *
  12  * Lesser General Public License for more details.                           *
  13  *                                                                           *
  14  * You should have received a copy of the GNU Lesser General Public          *
  15  * License along with gfxprim; if not, write to the Free Software            *
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                        *
  17  * Boston, MA  02110-1301  USA                                               *
  18  *                                                                           *
  19  * Copyright (C) 2009-2014 Cyril Hrubis <metan@ucw.cz>                       *
  20  *                                                                           *
  21  *****************************************************************************/
  22
  23 /*
  24
  25   General functions for loading and saving bitmaps.
  26
  27  */
  28
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34 #include <unistd.h>
  35 #include <ctype.h>
  36
  37 #include "core/GP_Debug.h"
  38
  39 #include "loaders/GP_Loaders.h"
  40 #include "loaders/GP_Loader.h"
  41
  42 #define MAX_LOADERS 64
  43
  44 static const GP_Loader *loaders[MAX_LOADERS] = {
  45         &GP_JPG,
  46         &GP_PNG,
  47         &GP_TIFF,
  48         &GP_GIF,
  49         &GP_BMP,
  50         &GP_PBM,
  51         &GP_PGM,
  52         &GP_PPM,
  53         &GP_PNM,
  54         &GP_JP2,
  55         &GP_PCX,
  56         &GP_PSP,
  57         &GP_PSD,
  58 };
  59
  60 static unsigned int get_last_loader(void)
  61 {
  62         unsigned int i;
  63
  64         for (i = 0; i < MAX_LOADERS; i++) {
  65                 if (!loaders[i])
  66                         return i ? i - 1 : 0;
  67         }
  68
  69         return i - 1;
  70 }
  71
  72 int GP_LoaderRegister(const GP_Loader *self)
  73 {
  74         unsigned int i;
  75
  76         GP_DEBUG(1, "Registering loader for '%s'", self->fmt_name);
  77
  78         /* We have to keep the last terminating NULL */
  79         for (i = 0; i < MAX_LOADERS - 2; i++) {
  80                 if (loaders[i] == self) {
  81                         GP_DEBUG(1, "Loader '%s' allready registered",
  82                                  self->fmt_name);
  83                         errno = EEXIST;
  84                         return 1;
  85                 }
  86
  87                 if (!loaders[i])
  88                         break;
  89         }
  90
  91         if (loaders[i]) {
  92                 GP_DEBUG(1, "Loaders table is full");
  93                 errno = ENOSPC;
  94                 return 1;
  95         }
  96
  97         loaders[i] = self;
  98
  99         return 0;
 100 }
 101
 102 void GP_LoaderUnregister(const GP_Loader *self)
 103 {
 104         unsigned int i, last = get_last_loader();
 105
 106         if (self == NULL)
 107                 return;
 108
 109         GP_DEBUG(1, "Unregistering loader for '%s'", self->fmt_name);
 110
 111         for (i = 0; loaders[i]; i++) {
 112                 if (loaders[i] == self) {
 113                         loaders[i] = loaders[last];
 114                         loaders[last] = NULL;
 115                         return;
 116                 }
 117         }
 118
 119         GP_WARN("Loader '%s' (%p) wasn't registered", self->fmt_name, self);
 120 }
 121
 122 void GP_ListLoaders(void)
 123 {
 124         unsigned int i, j;
 125
 126         for (i = 0; loaders[i]; i++) {
 127                 printf("Format: %s\n", loaders[i]->fmt_name);
 128                 printf("Read:\t%s\n", loaders[i]->Read ? "Yes" : "No");
 129                 printf("Write:\t%s\n", loaders[i]->Write ? "Yes" : "No");
 130                 if (loaders[i]->save_ptypes) {
 131                         printf("Write Pixel Types: ");
 132                         for (j = 0; loaders[i]->save_ptypes[j]; j++) {
 133                                 GP_PixelType ptype = loaders[i]->save_ptypes[j];
 134                                 printf("%s ", GP_PixelTypeName(ptype));
 135                         }
 136                         printf("\n");
 137                 }
 138                 printf("Match:\t%s\n", loaders[i]->Match ? "Yes" : "No");
 139                 printf("Extensions: ");
 140                 for (j = 0; loaders[i]->extensions[j]; j++)
 141                         printf("%s ", loaders[i]->extensions[j]);
 142                 printf("\n");
 143
 144                 if (loaders[i+1] != NULL)
 145                         printf("\n");
 146         }
 147 }
 148
 149 static const GP_Loader *loader_by_extension(const char *ext)
 150 {
 151         unsigned int i, j;
 152
 153         for (i = 0; loaders[i]; i++) {
 154                 for (j = 0; loaders[i]->extensions[j] != NULL; j++) {
 155                         if (!strcasecmp(ext, loaders[i]->extensions[j])) {
 156                                 GP_DEBUG(1, "Found loader '%s'",
 157                                          loaders[i]->fmt_name);
 158                                 return loaders[i];
 159                         }
 160                 }
 161         }
 162
 163         return NULL;
 164 }
 165
 166 static const char *get_ext(const char *path)
 167 {
 168         size_t len = strlen(path);
 169         int i;
 170
 171         for (i = len - 1; i >= 0; i--)
 172                 if (path[i] == '.')
 173                         break;
 174
 175         if (path[i] != '.')
 176                 return NULL;
 177
 178         return path + i + 1;
 179 }
 180
 181 const GP_Loader *GP_LoaderByFilename(const char *path)
 182 {
 183         const char *ext = get_ext(path);
 184
 185         if (ext == NULL)
 186                 return NULL;
 187
 188         GP_DEBUG(1, "Loading file by filename extension '%s'", ext);
 189
 190         return loader_by_extension(ext);
 191 }
 192
 193 static const GP_Loader *loader_by_signature(const char *path)
 194 {
 195         uint8_t buf[32];
 196         FILE *f;
 197         int err;
 198
 199         const GP_Loader *ret;
 200
 201         GP_DEBUG(1, "Trying to load by file signature");
 202
 203         f = fopen(path, "rb");
 204
 205         if (f == NULL) {
 206                 err = errno;
 207                 GP_DEBUG(1, "Failed to open file '%s'", path);
 208                 goto err0;
 209         }
 210
 211         if (fread(buf, sizeof(buf), 1, f) < 1) {
 212                 GP_DEBUG(1, "Failed to read start of the file '%s'", path);
 213                 err = EIO;
 214                 goto err1;
 215         }
 216
 217         fclose(f);
 218
 219         ret = GP_LoaderBySignature(buf);
 220
 221         if (ret == NULL)
 222                 errno = ENOSYS;
 223
 224         return ret;
 225 err1:
 226         fclose(f);
 227 err0:
 228         errno = err;
 229         return NULL;
 230 }
 231
 232 GP_Pixmap *GP_ReadImage(GP_IO *io, GP_ProgressCallback *callback)
 233 {
 234         GP_Pixmap *ret = NULL;
 235
 236         GP_ReadImageEx(io, &ret, NULL, callback);
 237
 238         return ret;
 239 }
 240
 241 int GP_ReadImageEx(GP_IO *io, GP_Pixmap **img, GP_DataStorage *meta_data,
 242                    GP_ProgressCallback *callback)
 243 {
 244         char buf[32];
 245         off_t start;
 246         const GP_Loader *loader;
 247
 248         start = GP_IOTell(io);
 249         if (start == (off_t)-1) {
 250                 GP_DEBUG(1, "Failed to get IO stream offset: %s",
 251                          strerror(errno));
 252                 return 1;
 253         }
 254
 255         if (GP_IOFill(io, buf, sizeof(buf))) {
 256                 GP_DEBUG(1, "Failed to read first 32 bytes: %s",
 257                          strerror(errno));
 258                 return 1;
 259         }
 260
 261         if (GP_IOSeek(io, start, GP_IO_SEEK_SET) != start) {
 262                 GP_DEBUG(1, "Failed to seek at the start of the stream: %s",
 263                          strerror(errno));
 264                 return 1;
 265         }
 266
 267         loader = GP_LoaderBySignature(buf);
 268
 269         if (!loader) {
 270                 GP_DEBUG(1, "Failed to find a loader by signature for"
 271                             "(%x (%c) %x (%c)...)",
 272                             buf[0], isprint(buf[0]) ? buf[0] : ' ',
 273                             buf[1], isprint(buf[1]) ? buf[1] : ' ');
 274                 errno = ENOSYS;
 275                 return 1;
 276         }
 277
 278         if (!loader->Read) {
 279                 GP_DEBUG(1, "Loader for '%s' does not support reading",
 280                          loader->fmt_name);
 281                 errno = ENOSYS;
 282                 return 1;
 283         }
 284
 285         return loader->Read(io, img, meta_data, callback);
 286 }
 287
 288 int GP_LoaderLoadImageEx(const GP_Loader *self, const char *src_path,
 289                          GP_Pixmap **img, GP_DataStorage *storage,
 290                          GP_ProgressCallback *callback)
 291 {
 292         GP_IO *io;
 293         int err, ret;
 294
 295         GP_DEBUG(1, "Loading Image '%s'", src_path);
 296
 297         if (!self->Read) {
 298                 errno = ENOSYS;
 299                 return ENOSYS;
 300         }
 301
 302         io = GP_IOFile(src_path, GP_IO_RDONLY);
 303         if (!io)
 304                 return 1;
 305
 306         ret = self->Read(io, img, storage, callback);
 307
 308         err = errno;
 309         GP_IOClose(io);
 310         errno = err;
 311
 312         return ret;
 313 }
 314
 315
 316 GP_Pixmap *GP_LoaderLoadImage(const GP_Loader *self, const char *src_path,
 317                                GP_ProgressCallback *callback)
 318 {
 319         GP_Pixmap *ret = NULL;
 320
 321         GP_LoaderLoadImageEx(self, src_path, &ret, NULL, callback);
 322
 323         return ret;
 324 }
 325
 326 GP_Pixmap *GP_LoaderReadImage(const GP_Loader *self, GP_IO *io,
 327                                GP_ProgressCallback *callback)
 328 {
 329         GP_Pixmap *ret = NULL;
 330
 331         GP_LoaderReadImageEx(self, io, &ret, NULL, callback);
 332
 333         return ret;
 334 }
 335
 336 int GP_LoaderReadImageEx(const GP_Loader *self, GP_IO *io,
 337                          GP_Pixmap **img, GP_DataStorage *data,
 338                          GP_ProgressCallback *callback)
 339 {
 340         GP_DEBUG(1, "Reading image (I/O %p)", io);
 341
 342         if (!self->Read) {
 343                 errno = ENOSYS;
 344                 return ENOSYS;
 345         }
 346
 347         return self->Read(io, img, data, callback);
 348 }
 349
 350 GP_Pixmap *GP_LoadImage(const char *src_path, GP_ProgressCallback *callback)
 351 {
 352         GP_Pixmap *ret = NULL;
 353
 354         GP_LoadImageEx(src_path, &ret, NULL, callback);
 355
 356         return ret;
 357 }
 358
 359 int GP_LoadImageEx(const char *src_path,
 360                    GP_Pixmap **img, GP_DataStorage *meta_data,
 361                    GP_ProgressCallback *callback)
 362 {
 363         int err;
 364         struct stat st;
 365
 366         if (access(src_path, R_OK)) {
 367                 err = errno;
 368                 GP_DEBUG(1, "Failed to access file '%s' : %s",
 369                             src_path, strerror(errno));
 370                 errno = err;
 371                 return 1;
 372         }
 373
 374         if (stat(src_path, &st)) {
 375                 GP_WARN("Failed to stat '%s': %s", src_path, strerror(errno));
 376         } else {
 377                 if (st.st_mode & S_IFDIR) {
 378                         errno = EISDIR;
 379                         return 1;
 380                 }
 381         }
 382
 383         const GP_Loader *ext_load, *sig_load;
 384
 385         ext_load = GP_LoaderByFilename(src_path);
 386
 387         if (ext_load) {
 388                 if (!GP_LoaderLoadImageEx(ext_load, src_path,
 389                                           img, meta_data, callback))
 390                         return 0;
 391         }
 392
 393         /*
 394          * Operation was aborted, just here exit.
 395          */
 396         if (errno == ECANCELED)
 397                 return 1;
 398
 399         sig_load = loader_by_signature(src_path);
 400
 401         /*
 402          * Avoid further work if extension matches the signature but image
 403          * couldn't be loaded. Probably unimplemented format or damaged file.
 404          */
 405         if (ext_load == sig_load) {
 406                 GP_WARN("Signature matches extension but file '%s' "
 407                         "can't be loaded. Unsupported/damaged file?",
 408                         src_path);
 409                 return 1;
 410         }
 411
 412         if (ext_load && sig_load) {
 413                 GP_WARN("File '%s': Extension says %s but signature %s",
 414                         src_path, ext_load->fmt_name, sig_load->fmt_name);
 415         }
 416
 417         if (sig_load) {
 418                 if (!GP_LoaderLoadImageEx(sig_load, src_path,
 419                                           img, meta_data, callback))
 420                         return 0;
 421         }
 422
 423         errno = ENOSYS;
 424         return 1;
 425 }
 426
 427 int GP_LoadMetaData(const char *src_path, GP_DataStorage *storage)
 428 {
 429         const GP_Loader *loader;
 430         struct stat st;
 431         int err;
 432
 433         // TODO unify this with GP_LoadImage()
 434         if (access(src_path, R_OK)) {
 435                 err = errno;
 436                 GP_DEBUG(1, "Failed to access file '%s' : %s",
 437                             src_path, strerror(errno));
 438                 errno = err;
 439                 return 1;
 440         }
 441
 442         if (stat(src_path, &st)) {
 443                 GP_WARN("Failed to stat '%s': %s", src_path, strerror(errno));
 444         } else {
 445                 if (st.st_mode & S_IFDIR) {
 446                         errno = EISDIR;
 447                         return 1;
 448                 }
 449         }
 450
 451         loader = GP_LoaderByFilename(src_path);
 452
 453         if (loader == NULL)
 454                 goto out;
 455
 456         return GP_LoaderLoadImageEx(loader, src_path, NULL, storage, NULL);
 457
 458 out:
 459         errno = ENOSYS;
 460         return 1;
 461 }
 462
 463 int GP_LoaderSaveImage(const GP_Loader *self, const GP_Pixmap *src,
 464                        const char *dst_path, GP_ProgressCallback *callback)
 465 {
 466         GP_IO *io;
 467
 468         GP_DEBUG(1, "Saving image '%s' format %s", dst_path, self->fmt_name);
 469
 470         if (!self->Write) {
 471                 errno = ENOSYS;
 472                 return 1;
 473         }
 474
 475         io = GP_IOFile(dst_path, GP_IO_WRONLY);
 476
 477         if (!io)
 478                 return 1;
 479
 480         if (self->Write(src, io, callback)) {
 481                 GP_IOClose(io);
 482                 unlink(dst_path);
 483                 return 1;
 484         }
 485
 486         if (GP_IOClose(io)) {
 487                 unlink(dst_path);
 488                 return 1;
 489         }
 490
 491         return 0;
 492 }
 493
 494 int GP_SaveImage(const GP_Pixmap *src, const char *dst_path,
 495                  GP_ProgressCallback *callback)
 496 {
 497         const GP_Loader *l = GP_LoaderByFilename(dst_path);
 498
 499         if (l == NULL) {
 500                 errno = EINVAL;
 501                 return 1;
 502         }
 503
 504         return GP_LoaderSaveImage(l, src, dst_path, callback);
 505 }
 506
 507 const GP_Loader *GP_LoaderBySignature(const void *buf)
 508 {
 509         unsigned int i;
 510
 511         for (i = 0; loaders[i]; i++) {
 512                 if (loaders[i]->Match && loaders[i]->Match(buf) == 1) {
 513                         GP_DEBUG(1, "Found loader '%s'", loaders[i]->fmt_name);
 514                         return loaders[i];
 515                 }
 516         }
 517
 518         GP_DEBUG(1, "Loader not found");
 519
 520         return NULL;
 521 }