wrlib/jpeg.c

   1 /* jpeg.c - load JPEG image from file
   2  *
   3  * Raster graphics library
   4  *
   5  * Copyright (c) 1997-2003 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 /* Avoid a compiler warning */
  26 #undef HAVE_STDLIB_H
  27
  28
  29
  30 #ifdef USE_JPEG
  31
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35
  36 #include <jpeglib.h>
  37
  38 #include "wraster.h"
  39
  40 /*
  41  * <setjmp.h> is used for the optional error recovery mechanism shown in
  42  * the second part of the example.
  43  */
  44
  45 #include <setjmp.h>
  46
  47 /*
  48  * ERROR HANDLING:
  49  *
  50  * The JPEG library's standard error handler (jerror.c) is divided into
  51  * several "methods" which you can override individually.  This lets you
  52  * adjust the behavior without duplicating a lot of code, which you might
  53  * have to update with each future release.
  54  *
  55  * Our example here shows how to override the "error_exit" method so that
  56  * control is returned to the library's caller when a fatal error occurs,
  57  * rather than calling exit() as the standard error_exit method does.
  58  *
  59  * We use C's setjmp/longjmp facility to return control.  This means that the
  60  * routine which calls the JPEG library must first execute a setjmp() call to
  61  * establish the return point.  We want the replacement error_exit to do a
  62  * longjmp().  But we need to make the setjmp buffer accessible to the
  63  * error_exit routine.  To do this, we make a private extension of the
  64  * standard JPEG error handler object.  (If we were using C++, we'd say we
  65  * were making a subclass of the regular error handler.)
  66  *
  67  * Here's the extended error handler struct:
  68  */
  69
  70 struct my_error_mgr {
  71     struct jpeg_error_mgr pub;  /* "public" fields */
  72
  73     jmp_buf setjmp_buffer;      /* for return to caller */
  74 };
  75
  76 typedef struct my_error_mgr * my_error_ptr;
  77
  78 /*
  79  * Here's the routine that will replace the standard error_exit method:
  80  */
  81
  82 static void
  83 my_error_exit(j_common_ptr cinfo)
  84 {
  85     /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
  86     my_error_ptr myerr = (my_error_ptr) cinfo->err;
  87
  88     /* Always display the message. */
  89     /* We could postpone this until after returning, if we chose. */
  90     (*cinfo->err->output_message) (cinfo);
  91
  92     /* Return control to the setjmp point */
  93     longjmp(myerr->setjmp_buffer, 1);
  94 }
  95
  96
  97 RImage*
  98 RLoadJPEG(RContext *context, char *file_name, int index)
  99 {
 100     RImage *image = NULL;
 101     struct jpeg_decompress_struct cinfo;
 102     int i;
 103     unsigned char *ptr;
 104     JSAMPROW buffer[1], bptr;
 105     FILE *file;
 106     /* We use our private extension JPEG error handler.
 107      * Note that this struct must live as long as the main JPEG parameter
 108      * struct, to avoid dangling-pointer problems.
 109      */
 110     struct my_error_mgr jerr;
 111
 112     file = fopen(file_name, "rb");
 113     if (!file) {
 114         RErrorCode = RERR_OPEN;
 115         return NULL;
 116     }
 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     if (cinfo.image_width < 1 || cinfo.image_height < 1) {
 137         RErrorCode = RERR_BADIMAGEFILE;
 138         goto bye;
 139     }
 140
 141     bptr = buffer[0] = (JSAMPROW)malloc(cinfo.image_width*cinfo.num_components);
 142     if (!buffer[0]) {
 143         RErrorCode = RERR_NOMEMORY;
 144         goto bye;
 145     }
 146
 147     if(cinfo.jpeg_color_space==JCS_GRAYSCALE) {
 148         cinfo.out_color_space=JCS_GRAYSCALE;
 149     } else
 150         cinfo.out_color_space = JCS_RGB;
 151     cinfo.quantize_colors = FALSE;
 152     cinfo.do_fancy_upsampling = FALSE;
 153     cinfo.do_block_smoothing = FALSE;
 154     jpeg_calc_output_dimensions(&cinfo);
 155
 156     if (context->flags.optimize_for_speed)
 157         image = RCreateImage(cinfo.image_width, cinfo.image_height, True);
 158     else
 159         image = RCreateImage(cinfo.image_width, cinfo.image_height, False);
 160
 161     if (!image) {
 162         RErrorCode = RERR_NOMEMORY;
 163         goto bye;
 164     }
 165     jpeg_start_decompress(&cinfo);
 166
 167     ptr = image->data;
 168
 169
 170     if (cinfo.out_color_space==JCS_RGB) {
 171         if (context->flags.optimize_for_speed) {
 172             while (cinfo.output_scanline < cinfo.output_height) {
 173                 jpeg_read_scanlines(&cinfo, buffer,(JDIMENSION) 1);
 174                 bptr = buffer[0];
 175                 for (i=0; i<cinfo.image_width; i++) {
 176                     *ptr++ = *bptr++;
 177                     *ptr++ = *bptr++;
 178                     *ptr++ = *bptr++;
 179                     ptr++; /* skip alpha channel */
 180                 }
 181             }
 182         } else {
 183             while (cinfo.output_scanline < cinfo.output_height) {
 184                 jpeg_read_scanlines(&cinfo, buffer,(JDIMENSION) 1);
 185                 bptr = buffer[0];
 186                 memcpy(ptr, bptr, cinfo.image_width*3);
 187                 ptr += cinfo.image_width*3;
 188             }
 189         }
 190     } else {
 191         while (cinfo.output_scanline < cinfo.output_height) {
 192             jpeg_read_scanlines(&cinfo, buffer,(JDIMENSION) 1);
 193             bptr = buffer[0];
 194             for (i=0; i<cinfo.image_width; i++) {
 195                 *ptr++ = *bptr;
 196                 *ptr++ = *bptr;
 197                 *ptr++ = *bptr++;
 198             }
 199         }
 200     }
 201
 202     jpeg_finish_decompress(&cinfo);
 203
 204 bye:
 205     jpeg_destroy_decompress(&cinfo);
 206
 207     fclose(file);
 208
 209     if (buffer[0])
 210         free(buffer[0]);
 211
 212     return image;
 213 }
 214
 215 #endif /* USE_JPEG */
 216