1 files changed, 437 insertions, 0 deletions

diff --git a/src/others/mimesh/libg3d-0.0.8/plugins/image/img_jpeg.c b/src/others/mimesh/libg3d-0.0.8/plugins/image/img_jpeg.c
new file mode 100644
index 0000000..138f26b
--- /dev/null
+++ b/src/others/mimesh/libg3d-0.0.8/plugins/image/img_jpeg.c
@@ -0,0 +1,437 @@
+/* $Id$ */
+
+/*
+    libg3d - 3D object loading library
+
+    Copyright (c) 2011, Dawid Seikel.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; version 2 of the License.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+
+/* This is an ugly collection of styles, I'll fix it up later, just want to get it pushed up now.  lol */
+
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include <g3d/types.h>
+#include <g3d/stream.h>
+
+#include <jpeglib.h>
+#include <jerror.h>
+#include <setjmp.h>
+
+#define BUFSIZE 1024
+
+typedef struct
+{
+    struct jpeg_source_mgr pub; /* public fields */
+
+    G3DStream *stream;          /* source stream */
+    JOCTET *buffer;             /* start of buffer */
+    boolean start_of_file;      /* have we gotten any data yet? */
+} my_source_mgr;
+
+typedef my_source_mgr *my_src_ptr;
+
+/* Stuff to stop jpeglib from exit() when things fail. */
+struct my_error_mgr
+{
+    struct jpeg_error_mgr pub;  /* "public" fields */
+    jmp_buf setjmp_buffer;      /* for return to caller */
+};
+
+typedef struct my_error_mgr *my_error_ptr;
+
+/*
+ * Here's the routine that will replace the standard error_exit method:
+ */
+
+METHODDEF(void)
+my_error_exit (j_common_ptr cinfo)
+{
+  /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
+  my_error_ptr myerr = (my_error_ptr) cinfo->err;
+
+  /* Always display the message. */
+  /* We could postpone this until after returning, if we chose. */
+  (*cinfo->err->output_message) (cinfo);
+
+  /* Return control to the setjmp point */
+  longjmp(myerr->setjmp_buffer, 1);
+}
+
+
+static void init_stream_source (j_decompress_ptr cinfo);
+static boolean fill_stream_input_buffer (j_decompress_ptr cinfo);
+static void skip_input_data (j_decompress_ptr cinfo, long num_bytes);
+/*static void resync_to_restart (j_decompress_ptr cinfo, int desired);*/
+static void term_source (j_decompress_ptr cinfo);
+static void jpeg_stream_src(struct jpeg_decompress_struct *cinfo, G3DStream *stream);
+
+
+EAPI
+gchar *plugin_description(G3DContext *context)
+{
+    return g_strdup("JPEG images.");
+}
+
+EAPI
+gchar **plugin_extensions(G3DContext *context)
+{
+    return g_strsplit("jpg:jpeg:jpe:jfif:jif", ":", 0);
+}
+
+EAPI
+gboolean plugin_load_image_from_stream(G3DContext *context, G3DStream *stream, G3DImage *image, gpointer user_data)
+{
+    gsize n;
+    gboolean retval;
+    guint32 x, y, nchannels;
+
+  /* This struct contains the JPEG decompression parameters and pointers to
+   * working space (which is allocated as needed by the JPEG library).
+   */
+  struct jpeg_decompress_struct cinfo;
+  /* We use our private extension JPEG error handler.
+   * Note that this struct must live as long as the main JPEG parameter
+   * struct, to avoid dangling-pointer problems.
+   */
+  struct my_error_mgr jerr;
+  /* More stuff */
+  JSAMPARRAY buffer;            /* Output row buffer */
+  int row_stride;               /* physical row width in output buffer */
+
+  /* Step 1: allocate and initialize JPEG decompression object */
+
+  /* We set up the normal JPEG error routines, then override error_exit. */
+  cinfo.err = jpeg_std_error(&jerr.pub);
+  jerr.pub.error_exit = my_error_exit;
+  /* Establish the setjmp return context for my_error_exit to use. */
+  if (setjmp(jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error.
+     * We need to clean up the JPEG object, close the input file, and return.
+     */
+    jpeg_destroy_decompress(&cinfo);
+    return 0;
+  }
+  /* Now we can initialize the JPEG decompression object. */
+  jpeg_create_decompress(&cinfo);
+
+  /* Step 2: specify data source (eg, a file) */
+
+  jpeg_stream_src(&cinfo, stream);
+
+  /* Step 3: read file parameters with jpeg_read_header() */
+
+  (void) jpeg_read_header(&cinfo, TRUE);
+  /* We can ignore the return value from jpeg_read_header since
+   *   (a) suspension is not possible with the stdio data source, and
+   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
+   * See libjpeg.txt for more info.
+   */
+
+  /* Step 4: set parameters for decompression */
+
+        if (cinfo.jpeg_color_space != JCS_RGB)
+        {
+                g_warning("Jpeg plugin: %s: colorspace is not RGB, converting.", stream->uri);
+                cinfo.out_color_space = JCS_RGB;
+        }
+
+
+  /* Step 5: Start decompressor */
+
+  (void) jpeg_start_decompress(&cinfo);
+  /* We can ignore the return value since suspension is not possible
+   * with the stdio data source.
+   */
+
+  /* We may need to do some setup of our own at this point before reading
+   * the data.  After jpeg_start_decompress() we have the correct scaled
+   * output image dimensions available, as well as the output colormap
+   * if we asked for color quantization.
+   * In this example, we need to make an output work buffer of the right size.
+   */ 
+  /* JSAMPLEs per row in output buffer */
+  row_stride = cinfo.output_width * cinfo.output_components;
+  /* Make a one-row-high sample array that will go away when done with image */
+  buffer = (*cinfo.mem->alloc_sarray)
+                ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
+
+/*
+//output_width            image width and height, as scaled
+//output_height
+//out_color_components    # of color components in out_color_space
+//output_components       # of color components returned per pixel
+//colormap                the selected colormap, if any
+//actual_number_of_colors         number of entries in colormap
+*/
+        nchannels = cinfo.output_components;
+        if(nchannels < 3)
+        {
+                g_warning("Jpeg plugin: %s: has only %d channels", stream->uri, nchannels);
+                jpeg_destroy_decompress(&cinfo);
+                return FALSE;
+        }
+
+        image->width = cinfo.output_width;
+        image->height = cinfo.output_height;
+        image->depth = 32;
+        image->name = g_path_get_basename(stream->uri);
+        image->pixeldata = g_new0(guint8, image->width * image->height * 4);
+
+
+  /* Step 6: while (scan lines remain to be read) */
+  /*           jpeg_read_scanlines(...); */
+
+  /* Here we use the library's state variable cinfo.output_scanline as the
+   * loop counter, so that we don't have to keep track ourselves.
+   */
+    y = 0;
+    while (cinfo.output_scanline < cinfo.output_height)
+    {
+    /* jpeg_read_scanlines expects an array of pointers to scanlines.
+     * Here the array is only one element long, but you could ask for
+     * more than one scanline at a time if that's more convenient.
+     */
+    (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+/*      for(y = 0; y < image->height; y ++) */
+                for(x = 0; x < image->width; x ++)
+                {
+                        JSAMPROW p = buffer[0] + x * nchannels;
+
+                        image->pixeldata[(y * image->width + x) * 4 + 0] = GETJSAMPLE(p[0]);
+                        image->pixeldata[(y * image->width + x) * 4 + 1] = GETJSAMPLE(p[1]);
+                        image->pixeldata[(y * image->width + x) * 4 + 2] = GETJSAMPLE(p[2]);
+                        if(nchannels >= 4)
+                                image->pixeldata[(y * image->width + x) * 4 + 3] = GETJSAMPLE(p[3]);
+                }
+        y++;
+  }
+
+    /* set alpha to 1.0 */
+    if(nchannels < 4)
+        for(y = 0; y < image->height; y ++)
+            for(x = 0; x < image->width; x ++)
+                image->pixeldata[(y * image->width + x) * 4 + 3] = 0xFF;
+
+  /* Step 7: Finish decompression */
+
+  (void) jpeg_finish_decompress(&cinfo);
+  /* We can ignore the return value since suspension is not possible
+   * with the stdio data source.
+   */
+
+  /* Step 8: Release JPEG decompression object */
+
+  /* This is an important step since it will release a good deal of memory. */
+  jpeg_destroy_decompress(&cinfo);
+
+  /* At this point you may want to check to see whether any corrupt-data
+   * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
+   */
+
+    return TRUE;
+}
+
+/*
+ * SOME FINE POINTS:
+ *
+ * In the above code, we ignored the return value of jpeg_read_scanlines,
+ * which is the number of scanlines actually read.  We could get away with
+ * this because we asked for only one line at a time and we weren't using
+ * a suspending data source.  See libjpeg.txt for more info.
+ *
+ * We cheated a bit by calling alloc_sarray() after jpeg_start_decompress();
+ * we should have done it beforehand to ensure that the space would be
+ * counted against the JPEG max_memory setting.  In some systems the above
+ * code would risk an out-of-memory error.  However, in general we don't
+ * know the output image dimensions before jpeg_start_decompress(), unless we
+ * call jpeg_calc_output_dimensions().  See libjpeg.txt for more about this.
+ *
+ * Scanlines are returned in the same order as they appear in the JPEG file,
+ * which is standardly top-to-bottom.  If you must emit data bottom-to-top,
+ * you can use one of the virtual arrays provided by the JPEG memory manager
+ * to invert the data.  See wrbmp.c for an example.
+ *
+ * As with compression, some operating modes may require temporary files.
+ * On some systems you may need to set up a signal handler to ensure that
+ * temporary files are deleted if the program is interrupted.  See libjpeg.txt.
+ */
+
+
+    const JOCTET * next_input_byte; /* => next byte to read from buffer */
+    size_t bytes_in_buffer;         /* # of bytes remaining in buffer */
+
+/*
+        Initialize source. This is called by jpeg_read_header() before any
+        data is actually read. Unlike init_destination(), it may leave
+        bytes_in_buffer set to 0 (in which case a fill_input_buffer() call
+        will occur immediately).
+*/
+
+static void init_stream_source (j_decompress_ptr cinfo)
+{
+  my_src_ptr src = (my_src_ptr) cinfo->src;
+
+  /* We reset the empty-input-file flag for each image,
+   * but we don't clear the input buffer.
+   * This is correct behavior for reading a series of images from one source.
+   */
+  src->start_of_file = TRUE;
+}
+
+/*
+        This is called whenever bytes_in_buffer has reached zero and more
+        data is wanted. In typical applications, it should read fresh data
+        into the buffer (ignoring the current state of next_input_byte and
+        bytes_in_buffer), reset the pointer & count to the start of the
+        buffer, and return TRUE indicating that the buffer has been reloaded.
+        It is not necessary to fill the buffer entirely, only to obtain at
+        least one more byte. bytes_in_buffer MUST be set to a positive value
+        if TRUE is returned. A FALSE return should only be used when I/O
+        suspension is desired (this mode is discussed in the next section).
+*/
+static boolean fill_stream_input_buffer (j_decompress_ptr cinfo)
+{
+    my_src_ptr src = (my_src_ptr) cinfo->src;
+    size_t nbytes = 0;
+
+    if (!g3d_stream_eof(src->stream))
+        nbytes = g3d_stream_read(src->stream, src->buffer, BUFSIZE);
+
+    if (nbytes <= 0)
+    {
+        if (src->start_of_file) /* Treat empty input file as fatal error */
+            ERREXIT(cinfo, JERR_INPUT_EMPTY);
+        WARNMS(cinfo, JWRN_JPEG_EOF);
+        /* Insert a fake EOI marker */
+        src->buffer[0] = (JOCTET) 0xFF;
+        src->buffer[1] = (JOCTET) JPEG_EOI;
+        nbytes = 2;
+    }
+
+    src->pub.next_input_byte = src->buffer;
+    src->pub.bytes_in_buffer = nbytes;
+    src->start_of_file = FALSE;
+
+    return TRUE;
+}
+
+/*
+        Skip num_bytes worth of data. The buffer pointer and count should
+        be advanced over num_bytes input bytes, refilling the buffer as
+        needed. This is used to skip over a potentially large amount of
+        uninteresting data (such as an APPn marker). In some applications
+        it may be possible to optimize away the reading of the skipped data,
+        but it's not clear that being smart is worth much trouble; large
+        skips are uncommon. bytes_in_buffer may be zero on return.
+        A zero or negative skip count should be treated as a no-op.
+*/
+static void skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+{
+  struct jpeg_source_mgr * src = cinfo->src;
+
+  /* Just a dumb implementation for now.  Could use fseek() except
+   * it doesn't work on pipes.  Not clear that being smart is worth
+   * any trouble anyway --- large skips are infrequent.
+   */
+  if (num_bytes > 0)
+  {
+    while (num_bytes > (long) src->bytes_in_buffer)
+    {
+      num_bytes -= (long) src->bytes_in_buffer;
+      (void) (*src->fill_input_buffer) (cinfo);
+      /* note we assume that fill_input_buffer will never return FALSE,
+       * so suspension need not be handled.
+       */
+    }
+    src->next_input_byte += (size_t) num_bytes;
+    src->bytes_in_buffer -= (size_t) num_bytes;
+  }
+}
+
+/*
+        This routine is called only when the decompressor has failed to find
+        a restart (RSTn) marker where one is expected. Its mission is to
+        find a suitable point for resuming decompression. For most
+        applications, we recommend that you just use the default resync
+        procedure, jpeg_resync_to_restart(). However, if you are able to back
+        up in the input data stream, or if you have a-priori knowledge about
+        the likely location of restart markers, you may be able to do better.
+        Read the read_restart_marker() and jpeg_resync_to_restart() routines
+        in jdmarker.c if you think you'd like to implement your own resync
+        procedure.
+*/
+/*
+//static void resync_to_restart (j_decompress_ptr cinfo, int desired)
+//{
+//}
+*/
+
+/*
+        Terminate source --- called by jpeg_finish_decompress() after all
+        data has been read. Often a no-op.
+*/
+static void term_source (j_decompress_ptr cinfo)
+{
+  /* no work necessary here */
+}
+/*
+For both fill_input_buffer() and skip_input_data(), there is no such thing as an EOF return. If the end of the file has been reached, the routine has a choice of exiting via ERREXIT() or inserting fake data into the buffer. In most cases, generating a warning message and inserting a fake EOI marker is the best course of action --- this will allow the decompressor to output however much of the image is there. In pathological cases, the decompressor
+
+may swallow the EOI and again demand data ... just keep feeding it fake EOIs.
+
+jdatasrc.c illustrates the recommended error recovery behavior.
+
+term_source() is NOT called by jpeg_abort() or jpeg_destroy(). If you want the source manager to be cleaned up during an abort, you must do it yourself.
+
+You will also need code to create a jpeg_source_mgr struct, fill in its method pointers, and insert a pointer to the struct into the "src" field of the JPEG decompression object. This can be done in-line in your setup code if you like, but it's probably cleaner to provide a separate routine similar to the jpeg_stdio_src() routine of the supplied source manager.
+
+For more information, consult the stdio source and destination managers in jdatasrc.c and jdatadst.c. 
+*/
+
+static void jpeg_stream_src(struct jpeg_decompress_struct *cinfo, G3DStream *stream)
+{
+    my_source_mgr *src;
+
+    if (stream == NULL)
+        ERREXIT(cinfo, JERR_INPUT_EMPTY);
+
+  /* The source object is made permanent so that a series of JPEG images
+   * can be read from the same buffer by calling jpeg_mem_src only before
+   * the first one.
+   */
+  if (cinfo->src == NULL) {     /* first time for this JPEG object? */
+    cinfo->src = (struct jpeg_source_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(my_source_mgr));
+
+    src = (my_src_ptr) cinfo->src;
+    src->buffer = (JOCTET *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, BUFSIZE * sizeof(JOCTET));
+  }
+
+  src = (my_src_ptr) cinfo->src;
+  src->pub.init_source = init_stream_source;
+  src->pub.fill_input_buffer = fill_stream_input_buffer;
+  src->pub.skip_input_data = skip_input_data;
+  src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+  src->pub.term_source = term_source;
+  src->stream = stream;
+  src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
+  src->pub.next_input_byte = NULL; /* until buffer loaded */
+}
+