source/graphics/jpeg/jpegloader.cpp

   1 #include <stdio.h>
   2 #include <setjmp.h>
   3 #include <jpeglib.h>
   4 #include "jpegloader.h"
   5
   6 using namespace std;
   7
   8 namespace {
   9
  10 struct ErrorManager: jpeg_error_mgr
  11 {
  12         jmp_buf jmp;
  13         string message;
  14 };
  15
  16 void error_exit(j_common_ptr jpeg)
  17 {
  18         ErrorManager *err = reinterpret_cast<ErrorManager *>(jpeg->err);
  19         char buf[JMSG_LENGTH_MAX];
  20         err->format_message(jpeg, buf);
  21         err->message = buf;
  22         longjmp(err->jmp, 1);
  23 }
  24
  25 void emit_message(j_common_ptr, int)
  26 {
  27 }
  28
  29
  30 struct SourceManager: jpeg_source_mgr
  31 {
  32         Msp::IO::Seekable *io;
  33         JOCTET buffer[4096];
  34 };
  35
  36 void init_source(j_decompress_ptr jpeg)
  37 {
  38         SourceManager *src = reinterpret_cast<SourceManager *>(jpeg->src);
  39         src->next_input_byte = src->buffer;
  40         src->bytes_in_buffer = 0;
  41 }
  42
  43 int fill_input_buffer(j_decompress_ptr jpeg)
  44 {
  45         SourceManager *src = reinterpret_cast<SourceManager *>(jpeg->src);
  46         src->next_input_byte = src->buffer;
  47         src->bytes_in_buffer = src->io->read(reinterpret_cast<char *>(src->buffer), sizeof(src->buffer));
  48         return true;
  49 }
  50
  51 void skip_input_data(j_decompress_ptr jpeg, long count)
  52 {
  53         if(count<=0)
  54                 return;
  55
  56         SourceManager *src = reinterpret_cast<SourceManager *>(jpeg->src);
  57         if(static_cast<unsigned long>(count)<src->bytes_in_buffer)
  58         {
  59                 src->next_input_byte += count;
  60                 src->bytes_in_buffer -= count;
  61         }
  62         else
  63         {
  64                 src->io->seek(count-src->bytes_in_buffer, Msp::IO::S_CUR);
  65                 src->bytes_in_buffer = 0;
  66         }
  67 }
  68
  69 void term_source(j_decompress_ptr)
  70 {
  71 }
  72
  73 } // namespace
  74
  75
  76 namespace Msp {
  77 namespace Graphics {
  78
  79 struct JpegLoader::Private
  80 {
  81         jpeg_decompress_struct jpeg;
  82         ErrorManager err_mgr;
  83         SourceManager src_mgr;
  84 };
  85
  86
  87 ImageLoader::Register<JpegLoader> JpegLoader::reg;
  88
  89 JpegLoader::JpegLoader(IO::Seekable &io):
  90         priv(new Private)
  91 {
  92         priv->jpeg.err = jpeg_std_error(&priv->err_mgr);
  93         priv->err_mgr.error_exit = &error_exit;
  94         priv->err_mgr.emit_message = &emit_message;
  95
  96         jpeg_create_decompress(&priv->jpeg);
  97
  98         priv->jpeg.src = &priv->src_mgr;
  99         priv->src_mgr.init_source = &init_source;
 100         priv->src_mgr.fill_input_buffer = &fill_input_buffer;
 101         priv->src_mgr.skip_input_data = &skip_input_data;
 102         priv->src_mgr.resync_to_restart = &jpeg_resync_to_restart;
 103         priv->src_mgr.term_source = &term_source;
 104         priv->src_mgr.io = &io;
 105 }
 106
 107 JpegLoader::~JpegLoader()
 108 {
 109         jpeg_destroy_decompress(&priv->jpeg);
 110         delete priv;
 111 }
 112
 113 bool JpegLoader::detect(const string &sig)
 114 {
 115         static const char jpeg_sig[] = "\xFF\xD8\xFF";
 116         if(sig.size()<sizeof(jpeg_sig))
 117                 return false;
 118         return !sig.compare(0, 3, jpeg_sig);
 119 }
 120
 121 void JpegLoader::load(Image::Data &data)
 122 {
 123         if(setjmp(priv->err_mgr.jmp))
 124                 throw bad_image_data(priv->err_mgr.message);
 125
 126         jpeg_read_header(&priv->jpeg, true);
 127         priv->jpeg.out_color_space = JCS_RGB;
 128         jpeg_start_decompress(&priv->jpeg);
 129
 130         data.width = priv->jpeg.output_width;
 131         data.height = priv->jpeg.output_height;
 132         data.stride = priv->jpeg.output_width*priv->jpeg.output_components;
 133         data.fmt = RGB;
 134
 135         data.data = new char[data.stride*data.height];
 136         JSAMPROW rows[8];
 137         while(priv->jpeg.output_scanline<data.height)
 138         {
 139                 unsigned y = data.height-priv->jpeg.output_scanline;
 140                 unsigned count = min(y, 8U);
 141                 for(unsigned i=0; i<count; ++i)
 142                         rows[i] = reinterpret_cast<JSAMPROW>(data.data+(y-i-1)*data.stride);
 143                 jpeg_read_scanlines(&priv->jpeg, rows, count);
 144         }
 145
 146         jpeg_finish_decompress(&priv->jpeg);
 147 }
 148
 149 } // namespace Graphics
 150 } // namespace Msp