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_Context *GP_ReadImage(GP_IO *io, GP_ProgressCallback *callback)
 233 {
 234         char buf[32];
 235         off_t start;
 236         const GP_Loader *loader;
 237
 238         start = GP_IOTell(io);
 239         if (start == (off_t)-1) {
 240                 GP_DEBUG(1, "Failed to get IO stream offset: %s",
 241                          strerror(errno));
 242                 return NULL;
 243         }
 244
 245         if (GP_IOFill(io, buf, sizeof(buf))) {
 246                 GP_DEBUG(1, "Failed to read first 32 bytes: %s",
 247                          strerror(errno));
 248                 return NULL;
 249         }
 250
 251         if (GP_IOSeek(io, start, GP_IO_SEEK_SET) != start) {
 252                 GP_DEBUG(1, "Failed to seek at the start of the stream: %s",
 253                          strerror(errno));
 254                 return NULL;
 255         }
 256
 257         loader = GP_LoaderBySignature(buf);
 258
 259         if (!loader) {
 260                 GP_DEBUG(1, "Failed to find a loader by signature for"
 261                             "(%x (%c) %x (%c)...)",
 262                             buf[0], isprint(buf[0]) ? buf[0] : ' ',
 263                             buf[1], isprint(buf[1]) ? buf[1] : ' ');
 264                 errno = ENOSYS;
 265                 return NULL;
 266         }
 267
 268         if (!loader->Read) {
 269                 GP_DEBUG(1, "Loader for '%s' does not support reading",
 270                          loader->fmt_name);
 271                 errno = ENOSYS;
 272                 return NULL;
 273         }
 274
 275         return loader->Read(io, callback);
 276 }
 277
 278 GP_Context *GP_LoaderLoadImage(const GP_Loader *self, const char *src_path,
 279                                GP_ProgressCallback *callback)
 280 {
 281         GP_IO *io;
 282         GP_Context *res;
 283         int err;
 284
 285         GP_DEBUG(1, "Loading Image '%s'", src_path);
 286
 287         if (!self->Read) {
 288                 errno = ENOSYS;
 289                 return NULL;
 290         }
 291
 292         io = GP_IOFile(src_path, GP_IO_RDONLY);
 293         if (!io)
 294                 return NULL;
 295
 296         res = self->Read(io, callback);
 297
 298         err = errno;
 299         GP_IOClose(io);
 300         errno = err;
 301
 302         return res;
 303 }
 304
 305 GP_Context *GP_LoadImage(const char *src_path, GP_ProgressCallback *callback)
 306 {
 307         int err;
 308         struct stat st;
 309
 310         if (access(src_path, R_OK)) {
 311                 err = errno;
 312                 GP_DEBUG(1, "Failed to access file '%s' : %s",
 313                             src_path, strerror(errno));
 314                 errno = err;
 315                 return NULL;
 316         }
 317
 318         if (stat(src_path, &st)) {
 319                 GP_WARN("Failed to stat '%s': %s", src_path, strerror(errno));
 320         } else {
 321                 if (st.st_mode & S_IFDIR) {
 322                         errno = EISDIR;
 323                         return NULL;
 324                 }
 325         }
 326
 327         GP_Context *img;
 328         const GP_Loader *ext_load = NULL, *sig_load;
 329
 330         ext_load = GP_LoaderByFilename(src_path);
 331
 332         if (ext_load) {
 333                 img = GP_LoaderLoadImage(ext_load, src_path, callback);
 334
 335                 if (img)
 336                         return img;
 337         }
 338
 339         sig_load = loader_by_signature(src_path);
 340
 341         /*
 342          * Avoid further work if extension matches the signature but image
 343          * couldn't be loaded. Probably unimplemented format or damaged file.
 344          */
 345         if (ext_load == sig_load)
 346                 return NULL;
 347
 348         if (ext_load && sig_load) {
 349                 GP_WARN("File '%s': Extension says %s but signature %s",
 350                         src_path, ext_load->fmt_name, sig_load->fmt_name);
 351         }
 352
 353         if (sig_load)
 354                 return GP_LoaderLoadImage(sig_load, src_path, callback);
 355
 356         errno = ENOSYS;
 357         return NULL;
 358 }
 359
 360 int GP_LoadMetaData(const char *src_path, GP_MetaData *data)
 361 {
 362         const char *ext;
 363         int err;
 364
 365         if (access(src_path, R_OK)) {
 366                 err = errno;
 367                 GP_DEBUG(1, "Failed to access file '%s' : %s",
 368                             src_path, strerror(errno));
 369                 errno = err;
 370                 return 1;
 371         }
 372
 373         ext = get_ext(src_path);
 374
 375         if (ext == NULL)
 376                 goto out;
 377
 378         if (!strcasecmp(ext, "jpg") || !strcasecmp(ext, "jpeg"))
 379                 return GP_LoadJPGMetaData(src_path, data);
 380
 381         if (!strcasecmp(ext, "png"))
 382                 return GP_LoadPNGMetaData(src_path, data);
 383
 384 out:
 385         errno = ENOSYS;
 386         return 1;
 387 }
 388
 389 int GP_LoaderSaveImage(const GP_Loader *self, const GP_Context *src,
 390                        const char *dst_path, GP_ProgressCallback *callback)
 391 {
 392         GP_IO *io;
 393
 394         GP_DEBUG(1, "Saving image '%s' format %s", dst_path, self->fmt_name);
 395
 396         if (!self->Write) {
 397                 errno = ENOSYS;
 398                 return 1;
 399         }
 400
 401         io = GP_IOFile(dst_path, GP_IO_WRONLY);
 402
 403         if (!io)
 404                 return 1;
 405
 406         if (self->Write(src, io, callback)) {
 407                 GP_IOClose(io);
 408                 unlink(dst_path);
 409                 return 1;
 410         }
 411
 412         if (GP_IOClose(io)) {
 413                 unlink(dst_path);
 414                 return 1;
 415         }
 416
 417         return 0;
 418 }
 419
 420 int GP_SaveImage(const GP_Context *src, const char *dst_path,
 421                  GP_ProgressCallback *callback)
 422 {
 423         const GP_Loader *l = GP_LoaderByFilename(dst_path);
 424
 425         if (l == NULL) {
 426                 errno = EINVAL;
 427                 return 1;
 428         }
 429
 430         return GP_LoaderSaveImage(l, src, dst_path, callback);
 431 }
 432
 433 const GP_Loader *GP_LoaderBySignature(const void *buf)
 434 {
 435         unsigned int i;
 436
 437         for (i = 0; loaders[i]; i++) {
 438                 if (loaders[i]->Match && loaders[i]->Match(buf) == 1) {
 439                         GP_DEBUG(1, "Found loader '%s'", loaders[i]->fmt_name);
 440                         return loaders[i];
 441                 }
 442         }
 443
 444         GP_DEBUG(1, "Loader not found");
 445
 446         return NULL;
 447 }