wrlib/jpeg.c

   1 /* jpeg.c - load JPEG image from file
   2  *
   3  *  Raster graphics library
   4  *
   5  *  Copyright (c) 1997 Alfredo K. Kojima
   6  *
   7  *  This library is free software; you can redistribute it and/or
   8  *  modify it under the terms of the GNU Library General Public
   9  *  License as published by the Free Software Foundation; either
  10  *  version 2 of the License, or (at your option) any later version.
  11  *
  12  *  This library is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Library General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Library General Public
  18  *  License along with this library; if not, write to the Free
  19  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <config.h>
  23
  24
  25
  26
  27
  28 #ifdef USE_JPEG
  29
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33
  34 #include <jpeglib.h>
  35
  36 #include "wraster.h"
  37
  38 /*
  39  * <setjmp.h> is used for the optional error recovery mechanism shown in
  40  * the second part of the example.
  41  */
  42
  43 #include <setjmp.h>
  44
  45 /*
  46  * ERROR HANDLING:
  47  *
  48  * The JPEG library's standard error handler (jerror.c) is divided into
  49  * several "methods" which you can override individually.  This lets you
  50  * adjust the behavior without duplicating a lot of code, which you might
  51  * have to update with each future release.
  52  *
  53  * Our example here shows how to override the "error_exit" method so that
  54  * control is returned to the library's caller when a fatal error occurs,
  55  * rather than calling exit() as the standard error_exit method does.
  56  *
  57  * We use C's setjmp/longjmp facility to return control.  This means that the
  58  * routine which calls the JPEG library must first execute a setjmp() call to
  59  * establish the return point.  We want the replacement error_exit to do a
  60  * longjmp().  But we need to make the setjmp buffer accessible to the
  61  * error_exit routine.  To do this, we make a private extension of the
  62  * standard JPEG error handler object.  (If we were using C++, we'd say we
  63  * were making a subclass of the regular error handler.)
  64  *
  65  * Here's the extended error handler struct:
  66  */
  67
  68 struct my_error_mgr {
  69   struct jpeg_error_mgr pub;    /* "public" fields */
  70
  71   jmp_buf setjmp_buffer;        /* for return to caller */
  72 };
  73
  74 typedef struct my_error_mgr * my_error_ptr;
  75
  76 /*
  77  * Here's the routine that will replace the standard error_exit method:
  78  */
  79
  80 void
  81 my_error_exit (j_common_ptr cinfo)
  82 {
  83   /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
  84   my_error_ptr myerr = (my_error_ptr) cinfo->err;
  85
  86   /* Always display the message. */
  87   /* We could postpone this until after returning, if we chose. */
  88   (*cinfo->err->output_message) (cinfo);
  89
  90   /* Return control to the setjmp point */
  91   longjmp(myerr->setjmp_buffer, 1);
  92 }
  93
  94
  95 RImage*
  96 RLoadJPEG(RContext *context, char *file_name, int index)
  97 {
  98     RImage *image = NULL;
  99     struct jpeg_decompress_struct cinfo;
 100     int i, j;
 101     unsigned char *r, *g, *b;
 102     JSAMPROW buffer[1];
 103     FILE *file;
 104     /* We use our private extension JPEG error handler.
 105      * Note that this struct must live as long as the main JPEG parameter
 106      * struct, to avoid dangling-pointer problems.
 107      */
 108     struct my_error_mgr jerr;
 109
 110     file = fopen(file_name, "r");
 111     if (!file) {
 112         sprintf(RErrorString, "could not open JPEG file \"%s\"", file_name);
 113         return NULL;
 114     }
 115
 116     RErrorString[0] = 0;
 117
 118     cinfo.err = jpeg_std_error(&jerr.pub);
 119     jerr.pub.error_exit = my_error_exit;
 120     /* Establish the setjmp return context for my_error_exit to use. */
 121     if (setjmp(jerr.setjmp_buffer)) {
 122        /* If we get here, the JPEG code has signaled an error.
 123         * We need to clean up the JPEG object, close the input file, and return.
 124         */
 125        jpeg_destroy_decompress(&cinfo);
 126        fclose(file);
 127        return NULL;
 128     }
 129
 130     jpeg_create_decompress(&cinfo);
 131
 132     jpeg_stdio_src(&cinfo, file);
 133
 134     jpeg_read_header(&cinfo, TRUE);
 135
 136     buffer[0] = (JSAMPROW)malloc(cinfo.image_width*cinfo.num_components);
 137     if (!buffer[0]) {
 138         sprintf(RErrorString, "out of memory");
 139         goto bye;
 140     }
 141
 142     image = RCreateImage(cinfo.image_width, cinfo.image_height, False);
 143     if (!image) {
 144         sprintf(RErrorString, "out of memory");
 145         goto bye;
 146     }
 147
 148     cinfo.out_color_space = JCS_RGB;
 149     cinfo.quantize_colors = FALSE;
 150     cinfo.do_fancy_upsampling = FALSE;
 151     cinfo.do_block_smoothing = FALSE;
 152
 153     jpeg_start_decompress(&cinfo);
 154
 155     r = image->data[0];
 156     g = image->data[1];
 157     b = image->data[2];
 158
 159     while (cinfo.output_scanline < cinfo.image_height) {
 160         jpeg_read_scanlines(&cinfo, buffer, 1);
 161         for (i=0,j=0; i<cinfo.image_width; i++) {
 162             *(r++) = buffer[0][j++];
 163             *(g++) = buffer[0][j++];
 164             *(b++) = buffer[0][j++];
 165         }
 166     }
 167 /*
 168     jpeg_finish_decompress(&cinfo);
 169 */
 170   bye:
 171     jpeg_destroy_decompress(&cinfo);
 172
 173     fclose(file);
 174
 175     if (buffer[0])
 176         free(buffer[0]);
 177
 178     return image;
 179 }
 180
 181 #endif /* USE_JPEG */