image_libjpeg.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <stdio.h>
#include <errno.h>
#include <setjmp.h>
#include <iostream>
#include <string>

#include <jpeglib.h>
#include <jerror.h>

#include <archon/util/mutex.H>
#include <archon/util/text.H>
#include <archon/util/image.H>
#include <archon/util/charenc.H>

#if BITS_IN_JSAMPLE != 8
#error ERROR: Unsupported number of bits per color component in LIBJPEG.
#endif

using namespace std;

namespace Archon
{
  namespace Utilities
  {
    struct FormatLibjpeg: Image::Format
    {
      string getSpecifier() const
      {
        return "jpeg";
      }

      bool checkSignature(Ref<Stream::Reader> r) const
      {
        LoadContext c(r, 0, 0); // No logging since we are only probing.

        /*
         * ALERT: No exceptions may arise between this point and the
         * call to jpeg_create_decompress below.
         */
        LoadWrapper w;

        // Catch errors occuring in any of the following JPEG-functions:
        if(!setjmp(c.setjmpBuffer)) // try
        {
          w.cinfo.err = &c; // Downcast to jpeg_err_mgr
          jpeg_create_decompress(&w.cinfo);
          w.cinfo.src = &c; // Downcast to jpeg_source_mgr
          return jpeg_read_header(&w.cinfo, 1) == JPEG_HEADER_OK;
        }
        else // catch
        {
          return false;
        }
      }

      bool checkSuffix(string s) const
      {
        return s == "jpg" || s == "jpeg";
      }

      Image load(Ref<Stream::Reader> reader, Image::ProgressTracker *tracker,
                 Logger *logger) const
        throw(Image::InvalidFormatException,
              IOException, UnexpectedException)
      {
        // If possible use extra resources to improve the perceived
        // progressiveness of the loading process.
        bool progressive = false;

        LoadContext c(reader, tracker, logger);

        string comment;
        Image image;
        Array<JSAMPROW> rowPointers;

        /*
         * ALERT: No exceptions may arise between this point and the
         * call to jpeg_create_decompress below.
         */
        LoadWrapper w;

        /*
         * Handle termination and catch errors occuring in any of the
         * following JPEG-functions.
         */
        if(!setjmp(c.setjmpBuffer)) // try
        {
          w.cinfo.err = &c; // Downcast to jpeg_err_mgr
          jpeg_create_decompress(&w.cinfo);
          w.cinfo.src = &c; // Downcast to jpeg_source_mgr
          if(tracker) w.cinfo.progress = &c; // Downcast to jpeg_progress_mgr

          // Load comments from stream
          jpeg_save_markers(&w.cinfo, JPEG_COM, 0xFFFF);

          if(jpeg_read_header(&w.cinfo, 1) != JPEG_HEADER_OK)
            ARCHON_THROW1(Image::InvalidFormatException, "Not a JPEG header");

          // Turn off progressive mode for files/streams with
          // single-scan images.
          progressive = progressive && jpeg_has_multiple_scans(&w.cinfo);

          if(progressive)
          {
            // select buffered-image mode
            w.cinfo.buffered_image = 1;

            // Run the initial passes with single-pass fixed color quantization
            w.cinfo.two_pass_quantize = 0;
            w.cinfo.colormap          = 0;

            // Prepare for shifting to two-pass optimum color quantization.
            w.cinfo.enable_2pass_quant = 1;
          }

          // SET UP PRESCALING AT THIS POINT.

          jpeg_start_decompress(&w.cinfo);

          if(w.cinfo.output_components > 4)
            ARCHON_THROW1(Image::InvalidFormatException, "Image contains more than 4 color components per pixel");

          // Fetch the image geometry
          unsigned bitsPerComponent = 8;
          unsigned height           = w.cinfo.output_height;
          unsigned width            = w.cinfo.output_width;
          Image::ComponentSpecifier components =
            static_cast<Image::ComponentSpecifier>(w.cinfo.output_components);
          unsigned charsPerPixel    = (bitsPerComponent*components+7)/8;
          unsigned charsPerRow      = charsPerPixel*width;

          // Construct an image with an uninitialized pixel buffer
          image = Image(width, height, components, bitsPerComponent);

          // Make row array
          JSAMPROW pixelBuffer =
            reinterpret_cast<JSAMPROW>(getPixelBufferNoLeak(image));
          rowPointers.reset(height);
          for(unsigned i=0; i<height; ++i)
            rowPointers[i] = pixelBuffer + (height-i-1)*charsPerRow;

          if(progressive)
          {
            for(;;)
            {
              /*
               * Absorb any waiting input by calling jpeg_consume_input().
               *
               * It seems to me there are two important aspectes of
               * this. First of all it can be used to advance the input
               * consumption to the point where a blocking read would
               * block. This is important in progressive visualization
               * mode, since it may allow us to skip display iterations
               * if the data arrives fast enough. The challenge here is
               * that it requires support for a non-blocking read on the
               * stream.
               *
               * The obvious procedure would then be to start by
               * switching the stream to non-blocking mode, then calling
               * jpeg_consume_input() repeatedly until it returns either
               * JPEG_SUSPENDED (stream reader would block) or
               * JPEG_REACHED_EOI.
               *
               * At this point we must....
               */
              switch(jpeg_consume_input(&w.cinfo))
              {
              case JPEG_REACHED_SOS:    cerr << "JPEG_REACHED_SOS\n";
              case JPEG_REACHED_EOI:    cerr << "JPEG_REACHED_EOI\n";
              case JPEG_ROW_COMPLETED:  cerr << "JPEG_ROW_COMPLETED\n";
              case JPEG_SCAN_COMPLETED: cerr << "JPEG_SCAN_COMPLETED\n";
              case JPEG_SUSPENDED:      cerr << "JPEG_SUSPENDED\n";
              }

              bool final_pass = jpeg_input_complete(&w.cinfo);

              // Run final pass with two-pass optimum color quantization.
              if(final_pass)
              {
                w.cinfo.two_pass_quantize = 1; 
                w.cinfo.colormap          = 0;
              }

              jpeg_start_output(&w.cinfo, w.cinfo.input_scan_number);
              while(w.cinfo.output_scanline < height)
                jpeg_read_scanlines(&w.cinfo, rowPointers.get()+w.cinfo.output_scanline, height-w.cinfo.output_scanline);
              jpeg_finish_output(&w.cinfo);

              if(final_pass) break;
            }
          }
          else
          {
            while(w.cinfo.output_scanline < height)
              jpeg_read_scanlines(&w.cinfo, rowPointers.get()+w.cinfo.output_scanline, height-w.cinfo.output_scanline);
          }

          jpeg_saved_marker_ptr text = w.cinfo.marker_list;
          while(text)
          {
            string c = Text::lineTrim(string(reinterpret_cast<char *>(text->data), text->data_length));
            if(c.empty())
              if(comment.empty()) comment += "\n\n";
            comment += c;
            text = text->next;
          }

          // Transcode is done to destroy potentail illegal 8-bit data
          // from image.
          if(!comment.empty())
            image.setComment(CharEnc::transcode(comment, CharEnc::US_ASCII, CharEnc::UTF_8));

          jpeg_finish_decompress(&w.cinfo);
        }
        else // catch
        {
          switch(c.errorType)
          {
          case 1: throw ThreadTerminatedException(c.errorLocation);
          case 2: throw Stream::ReadException(c.errorLocation, c.errorMessage);
          case 3: throw UnexpectedException(c.errorLocation, c.errorMessage);
          }
          ARCHON_THROW1(Image::InvalidFormatException, c.errorMessage);
        }

        return image;
      }


      void save(Image image, Ref<Stream::Writer> writer,
                Image::ProgressTracker *tracker, Logger *logger) const
        throw(IOException, UnexpectedException)
      {
        SaveContext c(writer, tracker, logger);

        // Transcode comment to enforce 7-bit ASCII
        string comment = CharEnc::transcode(image.getComment(), CharEnc::UTF_8, CharEnc::US_ASCII);
        Array<JSAMPROW> rowPointers;
        Array<JOCTET> row;

        /*
         * ALERT: No exceptions may arise between this point and the
         * call to jpeg_create_compress below.
         */
        SaveWrapper w;

        /*
         * Handle termination and catch errors occuring in any of the
         * following JPEG-functions.
         */
        if(!setjmp(c.setjmpBuffer)) // try
        {
          w.cinfo.err = &c; // Downcast to jpeg_err_mgr
          jpeg_create_compress(&w.cinfo);
          w.cinfo.dest = &c; // Downcast to jpeg_destination_mgr
          if(tracker) w.cinfo.progress = &c; // Downcast to jpeg_progress_mgr

          // Set header info
          unsigned width  = image.getWidth();
          unsigned height = image.getHeight();
          Image::ComponentSpecifier components = image.getComponentSpecifier();
          bool gray =
            components == Image::components_l ||
            components == Image::components_la;
          w.cinfo.image_width = image.getWidth();
          w.cinfo.image_height = height;
          w.cinfo.input_components = gray ? 1 : 3;
          w.cinfo.in_color_space = gray ? JCS_GRAYSCALE : JCS_RGB;
          jpeg_set_defaults(&w.cinfo);

          jpeg_start_compress(&w.cinfo, 1);

          // Save comment
          jpeg_write_marker(&w.cinfo, JPEG_COM, reinterpret_cast<const JOCTET *>(comment.data()), comment.size());

          if((components == Image::components_l ||
              components == Image::components_rgb) &&
             image.getBitsPerComponent() == 8)
          {
            // Make row array
            JSAMPROW pixelBuffer =
              reinterpret_cast<JSAMPROW>(getPixelBufferNoLeak(image));
            rowPointers.reset(height);
            for(unsigned i=0; i<height; ++i)
              rowPointers[i] = pixelBuffer + (height-i-1)*image.getCharsPerRow();

            while(w.cinfo.next_scanline < height)
              jpeg_write_scanlines(&w.cinfo, rowPointers.get()+w.cinfo.next_scanline, height-w.cinfo.next_scanline);
          }
          else if(gray) // L or LA (luminance)
          {
            row.reset(width);
            JSAMPROW rows[1];
            rows[0] = row.get();
            while(w.cinfo.next_scanline < height)
            {
              int y = height-w.cinfo.next_scanline-1;
              for(unsigned x=0; x<width; ++x)
              {
                unsigned l;
                image.getPixel(x, y, l);
                row[x] = static_cast<JOCTET>(l);
              }
              jpeg_write_scanlines(&w.cinfo, rows, 1);
            }
          }
          else // RGB or RGBA
          {
            row.reset(width*3);
            JSAMPROW rows[1];
            rowPointers[0] = row.get();
            while(w.cinfo.next_scanline < height)
            {
              int y = height-w.cinfo.next_scanline-1;
              for(unsigned x=0; x<width; ++x)
              {
                unsigned r, g, b;
                image.getPixel(x, y, r, g, b);
                int i = x*3;
                row[i]   = static_cast<JOCTET>(r);
                row[i+1] = static_cast<JOCTET>(g);
                row[i+2] = static_cast<JOCTET>(b);
              }
              jpeg_write_scanlines(&w.cinfo, rows, 1);
            }
          }

          jpeg_finish_compress(&w.cinfo);
        }
        else // catch
        {
          switch(c.errorType)
          {
          case 1: throw ThreadTerminatedException(c.errorLocation);
          case 2: throw Stream::ReadException(c.errorLocation, c.errorMessage);
          case 3: throw UnexpectedException(c.errorLocation, c.errorMessage);
          }
          ARCHON_THROW1(Image::InvalidFormatException, c.errorMessage);
        }
      }

    private:

      struct Context: jpeg_progress_mgr, jpeg_error_mgr
      {
        Image::ProgressTracker *tracker;
        Logger *logger;       // For warnings
        jmp_buf setjmpBuffer; // For aborting from the LIBJPEG.
        int errorType;        // 0 for none, 1 for ThreadTerminatedException,
                              // 2 for IOException, 3 for UnexpectedException
                              // from the stream, 4 for libjpeg initiated
                              // error or invalid format detected.
        string errorMessage;  // For fatal errors
        string errorLocation; // Source file location from exception
        Context(Image::ProgressTracker *tracker, Logger *logger):
          tracker(tracker), logger(logger), errorType(0)
        {
          jpeg_std_error(this); // Start by defaulting everything, then
                                // override
          progress_monitor = progressCallback;
          error_exit       = errorCallback;
          output_message   = warningCallback;
        }

        void warning(string message)
        {
          if(logger) logger->log(message);
        }

        static void progressCallback(j_common_ptr cinfo) throw()
        {
          Context *c = static_cast<Context *>(cinfo->progress);
          double p = c->completed_passes +
            static_cast<double>(c->pass_counter)/c->pass_limit;
          c->tracker->progress(p/c->total_passes);
        }

        static void errorCallback(j_common_ptr cinfo) throw()
        {
          Context *c = static_cast<Context *>(cinfo->err);
          {
            char buffer[JMSG_LENGTH_MAX];
            (*cinfo->err->format_message)(cinfo, buffer);
            c->errorType    = 4;
            c->errorMessage = buffer;
          }
          longjmp(c->setjmpBuffer, 1);
        }

        static void warningCallback(j_common_ptr cinfo) throw()
        {
          Context *c = static_cast<Context *>(cinfo->err);
          char buffer[JMSG_LENGTH_MAX];
          (*cinfo->err->format_message)(cinfo, buffer);
          c->warning(buffer);
        }
      };

      static const int bufferSize = 4096;

      struct LoadContext: jpeg_source_mgr, Context
      {
        Array<JOCTET> buffer;
        bool startOfFile;        // have we gotten any data yet?
        Ref<Stream::Reader> reader;
        LoadContext(Ref<Stream::Reader> reader, Image::ProgressTracker *tracker,
                    Logger *logger): Context(tracker, logger), buffer(bufferSize),
                                     startOfFile(true), reader(reader)
        {
          init_source       = initCallback;
          fill_input_buffer = readCallback;
          skip_input_data   = skipCallback;
          resync_to_restart = jpeg_resync_to_restart; // use default method
          term_source       = termCallback;
          bytes_in_buffer   = 0; // forces fill_input_buffer on first read
          next_input_byte   = 0;
        }

        static void initCallback(j_decompress_ptr cinfo) throw() {}

        static int readCallback(j_decompress_ptr cinfo) throw()
        {
          LoadContext *c = static_cast<LoadContext *>(cinfo->src);
          int n = 0;
          try
          {
            n = c->reader->read(reinterpret_cast<char *>(c->buffer.get()),
                                bufferSize);
          }
          catch(ThreadTerminatedException &e)
          {
            c->errorType     = 1;
            c->errorLocation = e.getLocation();
          }
          catch(IOException &e)
          {
            c->errorType     = 2;
            c->errorLocation = e.getLocation();
            c->errorMessage  = e.getMessage();
          }
          catch(UnexpectedException &e)
          {
            c->errorType     = 3;
            c->errorLocation = e.getLocation();
            c->errorMessage  = e.getMessage();
          }

          if(c->errorType == 1 || c->errorType == 2 && c->startOfFile ||
             c->errorType == 3) longjmp(c->setjmpBuffer, 1);

          if(n < 1)
          {
            if(c->startOfFile)
            {
              ERREXIT(cinfo, JERR_INPUT_EMPTY);
            }

            if(c->errorType == 2) c->warning(c->errorMessage);
            else WARNMS(cinfo, JWRN_JPEG_EOF);

            // Insert a fake EOI marker
            c->buffer[0] = static_cast<JOCTET>(0xFF);
            c->buffer[1] = static_cast<JOCTET>(JPEG_EOI);
            n = 2;
          }

          c->next_input_byte = c->buffer.get();
          c->bytes_in_buffer = n;
          c->startOfFile = false;

          return 1;
        }

        static void skipCallback(j_decompress_ptr cinfo, long num_bytes) throw()
        {
          LoadContext *c = static_cast<LoadContext *>(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 > static_cast<long>(c->bytes_in_buffer))
            {
              num_bytes -= static_cast<long>(c->bytes_in_buffer);
              readCallback(cinfo);
              /* note we assume that fill_input_buffer will never return FALSE,
               * so suspension need not be handled.
               */
            }
            c->next_input_byte += static_cast<size_t>(num_bytes);
            c->bytes_in_buffer -= static_cast<size_t>(num_bytes);
          }
        }

        /*
         * From LIBJPEG/example.c:
         *
         * An additional method that can be provided by data source modules is the
         * resync_to_restart method for error recovery in the presence of RST markers.
         * For the moment, this source module just uses the default resync method
         * provided by the JPEG library.  That method assumes that no backtracking
         * is possible.
         */

        static void termCallback(j_decompress_ptr cinfo) throw() {}
      };

      struct SaveContext: jpeg_destination_mgr, Context
      {
        Array<JOCTET> buffer;
        Ref<Stream::Writer> writer;
        SaveContext(Ref<Stream::Writer> writer, Image::ProgressTracker *tracker,
                    Logger *logger):
          Context(tracker, logger), buffer(bufferSize), writer(writer)
        {
          init_destination    = initCallback;
          empty_output_buffer = writeCallback;
          term_destination    = termCallback;
          next_output_byte    = buffer.get();
          free_in_buffer      = bufferSize;
        }

        static void initCallback(j_compress_ptr cinfo) throw() {}

        static int writeCallback(j_compress_ptr cinfo) throw()
        {
          SaveContext *c = static_cast<SaveContext *>(cinfo->dest);

          try
          {
            c->writer->writeAll(reinterpret_cast<const char *>(c->buffer.get()),
                                bufferSize);
            c->next_output_byte = c->buffer.get();
            c->free_in_buffer   = bufferSize;
            return 1;
          }
          catch(ThreadTerminatedException &e)
          {
            c->errorType     = 1;
            c->errorLocation = e.getLocation();
          }
          catch(IOException &e)
          {
            c->errorType     = 2;
            c->errorLocation = e.getLocation();
            c->errorMessage  = e.getMessage();
          }
          catch(UnexpectedException &e)
          {
            c->errorType     = 3;
            c->errorLocation = e.getLocation();
            c->errorMessage  = e.getMessage();
          }

          longjmp(c->setjmpBuffer, 1);
        }

        static void termCallback(j_compress_ptr cinfo) throw()
        {
          SaveContext *c = static_cast<SaveContext *>(cinfo->dest);

          try
          {
            c->writer->writeAll(reinterpret_cast<const char *>(c->buffer.get()),
                                bufferSize - c->free_in_buffer);
            return;
          }
          catch(ThreadTerminatedException &e)
          {
            c->errorType     = 1;
            c->errorLocation = e.getLocation();
          }
          catch(IOException &e)
          {
            c->errorType     = 2;
            c->errorLocation = e.getLocation();
            c->errorMessage  = e.getMessage();
          }
          catch(UnexpectedException &e)
          {
            c->errorType     = 3;
            c->errorLocation = e.getLocation();
            c->errorMessage  = e.getMessage();
          }

          longjmp(c->setjmpBuffer, 1);
        }
      };


      struct LoadWrapper
      {
        jpeg_decompress_struct cinfo;
        ~LoadWrapper()
        {
          cinfo.err = 0;
          cinfo.src = 0;
          jpeg_destroy_decompress(&cinfo);
        }
      };


      struct SaveWrapper
      {
        jpeg_compress_struct cinfo;
        ~SaveWrapper()
        {
          cinfo.err = 0;
          cinfo.dest = 0;
          jpeg_destroy_compress(&cinfo);
        }
      };
    };

    Image::Format *getDefaultJpegFormat()
    {
      static FormatLibjpeg f;
      return &f;
    }
  }
}

---