addons/Image/source/JPGImage.c

   1 /*
   2  docCopyright("Steve Dekorte", 2002)
   3  docLicense("BSD revised")
   4  */
   5 #include "JPGImage.h"
   6 #include <jpeglib.h>
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10
  11 #ifndef _WIN32
  12 #include <unistd.h>
  13 #endif
  14
  15 #include <string.h>
  16
  17 JPGImage *JPGImage_new(void)
  18 {
  19         JPGImage *self = (JPGImage *)calloc(1, sizeof(JPGImage));
  20         JPGImage_path_(self, "");
  21         JPGImage_error_(self, "");
  22         self->byteArray = UArray_new();
  23         self->ownsUArray = 1;
  24         self->quality = 0.5; /* default to meduim quality */
  25         self->decodingWidthHint = 0;
  26         self->decodingHeightHint = 0;
  27         return self;
  28 }
  29
  30 JPGImage *JPGImage_newWithPath_(char *path)
  31 {
  32         JPGImage *self = JPGImage_new();
  33         JPGImage_path_(self, path);
  34         JPGImage_load(self);
  35         return self;
  36 }
  37
  38 void JPGImage_free(JPGImage *self)
  39 {
  40         if (self->ownsUArray) UArray_free(self->byteArray);
  41         if (self->error) free(self->error);
  42         free(self->path);
  43         free(self);
  44 }
  45
  46 void JPGImage_path_(JPGImage *self, const char *path)
  47 {
  48         self->path = strcpy((char *)realloc(self->path, strlen(path)+1), path);
  49 }
  50
  51 char *JPGImage_path(JPGImage *self)
  52 {
  53         return self->path;
  54 }
  55
  56 void JPGImage_quality_(JPGImage *self, float q)
  57 {
  58         if (q<0) q = 0;
  59         if (q>1) q = 1;
  60         self->quality = q;
  61 }
  62
  63 float JPGImage_quality(JPGImage *self)
  64 {
  65         return self->quality;
  66 }
  67
  68 void JPGImage_decodingWidthHint_(JPGImage *self, int w)
  69 {
  70         self->decodingWidthHint = w;
  71 }
  72
  73 int JPGImage_decodingWidthHint(JPGImage *self)
  74 {
  75         return self->decodingWidthHint;
  76 }
  77
  78 void JPGImage_decodingHeightHint_(JPGImage *self, int h)
  79 {
  80         self->decodingHeightHint = h;
  81 }
  82
  83 int JPGImage_decodingHeightHint(JPGImage *self)
  84 {
  85         return self->decodingHeightHint;
  86 }
  87
  88 void JPGImage_error_(JPGImage *self, const char *error)
  89 {
  90         self->error = strcpy((char *)realloc(self->error, strlen(error)+1), error);
  91         /*if (strlen(self->error)) printf("JPGImage error: %s\n", self->error);*/
  92 }
  93
  94 char *JPGImage_error(JPGImage *self)
  95 {
  96         return self->error;
  97 }
  98
  99 char JPGImage_isProgressive(JPGImage *self)
 100 {
 101         FILE *infile;
 102         struct jpeg_decompress_struct cinfo;
 103         struct jpeg_error_mgr jerr;
 104
 105         cinfo.err = jpeg_std_error(&jerr);
 106         jpeg_create_decompress(&cinfo);
 107
 108         if ((infile = fopen(self->path, "rb")) == NULL)
 109         {
 110                 JPGImage_error_(self, "can't open file");
 111                 return 0;
 112         }
 113
 114         jpeg_stdio_src(&cinfo, infile);
 115
 116         //jpeg_read_header(&cinfo, TRUE); // this causes an exit on a bad image
 117         jpeg_read_header(&cinfo, FALSE);
 118         return jpeg_has_multiple_scans(&cinfo);
 119 }
 120
 121 void JPGImage_readScanLines(JPGImage *self, struct jpeg_decompress_struct *cinfo);
 122
 123 /*
 124 struct MY_jpeg_error_mgr *jpeg_std_error(struct jpeg_error_mgr * err)
 125 {
 126         err->error_exit = error_exit;
 127         err->emit_message = emit_message;
 128         err->output_message = output_message;
 129         err->format_message = format_message;
 130         err->reset_error_mgr = reset_error_mgr;
 131
 132         err->trace_level = 0;           // default = no tracing
 133         err->num_warnings = 0;  // no warnings emitted yet
 134         err->msg_code = 0;              // may be useful as a flag for "no error"
 135
 136         // Initialize message table pointers
 137         err->jpeg_message_table = jpeg_std_message_table;
 138         err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;
 139
 140         err->addon_message_table = NULL;
 141         err->first_addon_message = 0;   // for safety
 142         err->last_addon_message = 0;
 143
 144         return err;
 145 }
 146 */
 147
 148 #include <setjmp.h>
 149
 150 static jmp_buf env;
 151
 152 void MY_error_exit(j_common_ptr cinfo)
 153 {
 154         (*cinfo->err->output_message) (cinfo);
 155         jpeg_destroy(cinfo);
 156         //exit(EXIT_FAILURE);
 157         printf("longjmp\n");
 158         longjmp(env, 1);
 159 }
 160
 161 void JPGImage_load(JPGImage *self)
 162 {
 163         FILE *infile;
 164
 165         /* 1. setup error structure */
 166         struct jpeg_decompress_struct cinfo;
 167         struct jpeg_error_mgr jerr;
 168
 169      if(setjmp(env) == 1)
 170         {
 171                 printf("longjmped\n");
 172                 JPGImage_error_(self, "jpeg decoding error");
 173                 return;
 174         }
 175
 176
 177         cinfo.err = jpeg_std_error(&jerr);
 178         jerr.error_exit = MY_error_exit;
 179
 180         jpeg_create_decompress(&cinfo);
 181
 182
 183         /* 2. input file */
 184         if ((infile = fopen(self->path, "r")) == NULL)
 185         {
 186                 JPGImage_error_(self, "can't open file");
 187                 return;
 188         }
 189
 190         jpeg_stdio_src(&cinfo, infile);
 191
 192         /* 3. Call jpeg_read_header() to obtain image info. */
 193         //jpeg_read_header(&cinfo, TRUE); // this causes an exit on a bad image
 194         jpeg_read_header(&cinfo, FALSE);
 195
 196         if (jpeg_has_multiple_scans(&cinfo) &&
 197             (self->decodingWidthHint || self->decodingHeightHint) ) /* progressive thumbnail */
 198             {
 199                 int wr = 0;
 200                 int hr = 0;
 201                 int s = 0;
 202                 if (self->decodingWidthHint)  wr = cinfo.image_width/self->decodingWidthHint;
 203                 if (self->decodingHeightHint) hr = cinfo.image_height/self->decodingHeightHint;
 204                 if (wr && hr) { s = wr < hr ? wr : hr; } else  /* take the small so no dimension is smaller than the min */
 205                         if (wr) { s = wr; } else if (hr) { s = hr; }
 206                 /* valid scales are 1/1 1/2 1/4 and 1/8 */
 207                 if (s <= 1) { s = 1; } else
 208                         if (s <= 2) { s = 2; } else
 209                                 if (s <= 4) { s = 4; } else { s = 8; }
 210
 211                 cinfo.scale_num = 1;
 212                 cinfo.scale_denom = s;
 213
 214                 /*printf("JPEG is Progressive\n");*/
 215                 cinfo.buffered_image = TRUE; /* select buffered-image mode so we can handle progressive jpegs */
 216                 jpeg_start_decompress(&cinfo);
 217                 while (!jpeg_input_complete(&cinfo))
 218                 {
 219                         /*printf("reading progressive pass %i\n", cinfo.input_scan_number); */
 220                         /* adjust output decompression parameters if required */
 221                         cinfo.do_block_smoothing = 0;
 222                         jpeg_start_output(&cinfo, cinfo.input_scan_number);
 223                         JPGImage_readScanLines(self, &cinfo);
 224                         /* display scanlines */
 225                         jpeg_finish_output(&cinfo);     /* terminate output pass */
 226                         if (cinfo.scale_denom != 1) break; /* hack - just break since we don't know the pass resolution */
 227                 }
 228             }
 229             else /* non-progressive */
 230             {
 231                     jpeg_start_decompress(&cinfo);
 232                     /*printf("JPEG is NOT progressive\n");*/
 233                     JPGImage_readScanLines(self, &cinfo);
 234             }
 235
 236             /* Finish decompression and release memory.
 237             * I must do it in this order because output module has allocated memory
 238             * of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
 239             */
 240             jpeg_finish_decompress(&cinfo);
 241             jpeg_destroy_decompress(&cinfo);
 242
 243             /* Close files, if we opened them */
 244             if (infile != stdin) fclose(infile);
 245 }
 246
 247 void JPGImage_readScanLines(JPGImage *self, struct jpeg_decompress_struct *cinfo)
 248 {
 249         self->width      = cinfo->output_width;
 250         self->height     = cinfo->output_height;
 251         self->components = cinfo->out_color_components;
 252         /*printf("JPGImage_readScanLines %i x %i x %i\n", self->width, self->height, self->components);*/
 253
 254         {
 255                 int numbytes = cinfo->output_height * cinfo->output_width * cinfo->out_color_components;
 256                 UArray_setSize_(self->byteArray, numbytes);
 257         }
 258
 259         /* 6. while (scan lines remain to be read) */
 260         {
 261                 unsigned char **rows = malloc(cinfo->output_height * sizeof(unsigned char *));
 262                 int r;
 263                 for (r=0; r < (int)cinfo->output_height; r++)
 264                 {
 265                         rows[r] = (uint8_t *)UArray_bytes(self->byteArray) + (r * cinfo->output_width * cinfo->out_color_components);
 266                 }
 267
 268                 while (cinfo->output_scanline < cinfo->output_height)
 269                 {
 270                         jpeg_read_scanlines(cinfo, rows + cinfo->output_scanline, cinfo->output_height);
 271                 }
 272
 273                 free(rows);
 274         }
 275 }
 276
 277 void JPGImage_save(JPGImage *self)
 278 {
 279         struct jpeg_compress_struct cinfo;
 280         struct jpeg_error_mgr jerr;
 281
 282         FILE *outfile;          /* target file */
 283         JSAMPROW row_pointer[1];        /* pointer to JSAMPLE row[s] */
 284         int row_stride;         /* physical row width in image buffer */
 285
 286         /* Step 1: allocate and initialize JPEG compression object */
 287
 288         cinfo.err = jpeg_std_error(&jerr);
 289         jpeg_create_compress(&cinfo);
 290
 291         /* Step 2: specify data destination (eg, a file) */
 292         /* Note: steps 2 and 3 can be done in either order. */
 293
 294         /* Here we use the library-supplied code to send compressed data to a
 295                 * stdio stream.  You can also write your own code to do something else.
 296                 * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
 297                 * requires it in order to write binary files.
 298                 */
 299         if ((outfile = fopen(self->path, "wb")) == NULL)
 300         {
 301                 JPGImage_error_(self, "can't open output file");
 302                 return;
 303         }
 304         jpeg_stdio_dest(&cinfo, outfile);
 305
 306         /* Step 3: set parameters for compression */
 307
 308         /* First we supply a description of the input image.
 309                 * Four fields of the cinfo struct must be filled in:
 310                 */
 311         cinfo.image_width = self->width;        /* image width and height, in pixels */
 312         cinfo.image_height = self->height;
 313         cinfo.input_components = self->components;  /* # of color components per pixel */
 314         cinfo.in_color_space = JCS_RGB;         /* colorspace of input image */
 315         /* Now use the library's routine to set default compression parameters.
 316                 * (You must set at least cinfo.in_color_space before calling this,
 317                    * since the defaults depend on the source color space.)
 318                 */
 319
 320
 321         jpeg_set_defaults(&cinfo);
 322         /* Now you can set any non-default parameters you wish to.
 323                 * Here we just illustrate the use of quality (quantization table) scaling:
 324                 */
 325
 326         jpeg_simple_progression(&cinfo); /* is this the right spot for this? */
 327
 328
 329         jpeg_set_quality(&cinfo, JPGImage_quality(self)*100, TRUE); /* limit to baseline-JPEG values */
 330
 331         /* Step 4: Start compressor */
 332
 333         /* TRUE ensures that we will write a complete interchange-JPEG file.
 334                 * Pass TRUE unless you are very sure of what you're doing.
 335                 */
 336         jpeg_start_compress(&cinfo, TRUE);
 337
 338         /* Step 5: while (scan lines remain to be written) */
 339         /*           jpeg_write_scanlines(...); */
 340
 341         /* Here we use the library's state variable cinfo.next_scanline as the
 342                 * loop counter, so that we don't have to keep track ourselves.
 343                 * To keep things simple, we pass one scanline per call; you can pass
 344                 * more if you wish, though.
 345                 */
 346         row_stride = self->width * 3;   /* JSAMPLEs per row in image_buffer */
 347
 348         while (cinfo.next_scanline < cinfo.image_height) {
 349                 /* jpeg_write_scanlines expects an array of pointers to scanlines.
 350                 * Here the array is only one element long, but you could pass
 351                 * more than one scanline at a time if that's more convenient.
 352                 */
 353                 row_pointer[0] = ((uint8_t *)UArray_bytes(self->byteArray) + (cinfo.next_scanline * row_stride));
 354                 (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
 355         }
 356
 357         /* Step 6: Finish compression */
 358
 359         jpeg_finish_compress(&cinfo);
 360         /* After finish_compress, we can close the output file. */
 361         fclose(outfile);
 362
 363         /* Step 7: release JPEG compression object */
 364
 365         /* This is an important step since it will release a good deal of memory. */
 366         jpeg_destroy_compress(&cinfo);
 367 }
 368
 369 /*
 370  void JPGImage_setBuffer_length_(JPGImage *self, void *data, int size)
 371  { self->data = png_create( self->width, self->height, self->format); }
 372  */
 373
 374 int JPGImage_width(JPGImage *self)
 375 {
 376         return self->width;
 377 }
 378
 379 int JPGImage_height(JPGImage *self)
 380 {
 381         return self->height;
 382 }
 383
 384 void JPGImage_width_(JPGImage *self, int w)
 385 {
 386         self->width = w;
 387 }
 388
 389 void JPGImage_height_(JPGImage *self, int h)
 390 {
 391         self->height = h;
 392 }
 393
 394 void JPGImage_components_(JPGImage *self, int c)
 395 {
 396         self->components = c;
 397 }
 398
 399 unsigned char JPGImage_isL8(JPGImage *self)
 400 {
 401         return (self->components == 1); /* LUMINANCE */
 402 }
 403
 404 unsigned char JPGImage_isLA8(JPGImage *self)
 405 {
 406         return (self->components == 2); /* LUMINANCE, ALPHA */
 407 }
 408
 409 unsigned char JPGImage_isRGB8(JPGImage *self)
 410 {
 411         return (self->components == 3); /* RGB */
 412 }
 413
 414 unsigned char JPGImage_isRGBA8(JPGImage *self)
 415 {
 416         return (self->components == 4); /* RGBA */
 417 }
 418
 419 int JPGImage_components(JPGImage *self)
 420 {
 421         return self->components;
 422 }
 423
 424 int JPGImage_sizeInBytes(JPGImage *self)
 425 {
 426         return self->height * self->width * self->components;
 427 }
 428
 429 void *JPGImage_data(JPGImage *self)
 430 {
 431         return (uint8_t *)UArray_bytes(self->byteArray);
 432 }
 433
 434 UArray *JPGImage_byteArray(JPGImage *self)
 435 {
 436         return self->byteArray;
 437 }
 438
 439 void JPGImage_setExternalUArray_(JPGImage *self, UArray *ba)
 440 {
 441         if (self->ownsUArray)
 442         {
 443                 UArray_free(self->byteArray);
 444         }
 445         self->byteArray = ba;
 446         self->ownsUArray = 0;
 447 }
 448
 449