ImageLoaderJPEG.cpp

Go to the documentation of this file.

/*
    This is a mercury driver for the independent jpeg group's jpeglib.

    IF YOU WISH TO USE THIS, YOU MUST COMPLY WITH THE TERMS FOUND AT:
    http://www.ijg.org/ and get and include the library to use with this
    driver.  Because of legal linking difficulties, we cannot include
    the source to this application by default.

    IF YOU DO NOT WISH TO USE THIS, DO NOT COMPILE IT INTO YOUR APP.
    Mercury does not need this app to run.


    libJPG is Copyright (C) 1991-1997, Thomas G. Lane.
    This file is part of the Independent JPEG Group's software.
    For conditions of distribution and use, see the accompanying README file.
    This file contains additional configuration options that customize the
    JPEG software for special applications or support machine-dependent
    optimizations.  Most users will not need to touch this file.
*/

#include "MercuryTextureManager.h"
#include "MercuryLog.h"
#include <stdio.h>
#include "jpeglib.h"
#include <setjmp.h>

#if !defined(__GNUC__)
  #pragma comment(lib, "jpeg.lib")
#endif

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;


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);

  LOG.Warn( "JPEG Decompression failed." );

  /* Return control to the setjmp point */
  longjmp(myerr->setjmp_buffer, 1);
}

class DataSource
{
public:
    struct jpeg_source_mgr pub;/* public fields */

    DataSource() : pData(0) { }
    ~DataSource() { SAFE_DELETE( pData ); }

    JOCTET * pData;
    int iSize;
    int iPlace;
};

//Get info on these functions from jdatasrc.c
void HGinit_source(j_decompress_ptr cinfo)
{
    DataSource * pds = (DataSource*) cinfo->src;

}

unsigned char HGfill_input_buffer( j_decompress_ptr cinfo )
{
    DataSource * pds = (DataSource*) cinfo->src;
    
    if( pds->iSize == pds->iPlace )
        return false;

    pds->pub.next_input_byte = pds->pData;
    pds->pub.bytes_in_buffer = pds->iSize;
    pds->iPlace = pds->iSize;
    return true;
}

void HGskip_input_data(j_decompress_ptr cinfo, long num_bytes)
{
    DataSource * pds = (DataSource*) cinfo->src;

    //This looks queer... maybe we should see if it's ever getting called.
    pds->pub.next_input_byte += (size_t) num_bytes;
    pds->pub.bytes_in_buffer -= (size_t) num_bytes;
}

unsigned char HGresync_to_restart(j_decompress_ptr cinfo, int desired)
{
    return false;
}

void HGterm_source(j_decompress_ptr cinfo)
{
    //don't worry our pds gets deleted elsewhere.
}


RawImageData* LoadJPEG( MercuryFile * fp )
{
  RawImageData* rid = new RawImageData;
  DataSource pds;
  jpeg_decompress_struct cinfo;
  my_error_mgr jerr;
//  jpeg_source_mgr cmysource;

  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) */

//****************************************************************************//
    cinfo.src = (jpeg_source_mgr *)&pds;
    pds.pub.init_source = HGinit_source;
    pds.pub.fill_input_buffer = HGfill_input_buffer;
    pds.pub.skip_input_data = HGskip_input_data;
    pds.pub.resync_to_restart = HGresync_to_restart;
    pds.pub.term_source = HGterm_source;
    pds.pub.next_input_byte = 0;
    pds.pub.bytes_in_buffer = 0;
    pds.iSize = fp->Length();
    pds.pData = new JOCTET[pds.iSize];
    fp->Read( pds.pData, pds.iSize );
    pds.iPlace = 0;
  /* 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.doc for more info.
   */

  /* Step 4: set parameters for decompression */

  /* In this example, we don't need to change any of the defaults set by
   * jpeg_read_header(), so we do nothing here.
   */

  /* 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.
   */

//  rid->
  rid->attrs.m_height = cinfo.image_height;
  rid->attrs.m_width = cinfo.image_width;
  rid->data = new unsigned char[cinfo.image_height * cinfo.image_width * 3];
  
  //Let's assume 72 dpi
  rid->attrs.m_dpi_y = rid->attrs.m_dpi_x = 72;
  rid->attrs.m_ColorByteType = RGB;
  cinfo.out_color_space = JCS_RGB;


  /* 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);

  /* 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.
   */

  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);
    memcpy( rid->data + row_stride * (  cinfo.output_height-cinfo.output_scanline), *buffer, row_stride );
    /* Assume put_scanline_someplace wants a pointer and sample count. */
    //put_scanline_someplace(buffer[0], row_stride);
    //*****************************************************************************//

  }

  /* 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);

  /* After finish_decompress, we can close the input file.
   * Here we postpone it until after no more JPEG errors are possible,
   * so as to simplify the setjmp error logic above.  (Actually, I don't
   * think that jpeg_destroy can do an error exit, but why assume anything...)
   */
  /* And we're done! */
  return rid;
}

RUN_STATEMENT_AT_BOOT( include_jpeg, IMAGEREADERREGISTER.AddDecoder( LoadJPEG, "ÿØÿ" ); )

/*
 * (c) 2006 Charles Lohr
 * All rights reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, and/or sell copies of the Software, and to permit persons to
 * whom the Software is furnished to do so, provided that the above
 * copyright notice(s) and this permission notice appear in all copies of
 * the Software and that both the above copyright notice(s) and this
 * permission notice appear in supporting documentation.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
 * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
 * INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
 * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

---

Hosted by