wave-jpeg.cpp

Go to the documentation of this file.

/*
 * wave-jpeg.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Reading jpeg files.  See wave-jpeg.h
 */

// includes --------------------------------------------------------------------
#include "wave-jpeg.h"                  // always include our own header first!

// libjpeg headers
#include <setjmp.h>
#include <jpeglib.h>

#include "common/wave_ex.h"
#include "nstream/nstream.h"
#include "perf/perf.h"
#include "util/file.h"
#include "util/token_stream.h"



namespace media {


// constants

static const int s_bufferSize           = 4096;

struct source_context_t {
        // constructor, manipulators
        source_context_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        pstream = NULL;
                }

        struct jpeg_source_mgr          pub;
        std::istream *                  pstream;
        char                            buffer[s_bufferSize];
};




////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static void
init_source
(
IN struct jpeg_decompress_struct * pds
)
{
        pds = pds;      // unused
        // nothing to do!
}


#ifdef WIN32
typedef boolean boolean_t;
#else   // WIN32
typedef int boolean_t;
#endif  // WIN32

static boolean_t
fill_input_buffer
(
IN struct jpeg_decompress_struct * pds
)
{
        ASSERT(pds, "null");
        source_context_t * psc = (source_context_t *) pds->src;
        ASSERT(psc, "null source object");
        ASSERT(psc->pstream, "null stream");

        // I still find it hard to believe there isn't a transactional
        //   read command for std::istream()!  Calling read() and then
        //   gcount() is bogus...
        psc->pstream->read(psc->buffer, s_bufferSize);
        int nRead = psc->pstream->gcount();

        // we take a cue from the SDL source: if the stream ends early,
        //   fake an end of image.  I'm not sure if this works, but it
        //   may make loading of partial images more graceful.
        if (nRead <= 0) {
                psc->buffer[0] = 0xFF;
                psc->buffer[1] = JPEG_EOI;
                nRead = 2;
        }

        // update public data
        psc->pub.next_input_byte = (JOCTET *) psc->buffer;
        psc->pub.bytes_in_buffer = nRead;

        return TRUE;
}



static void
skip_input_data
(
IN struct jpeg_decompress_struct * pds,
IN long bytes
)
{
        ASSERT(pds, "null");
        source_context_t * psc = (source_context_t *) pds->src;
        ASSERT(psc, "null source");

        if (bytes < 1)
                return;         // nothing to do...

        while (bytes > (long) psc->pub.bytes_in_buffer) {
                bytes -= psc->pub.bytes_in_buffer;
                psc->pub.fill_input_buffer(pds);
        }

        psc->pub.next_input_byte += bytes;
        psc->pub.bytes_in_buffer -= bytes;
}



static void
term_source
(
IN struct jpeg_decompress_struct * pds
)
{
        pds = pds;      // unused
        // nothing to do...
}



static void
setJpegSourceStream
(
IN struct jpeg_decompress_struct& cinfo,
IN std::istream& stream
)
{
        ASSERT_THROW(stream.good(), "bad?");

        // Here we are setting our own source for jpeg data.  Basically we
        // are wrapping the std::istream so the jpeg libraries can pull data.
        // Look for this sort of code out in the Internet for other examples.
        if (!cinfo.src) {
                cinfo.src = (struct jpeg_source_mgr *)
                    (*cinfo.mem->alloc_small)((j_common_ptr) &cinfo,
                        JPOOL_PERMANENT,
                        sizeof(source_context_t));
                ASSERT(cinfo.src, "out of memory");

                source_context_t * psc = (source_context_t *) cinfo.src;
                psc->clear();
        }

        // set up other data
        source_context_t * psc = (source_context_t *) cinfo.src;
        ASSERT(psc, "null");
        psc->pub.init_source = init_source;
        psc->pub.fill_input_buffer = fill_input_buffer;
        psc->pub.skip_input_data = skip_input_data;
        psc->pub.resync_to_restart = jpeg_resync_to_restart;    // use default
        psc->pub.term_source = term_source;
        psc->pub.next_input_byte = (JOCTET *) psc->buffer;
        psc->pub.bytes_in_buffer = 0;   // needs to be filled

        psc->pstream = &stream;
}



struct my_error_mgr {
        struct jpeg_error_mgr   errmgr;
        jmp_buf                 setjmp_buffer;
};



static void
my_error_exit
(
IN j_common_ptr cinfo
)
{
        my_error_mgr * err = (my_error_mgr *) cinfo->err;
        longjmp(err->setjmp_buffer, 1);
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

void
readJpegFromStream
(
IO std::istream& stream,
OUT image_t& image
)
{
        perf::Timer timer("readJpegFromStream");
        ASSERT_THROW(stream.good(), "bad?");
        image.clear();

        struct jpeg_decompress_struct cinfo;
        struct my_error_mgr jerr;
        JSAMPROW rowptr[1];

        // this is where we go if there's an error
        cinfo.err = jpeg_std_error(&jerr.errmgr);
        jerr.errmgr.error_exit = my_error_exit;
        cinfo.err->output_message = NULL;
        if (setjmp(jerr.setjmp_buffer)) {
                jpeg_destroy_decompress(&cinfo);
                image.clear();
                WAVE_EX(wex);
                wex << "Failed to read jpeg from stream";
        }

        // initialize
        jpeg_create_decompress(&cinfo);
        setJpegSourceStream(cinfo, stream);     // use stream as data source
        jpeg_read_header(&cinfo, TRUE);
        cinfo.out_color_space = JCS_RGB;        // we want RGB data
        cinfo.quantize_colors = FALSE;
        jpeg_calc_output_dimensions(&cinfo);

        // allocate space for raw data
        image.width = cinfo.output_width;
        image.height = cinfo.output_height;
        image.bytes_per_pixel = 3;
        image.bit_depth = 24;
        image.color_format = eColorFormat_RGB;
        image.allocate();
        if (!image.data) {
                jpeg_destroy_decompress(&cinfo);
                WAVE_EX(wex);
                wex << "Out of memory";
        }

        // okay, start decompressing...
        jpeg_start_decompress(&cinfo);
        while (cinfo.output_scanline < cinfo.output_height) {
                rowptr[0] = (JSAMPROW) (image.data +
                    (cinfo.output_scanline * cinfo.output_width));
                jpeg_read_scanlines(&cinfo, rowptr, (JDIMENSION) 1);
        }

        // all done--cleanup!
        jpeg_finish_decompress(&cinfo);
        jpeg_destroy_decompress(&cinfo);
}



class JpegImageLoader : public ImageLoader {
public:
        ~JpegImageLoader(void) throw() { }

        // media::ImageLoader class interface methods --------------------------
        const char * getLoaderName(void) const throw() { return "JPEG"; }

        bool canLoadImage(IN nstream::Manager * mgr,
                                IN const char * name) const {
                        mgr = mgr;              // unused
                        ASSERT(name, "null");

                        const char * ext = GetExtension(name);
                        return (!strcasecmp(ext, "jpg") ||
                                !strcasecmp(ext, "jpeg"));
                }

        void load(IN nstream::Stream * stream,
                                OUT image_t& image) const {
                        ASSERT(stream, "null");
                        std::istream& input = stream->getStream();
                        ASSERT_THROW(input.good(), "bad?");

                        readJpegFromStream(input, image);
                }
};



smart_ptr<ImageLoader>
createJpegImageLoader
(
void
)
{
        smart_ptr<ImageLoader> local = new JpegImageLoader;
        ASSERT_THROW(local, "out of memory");

        return local;
}



};      // media namespace