WebCore/platform/image-decoders/skia/JPEGImageDecoder.cpp

   1 /*
   2  * Copyright (C) 2006 Apple Computer, Inc.
   3  *
   4  * Portions are Copyright (C) 2001-6 mozilla.org
   5  *
   6  * Other contributors:
   7  *   Stuart Parmenter <stuart@mozilla.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  * Alternatively, the contents of this file may be used under the terms
  24  * of either the Mozilla Public License Version 1.1, found at
  25  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
  26  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
  27  * (the "GPL"), in which case the provisions of the MPL or the GPL are
  28  * applicable instead of those above.  If you wish to allow use of your
  29  * version of this file only under the terms of one of those two
  30  * licenses (the MPL or the GPL) and not to allow others to use your
  31  * version of this file under the LGPL, indicate your decision by
  32  * deletingthe provisions above and replace them with the notice and
  33  * other provisions required by the MPL or the GPL, as the case may be.
  34  * If you do not delete the provisions above, a recipient may use your
  35  * version of this file under any of the LGPL, the MPL or the GPL.
  36  */
  37
  38 #include "config.h"
  39 #include "JPEGImageDecoder.h"
  40 #include <assert.h>
  41 #include <stdio.h>
  42
  43 #if PLATFORM(CAIRO) || PLATFORM(QT) || PLATFORM(WX)
  44
  45 #if COMPILER(MSVC)
  46 // Remove warnings from warning level 4.
  47 #pragma warning(disable : 4611) // warning C4611: interaction between '_setjmp' and C++ object destruction is non-portable
  48
  49 // if ADDRESS_TAG_BIT is dfined, INT32 has been declared as a typedef in the PlatformSDK (BaseTsd.h),
  50 // so we need to stop jpeglib.h from trying to #define it
  51 // see here for more info: http://www.cygwin.com/ml/cygwin/2004-07/msg01051.html
  52 # if defined(ADDRESS_TAG_BIT) && !defined(XMD_H)
  53 #  define XMD_H
  54 #  define VTK_JPEG_XMD_H
  55 # endif
  56 #endif // COMPILER(MSVC)
  57
  58 extern "C" {
  59 #include "jpeglib.h"
  60 }
  61
  62 #if COMPILER(MSVC)
  63 # if defined(VTK_JPEG_XMD_H)
  64 #  undef VTK_JPEG_XMD_H
  65 #  undef XMD_H
  66 # endif
  67 #endif // COMPILER(MSVC)
  68
  69 #include <setjmp.h>
  70
  71 namespace WebCore {
  72
  73 struct decoder_error_mgr {
  74     struct jpeg_error_mgr pub;  /* "public" fields for IJG library*/
  75     jmp_buf setjmp_buffer;      /* For handling catastropic errors */
  76 };
  77
  78 enum jstate {
  79     JPEG_HEADER,                          /* Reading JFIF headers */
  80     JPEG_START_DECOMPRESS,
  81     JPEG_DECOMPRESS_PROGRESSIVE,          /* Output progressive pixels */
  82     JPEG_DECOMPRESS_SEQUENTIAL,           /* Output sequential pixels */
  83     JPEG_DONE,
  84     JPEG_SINK_NON_JPEG_TRAILER,          /* Some image files have a */
  85                                          /* non-JPEG trailer */
  86     JPEG_ERROR
  87 };
  88
  89 void init_source(j_decompress_ptr jd);
  90 boolean fill_input_buffer(j_decompress_ptr jd);
  91 void skip_input_data(j_decompress_ptr jd, long num_bytes);
  92 void term_source(j_decompress_ptr jd);
  93 void error_exit(j_common_ptr cinfo);
  94
  95 /*
  96  *  Implementation of a JPEG src object that understands our state machine
  97  */
  98 struct decoder_source_mgr {
  99   /* public fields; must be first in this struct! */
 100   struct jpeg_source_mgr pub;
 101
 102   JPEGImageReader *decoder;
 103 };
 104
 105 class JPEGImageReader
 106 {
 107 public:
 108     JPEGImageReader(JPEGImageDecoder* decoder)
 109         : m_decoder(decoder)
 110         , m_bufferLength(0)
 111         , m_bytesToSkip(0)
 112         , m_state(JPEG_HEADER)
 113         , m_samples(0)
 114     {
 115         memset(&m_info, 0, sizeof(jpeg_decompress_struct));
 116
 117         /* We set up the normal JPEG error routines, then override error_exit. */
 118         m_info.err = jpeg_std_error(&m_err.pub);
 119         m_err.pub.error_exit = error_exit;
 120
 121         /* Allocate and initialize JPEG decompression object */
 122         jpeg_create_decompress(&m_info);
 123
 124         decoder_source_mgr* src = 0;
 125         if (!m_info.src) {
 126             src = (decoder_source_mgr*)fastCalloc(sizeof(decoder_source_mgr), 1);
 127             if (!src) {
 128                 m_state = JPEG_ERROR;
 129                 return;
 130             }
 131         }
 132
 133         m_info.src = (jpeg_source_mgr*)src;
 134
 135         /* Set up callback functions. */
 136         src->pub.init_source = init_source;
 137         src->pub.fill_input_buffer = fill_input_buffer;
 138         src->pub.skip_input_data = skip_input_data;
 139         src->pub.resync_to_restart = jpeg_resync_to_restart;
 140         src->pub.term_source = term_source;
 141         src->decoder = this;
 142     }
 143
 144     ~JPEGImageReader()
 145     {
 146         close();
 147     }
 148
 149     void close() {
 150         decoder_source_mgr* src = (decoder_source_mgr*)m_info.src;
 151         if (src)
 152             fastFree(src);
 153         m_info.src = 0;
 154
 155         jpeg_destroy_decompress(&m_info);
 156     }
 157
 158     void skipBytes(long num_bytes) {
 159         decoder_source_mgr* src = (decoder_source_mgr*)m_info.src;
 160         long bytesToSkip = std::min(num_bytes, (long)src->pub.bytes_in_buffer);
 161         src->pub.bytes_in_buffer -= (size_t)bytesToSkip;
 162         src->pub.next_input_byte += bytesToSkip;
 163
 164         if (num_bytes > bytesToSkip)
 165             m_bytesToSkip = (size_t)(num_bytes - bytesToSkip);
 166         else
 167             m_bytesToSkip = 0;
 168     }
 169
 170     bool decode(const Vector<char>& data, bool sizeOnly) {
 171         m_decodingSizeOnly = sizeOnly;
 172
 173         unsigned newByteCount = data.size() - m_bufferLength;
 174         unsigned readOffset = m_bufferLength - m_info.src->bytes_in_buffer;
 175
 176         m_info.src->bytes_in_buffer += newByteCount;
 177         m_info.src->next_input_byte = (JOCTET*)(data.data()) + readOffset;
 178
 179         // If we still have bytes to skip, try to skip those now.
 180         if (m_bytesToSkip)
 181             skipBytes(m_bytesToSkip);
 182
 183         m_bufferLength = data.size();
 184
 185         // We need to do the setjmp here. Otherwise bad things will happen
 186         if (setjmp(m_err.setjmp_buffer)) {
 187             m_state = JPEG_SINK_NON_JPEG_TRAILER;
 188             close();
 189             return false;
 190         }
 191
 192         switch (m_state) {
 193             case JPEG_HEADER:
 194             {
 195                 /* Read file parameters with jpeg_read_header() */
 196                 if (jpeg_read_header(&m_info, true) == JPEG_SUSPENDED)
 197                     return true; /* I/O suspension */
 198
 199                 /* let libjpeg take care of gray->RGB and YCbCr->RGB conversions */
 200                 switch (m_info.jpeg_color_space) {
 201                     case JCS_GRAYSCALE:
 202                     case JCS_RGB:
 203                     case JCS_YCbCr:
 204                         m_info.out_color_space = JCS_RGB;
 205                         break;
 206                     case JCS_CMYK:
 207                     case JCS_YCCK:
 208                     default:
 209                         m_state = JPEG_ERROR;
 210                         return false;
 211                 }
 212
 213                 /*
 214                  * Don't allocate a giant and superfluous memory buffer
 215                  * when the image is a sequential JPEG.
 216                  */
 217                 m_info.buffered_image = jpeg_has_multiple_scans(&m_info);
 218
 219                 /* Used to set up image size so arrays can be allocated */
 220                 jpeg_calc_output_dimensions(&m_info);
 221
 222                 /*
 223                  * Make a one-row-high sample array that will go away
 224                  * when done with image. Always make it big enough to
 225                  * hold an RGB row.  Since this uses the IJG memory
 226                  * manager, it must be allocated before the call to
 227                  * jpeg_start_compress().
 228                  */
 229                 int row_stride = m_info.output_width * 4; // RGBA buffer
 230
 231
 232                 m_samples = (*m_info.mem->alloc_sarray)((j_common_ptr) &m_info,
 233                                            JPOOL_IMAGE,
 234                                            row_stride, 1);
 235
 236                 m_state = JPEG_START_DECOMPRESS;
 237
 238                 // We can fill in the size now that the header is available.
 239                 m_decoder->setSize(m_info.image_width, m_info.image_height);
 240
 241                 if (m_decodingSizeOnly) {
 242                     // We can stop here.
 243                     // Reduce our buffer length and available data.
 244                     m_bufferLength -= m_info.src->bytes_in_buffer;
 245                     m_info.src->bytes_in_buffer = 0;
 246                     return true;
 247                 }
 248             }
 249
 250             case JPEG_START_DECOMPRESS:
 251             {
 252                 /* Set parameters for decompression */
 253                 /* FIXME -- Should reset dct_method and dither mode
 254                  * for final pass of progressive JPEG
 255                  */
 256                 m_info.dct_method =  JDCT_ISLOW;
 257                 m_info.dither_mode = JDITHER_FS;
 258                 m_info.do_fancy_upsampling = true;
 259                 m_info.enable_2pass_quant = false;
 260                 m_info.do_block_smoothing = true;
 261
 262                 /* Start decompressor */
 263                 if (!jpeg_start_decompress(&m_info))
 264                     return true; /* I/O suspension */
 265
 266                 /* If this is a progressive JPEG ... */
 267                 m_state = (m_info.buffered_image) ? JPEG_DECOMPRESS_PROGRESSIVE : JPEG_DECOMPRESS_SEQUENTIAL;
 268             }
 269
 270             case JPEG_DECOMPRESS_SEQUENTIAL:
 271             {
 272                 if (m_state == JPEG_DECOMPRESS_SEQUENTIAL) {
 273
 274                     if (!m_decoder->outputScanlines())
 275                         return true; /* I/O suspension */
 276
 277                     /* If we've completed image output ... */
 278                     assert(m_info.output_scanline == m_info.output_height);
 279                     m_state = JPEG_DONE;
 280                 }
 281             }
 282
 283             case JPEG_DECOMPRESS_PROGRESSIVE:
 284             {
 285                 if (m_state == JPEG_DECOMPRESS_PROGRESSIVE) {
 286                     int status;
 287                     do {
 288                         status = jpeg_consume_input(&m_info);
 289                     } while ((status != JPEG_SUSPENDED) &&
 290                              (status != JPEG_REACHED_EOI));
 291
 292                     for (;;) {
 293                         if (m_info.output_scanline == 0) {
 294                             int scan = m_info.input_scan_number;
 295
 296                             /* if we haven't displayed anything yet (output_scan_number==0)
 297                             and we have enough data for a complete scan, force output
 298                             of the last full scan */
 299                             if ((m_info.output_scan_number == 0) &&
 300                                 (scan > 1) &&
 301                                 (status != JPEG_REACHED_EOI))
 302                                 scan--;
 303
 304                             if (!jpeg_start_output(&m_info, scan))
 305                                 return true; /* I/O suspension */
 306                         }
 307
 308                         if (m_info.output_scanline == 0xffffff)
 309                             m_info.output_scanline = 0;
 310
 311                         if (!m_decoder->outputScanlines()) {
 312                             if (m_info.output_scanline == 0)
 313                                 /* didn't manage to read any lines - flag so we don't call
 314                                 jpeg_start_output() multiple times for the same scan */
 315                                 m_info.output_scanline = 0xffffff;
 316                             return true; /* I/O suspension */
 317                         }
 318
 319                         if (m_info.output_scanline == m_info.output_height) {
 320                             if (!jpeg_finish_output(&m_info))
 321                                 return true; /* I/O suspension */
 322
 323                             if (jpeg_input_complete(&m_info) &&
 324                                 (m_info.input_scan_number == m_info.output_scan_number))
 325                                 break;
 326
 327                             m_info.output_scanline = 0;
 328                         }
 329                     }
 330
 331                     m_state = JPEG_DONE;
 332                 }
 333             }
 334
 335             case JPEG_DONE:
 336             {
 337                 /* Finish decompression */
 338                 if (!jpeg_finish_decompress(&m_info))
 339                     return true; /* I/O suspension */
 340
 341                 m_state = JPEG_SINK_NON_JPEG_TRAILER;
 342
 343                 /* we're done */
 344                 break;
 345             }
 346
 347             case JPEG_SINK_NON_JPEG_TRAILER:
 348                 break;
 349
 350             case JPEG_ERROR:
 351                 break;
 352         }
 353
 354         return true;
 355     }
 356
 357     jpeg_decompress_struct* info() { return &m_info; }
 358     JSAMPARRAY samples() const { return m_samples; }
 359     JPEGImageDecoder* decoder() { return m_decoder; }
 360
 361 private:
 362     JPEGImageDecoder* m_decoder;
 363     unsigned m_bufferLength;
 364     int m_bytesToSkip;
 365     bool m_decodingSizeOnly;
 366     bool m_initialized;
 367
 368     jpeg_decompress_struct m_info;
 369     decoder_error_mgr m_err;
 370     jstate m_state;
 371
 372     JSAMPARRAY m_samples;
 373 };
 374
 375 /* Override the standard error method in the IJG JPEG decoder code. */
 376 void error_exit(j_common_ptr cinfo)
 377 {
 378     /* Return control to the setjmp point. */
 379     decoder_error_mgr *err = (decoder_error_mgr *) cinfo->err;
 380     longjmp(err->setjmp_buffer, -1);
 381 }
 382
 383 void init_source(j_decompress_ptr jd)
 384 {
 385 }
 386
 387 void skip_input_data(j_decompress_ptr jd, long num_bytes)
 388 {
 389     decoder_source_mgr *src = (decoder_source_mgr *)jd->src;
 390     src->decoder->skipBytes(num_bytes);
 391 }
 392
 393 boolean fill_input_buffer(j_decompress_ptr jd)
 394 {
 395     // Our decode step always sets things up properly, so if this method is ever
 396     // called, then we have hit the end of the buffer.  A return value of FALSE indicates
 397     // that we have no data to supply yet.
 398     return false;
 399 }
 400
 401 void term_source (j_decompress_ptr jd)
 402 {
 403     decoder_source_mgr *src = (decoder_source_mgr *)jd->src;
 404     src->decoder->decoder()->jpegComplete();
 405 }
 406
 407 JPEGImageDecoder::JPEGImageDecoder()
 408 : m_reader(0)
 409 {}
 410
 411 JPEGImageDecoder::~JPEGImageDecoder()
 412 {
 413     delete m_reader;
 414 }
 415
 416 // Take the data and store it.
 417 void JPEGImageDecoder::setData(SharedBuffer* data, bool allDataReceived)
 418 {
 419     if (m_failed)
 420         return;
 421
 422     // Cache our new data.
 423     ImageDecoder::setData(data, allDataReceived);
 424
 425     // Create the JPEG reader.
 426     if (!m_reader && !m_failed)
 427         m_reader = new JPEGImageReader(this);
 428 }
 429
 430 // Whether or not the size information has been decoded yet.
 431 bool JPEGImageDecoder::isSizeAvailable() const
 432 {
 433     // If we have pending data to decode, send it to the JPEG reader now.
 434     if (!m_sizeAvailable && m_reader) {
 435         if (m_failed)
 436             return false;
 437
 438         // The decoder will go ahead and aggressively consume everything up until the
 439         // size is encountered.
 440         decode(true);
 441     }
 442
 443     return m_sizeAvailable;
 444 }
 445
 446 RGBA32Buffer* JPEGImageDecoder::frameBufferAtIndex(size_t index)
 447 {
 448     if (index)
 449         return 0;
 450
 451     if (m_frameBufferCache.isEmpty())
 452         m_frameBufferCache.resize(1);
 453
 454     RGBA32Buffer& frame = m_frameBufferCache[0];
 455     if (frame.status() != RGBA32Buffer::FrameComplete && m_reader)
 456         // Decode this frame.
 457         decode();
 458     return &frame;
 459 }
 460
 461 // Feed data to the JPEG reader.
 462 void JPEGImageDecoder::decode(bool sizeOnly) const
 463 {
 464     if (m_failed)
 465         return;
 466
 467     m_failed = !m_reader->decode(m_data->buffer(), sizeOnly);
 468
 469     if (m_failed || (!m_frameBufferCache.isEmpty() && m_frameBufferCache[0].status() == RGBA32Buffer::FrameComplete)) {
 470         delete m_reader;
 471         m_reader = 0;
 472     }
 473 }
 474
 475 bool JPEGImageDecoder::outputScanlines()
 476 {
 477     if (m_frameBufferCache.isEmpty())
 478         return false;
 479
 480     // Resize to the width and height of the image.
 481     RGBA32Buffer& buffer = m_frameBufferCache[0];
 482     if (buffer.status() == RGBA32Buffer::FrameEmpty) {
 483         // Let's resize our buffer now to the correct width/height.
 484         RGBA32Array& bytes = buffer.bytes();
 485         bytes.resize(m_size.width() * m_size.height());
 486
 487         // Update our status to be partially complete.
 488         buffer.setStatus(RGBA32Buffer::FramePartial);
 489
 490         // For JPEGs, the frame always fills the entire image.
 491         buffer.setRect(IntRect(0, 0, m_size.width(), m_size.height()));
 492
 493         // We don't have alpha (this is the default when the buffer is constructed).
 494     }
 495
 496     jpeg_decompress_struct* info = m_reader->info();
 497     JSAMPARRAY samples = m_reader->samples();
 498
 499     unsigned* dst = buffer.bytes().data() + info->output_scanline * m_size.width();
 500
 501     while (info->output_scanline < info->output_height) {
 502         /* Request one scanline.  Returns 0 or 1 scanlines. */
 503         if (jpeg_read_scanlines(info, samples, 1) != 1)
 504             return false;
 505         JSAMPLE *j1 = samples[0];
 506         for (unsigned i = 0; i < info->output_width; ++i) {
 507             unsigned r = *j1++;
 508             unsigned g = *j1++;
 509             unsigned b = *j1++;
 510             RGBA32Buffer::setRGBA(*dst++, r, g, b, 0xFF);
 511         }
 512
 513         buffer.ensureHeight(info->output_scanline);
 514     }
 515
 516     return true;
 517 }
 518
 519 void JPEGImageDecoder::jpegComplete()
 520 {
 521     if (m_frameBufferCache.isEmpty())
 522         return;
 523
 524     // Hand back an appropriately sized buffer, even if the image ended up being empty.
 525     RGBA32Buffer& buffer = m_frameBufferCache[0];
 526     buffer.setStatus(RGBA32Buffer::FrameComplete);
 527 }
 528
 529 }
 530
 531 #endif // PLATFORM(CAIRO)