Changeset 53411 in webkit


Ignore:
Timestamp:
Jan 18, 2010 9:46:39 AM (14 years ago)
Author:
pkasting@chromium.org
Message:

Simplify image decoders slightly by using OwnPtr instead of raw pointers
and eliminating a basically-useless wrapper class in the GIF decoder.
​https://bugs.webkit.org/show_bug.cgi?id=28751

Reviewed by Adam Barth.

  • platform/graphics/qt/ImageDecoderQt.cpp:

(WebCore::ImageDecoderQt::ImageDecoderQt):
(WebCore::ImageDecoderQt::~ImageDecoderQt):
(WebCore::ImageDecoderQt::setData):
(WebCore::ImageDecoderQt::internalReadImage):
(WebCore::ImageDecoderQt::failRead):

  • platform/graphics/qt/ImageDecoderQt.h:
  • platform/image-decoders/gif/GIFImageDecoder.cpp:

(WebCore::GIFImageDecoder::GIFImageDecoder):
(WebCore::GIFImageDecoder::~GIFImageDecoder):
(WebCore::GIFImageDecoder::setData):
(WebCore::GIFImageDecoder::frameCount):
(WebCore::GIFImageDecoder::repetitionCount):
(WebCore::GIFImageDecoder::decode):
(WebCore::GIFImageDecoder::decodingHalted):
(WebCore::GIFImageDecoder::initFrameBuffer):
(WebCore::GIFImageDecoder::haveDecodedRow):
(WebCore::GIFImageDecoder::gifComplete):

  • platform/image-decoders/gif/GIFImageDecoder.h:
  • platform/image-decoders/jpeg/JPEGImageDecoder.cpp:

(WebCore::JPEGImageDecoder::JPEGImageDecoder):
(WebCore::JPEGImageDecoder::~JPEGImageDecoder):
(WebCore::JPEGImageDecoder::setData):
(WebCore::JPEGImageDecoder::decode):

  • platform/image-decoders/jpeg/JPEGImageDecoder.h:
  • platform/image-decoders/png/PNGImageDecoder.cpp:

(WebCore::PNGImageDecoder::PNGImageDecoder):
(WebCore::PNGImageDecoder::~PNGImageDecoder):
(WebCore::PNGImageDecoder::setData):
(WebCore::PNGImageDecoder::decode):
(WebCore::PNGImageDecoder::headerAvailable):
(WebCore::PNGImageDecoder::rowAvailable):

  • platform/image-decoders/png/PNGImageDecoder.h:
Location:
trunk/WebCore
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r53410 r53411  
     12010-01-18  Peter Kasting  <pkasting@google.com>
     2
     3        Reviewed by Adam Barth.
     4
     5        Simplify image decoders slightly by using OwnPtr instead of raw pointers
     6        and eliminating a basically-useless wrapper class in the GIF decoder.
     7        https://bugs.webkit.org/show_bug.cgi?id=28751
     8
     9        * platform/graphics/qt/ImageDecoderQt.cpp:
     10        (WebCore::ImageDecoderQt::ImageDecoderQt):
     11        (WebCore::ImageDecoderQt::~ImageDecoderQt):
     12        (WebCore::ImageDecoderQt::setData):
     13        (WebCore::ImageDecoderQt::internalReadImage):
     14        (WebCore::ImageDecoderQt::failRead):
     15        * platform/graphics/qt/ImageDecoderQt.h:
     16        * platform/image-decoders/gif/GIFImageDecoder.cpp:
     17        (WebCore::GIFImageDecoder::GIFImageDecoder):
     18        (WebCore::GIFImageDecoder::~GIFImageDecoder):
     19        (WebCore::GIFImageDecoder::setData):
     20        (WebCore::GIFImageDecoder::frameCount):
     21        (WebCore::GIFImageDecoder::repetitionCount):
     22        (WebCore::GIFImageDecoder::decode):
     23        (WebCore::GIFImageDecoder::decodingHalted):
     24        (WebCore::GIFImageDecoder::initFrameBuffer):
     25        (WebCore::GIFImageDecoder::haveDecodedRow):
     26        (WebCore::GIFImageDecoder::gifComplete):
     27        * platform/image-decoders/gif/GIFImageDecoder.h:
     28        * platform/image-decoders/jpeg/JPEGImageDecoder.cpp:
     29        (WebCore::JPEGImageDecoder::JPEGImageDecoder):
     30        (WebCore::JPEGImageDecoder::~JPEGImageDecoder):
     31        (WebCore::JPEGImageDecoder::setData):
     32        (WebCore::JPEGImageDecoder::decode):
     33        * platform/image-decoders/jpeg/JPEGImageDecoder.h:
     34        * platform/image-decoders/png/PNGImageDecoder.cpp:
     35        (WebCore::PNGImageDecoder::PNGImageDecoder):
     36        (WebCore::PNGImageDecoder::~PNGImageDecoder):
     37        (WebCore::PNGImageDecoder::setData):
     38        (WebCore::PNGImageDecoder::decode):
     39        (WebCore::PNGImageDecoder::headerAvailable):
     40        (WebCore::PNGImageDecoder::rowAvailable):
     41        * platform/image-decoders/png/PNGImageDecoder.h:
     42
    1432010-01-18  Daniel Cheng  <dcheng@google.com>
    244

  • trunk/WebCore/platform/graphics/qt/ImageDecoderQt.cpp

    r52657 r53411  
    4848
    4949ImageDecoderQt::ImageDecoderQt()
    50     :  m_buffer(0)
    51     , m_reader(0)
    52     , m_repetitionCount(cAnimationNone)
     50    : m_repetitionCount(cAnimationNone)
    5351{
    5452}
    … …  
    5654ImageDecoderQt::~ImageDecoderQt()
    5755{
    58     delete m_reader;
    59     delete m_buffer;
    6056}
    6157
    … …  
    7874    // Attempt to load the data
    7975    QByteArray imageData = QByteArray::fromRawData(m_data->data(), m_data->size());
    80     m_buffer = new QBuffer;
     76    m_buffer.set(new QBuffer);
    8177    m_buffer->setData(imageData);
    8278    m_buffer->open(QBuffer::ReadOnly);
    83     m_reader = new QImageReader(m_buffer, m_format);
     79    m_reader.set(new QImageReader(m_buffer.get(), m_format));
    8480
    8581    // This will force the JPEG decoder to use JDCT_IFAST
    … …  
    184180            return;
    185181
    186     delete m_reader;
    187     delete m_buffer;
    188     m_buffer = 0;
    189     m_reader = 0;
     182    m_reader.clear();
     183    m_buffer.clear();
    190184}
    191185
    … …  
    235229{
    236230    setFailed();
    237     delete m_reader;
    238     delete m_buffer;
    239     m_reader = 0;
    240     m_buffer = 0;
     231    m_reader.clear();
     232    m_buffer.clear();
    241233}
    242234}

  • trunk/WebCore/platform/graphics/qt/ImageDecoderQt.h

    r52657 r53411  
    3434#include <QtCore/QHash>
    3535#include <QtCore/QBuffer>
     36#include <wtf/OwnPtr.h>
    3637
    3738namespace WebCore {
    … …  
    6768private:
    6869    QByteArray m_format;
    69     QBuffer* m_buffer;
    70     QImageReader* m_reader;
     70    OwnPtr<QBuffer> m_buffer;
     71    OwnPtr<QImageReader> m_reader;
    7172    mutable int m_repetitionCount;
    7273};

  • trunk/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp

    r53311 r53411  
    3030namespace WebCore {
    3131
    32 class GIFImageDecoderPrivate {
    33 public:
    34     GIFImageDecoderPrivate(GIFImageDecoder* decoder = 0)
    35         : m_reader(decoder)
    36         , m_readOffset(0)
    37     {
    38     }
    39 
    40     ~GIFImageDecoderPrivate()
    41     {
    42         m_reader.close();
    43     }
    44 
    45     bool decode(SharedBuffer* data,
    46                 GIFImageDecoder::GIFQuery query = GIFImageDecoder::GIFFullQuery,
    47                 unsigned int haltFrame = -1)
    48     {
    49         return m_reader.read((const unsigned char*)data->data() + m_readOffset, data->size() - m_readOffset,
    50                              query,
    51                              haltFrame);
    52     }
    53 
    54     unsigned frameCount() const { return m_reader.images_count; }
    55     int repetitionCount() const { return m_reader.loop_count; }
    56 
    57     void setReadOffset(unsigned o) { m_readOffset = o; }
    58 
    59     bool isTransparent() const { return m_reader.frame_reader->is_transparent; }
    60 
    61     void getColorMap(unsigned char*& map, unsigned& size) const
    62     {
    63         if (m_reader.frame_reader->is_local_colormap_defined) {
    64             map = m_reader.frame_reader->local_colormap;
    65             size = (unsigned)m_reader.frame_reader->local_colormap_size;
    66         } else {
    67             map = m_reader.global_colormap;
    68             size = m_reader.global_colormap_size;
    69         }
    70     }
    71 
    72     unsigned frameXOffset() const { return m_reader.frame_reader->x_offset; }
    73     unsigned frameYOffset() const { return m_reader.frame_reader->y_offset; }
    74     unsigned frameWidth() const { return m_reader.frame_reader->width; }
    75     unsigned frameHeight() const { return m_reader.frame_reader->height; }
    76 
    77     int transparentPixel() const { return m_reader.frame_reader->tpixel; }
    78 
    79     unsigned duration() const { return m_reader.frame_reader->delay_time; }
    80 
    81 private:
    82     GIFImageReader m_reader;
    83     unsigned m_readOffset;
    84 };
    85 
    8632GIFImageDecoder::GIFImageDecoder()
    8733    : m_frameCountValid(true)
    8834    , m_repetitionCount(cAnimationLoopOnce)
    89     , m_reader(0)
     35    , m_readOffset(0)
    9036{
    9137}
    … …  
    9339GIFImageDecoder::~GIFImageDecoder()
    9440{
    95     delete m_reader;
    9641}
    9742
    … …  
    11055    // Create the GIF reader.
    11156    if (!m_reader && !m_failed)
    112         m_reader = new GIFImageDecoderPrivate(this);
     57        m_reader.set(new GIFImageReader(this));
    11358}
    11459
    … …  
    13378        // state, but for now we just crawl all the data.  Note that this is no worse than what
    13479        // ImageIO does on Mac right now (it also crawls all the data again).
    135         GIFImageDecoderPrivate reader;
     80        GIFImageReader reader(0);
    13681        // This function may fail, but we want to keep any partial data it may
    13782        // have decoded, so don't mark it is invalid. If there is an overflow
    13883        // or some serious error, m_failed will have gotten set for us.
    139         reader.decode(m_data.get(), GIFFrameCountQuery);
     84        reader.read((const unsigned char*)m_data->data(), m_data->size(), GIFFrameCountQuery, -1);
    14085        m_frameCountValid = true;
    141         m_frameBufferCache.resize(reader.frameCount());
     86        m_frameBufferCache.resize(reader.images_count);
    14287    }
    14388
    … …  
    162107        // seen a loop count yet; in this case we return our previously-cached
    163108        // value.
    164         const int repetitionCount = m_reader->repetitionCount();
     109        const int repetitionCount = m_reader->loop_count;
    165110        if (repetitionCount != cLoopCountNotSeen)
    166111            m_repetitionCount = repetitionCount;
    … …  
    236181        return;
    237182
    238     m_failed = !m_reader->decode(m_data.get(), query, haltAtFrame);
     183    m_failed = !m_reader->read((const unsigned char*)m_data->data() + m_readOffset, m_data->size() - m_readOffset, query, haltAtFrame);
    239184   
    240     if (m_failed) {
    241         delete m_reader;
    242         m_reader = 0;
    243     }
     185    if (m_failed)
     186        m_reader.clear();
    244187}
    245188
    … …  
    255198void GIFImageDecoder::decodingHalted(unsigned bytesLeft)
    256199{
    257     m_reader->setReadOffset(m_data->size() - bytesLeft);
     200    m_readOffset = m_data->size() - bytesLeft;
    258201}
    259202
    … …  
    261204{
    262205    // Initialize the frame rect in our buffer.
    263     IntRect frameRect(m_reader->frameXOffset(), m_reader->frameYOffset(),
    264                       m_reader->frameWidth(), m_reader->frameHeight());
     206    const GIFFrameReader* frameReader = m_reader->frame_reader;
     207    IntRect frameRect(frameReader->x_offset, frameReader->y_offset, frameReader->width, frameReader->height);
    265208
    266209    // Make sure the frameRect doesn't extend past the bottom-right of the buffer.
    267210    if (frameRect.right() > size().width())
    268         frameRect.setWidth(size().width() - m_reader->frameXOffset());
     211        frameRect.setWidth(size().width() - frameReader->x_offset);
    269212    if (frameRect.bottom() > size().height())
    270         frameRect.setHeight(size().height() - m_reader->frameYOffset());
     213        frameRect.setHeight(size().height() - frameReader->y_offset);
    271214
    272215    RGBA32Buffer* const buffer = &m_frameBufferCache[frameIndex];
    … …  
    347290                                     bool writeTransparentPixels)
    348291{
     292    const GIFFrameReader* frameReader = m_reader->frame_reader;
    349293    // The pixel data and coordinates supplied to us are relative to the frame's
    350294    // origin within the entire image size, i.e.
    351     // (m_reader->frameXOffset(), m_reader->frameYOffset()).  There is no
    352     // guarantee that
    353     // (rowEnd - rowBuffer) == (size().width() - m_reader->frameXOffset()), so
     295    // (frameReader->x_offset, frameReader->y_offset).  There is no guarantee
     296    // that (rowEnd - rowBuffer) == (size().width() - frameReader->x_offset), so
    354297    // we must ensure we don't run off the end of either the source data or the
    355298    // row's X-coordinates.
    356     int xBegin = upperBoundScaledX(m_reader->frameXOffset());
    357     int yBegin = upperBoundScaledY(m_reader->frameYOffset() + rowNumber);
     299    int xBegin = upperBoundScaledX(frameReader->x_offset);
     300    int yBegin = upperBoundScaledY(frameReader->y_offset + rowNumber);
    358301    int xEnd = lowerBoundScaledX(std::min(xBegin + static_cast<int>(rowEnd - rowBuffer), size().width()) - 1, xBegin + 1) + 1;
    359302    int yEnd = lowerBoundScaledY(std::min(yBegin + static_cast<int>(repeatCount), size().height()) - 1, yBegin + 1) + 1;
    … …  
    362305
    363306    // Get the colormap.
     307    const unsigned char* colorMap;
    364308    unsigned colorMapSize;
    365     unsigned char* colorMap;
    366     m_reader->getColorMap(colorMap, colorMapSize);
     309    if (frameReader->is_local_colormap_defined) {
     310        colorMap = frameReader->local_colormap;
     311        colorMapSize = (unsigned)frameReader->local_colormap_size;
     312    } else {
     313        colorMap = m_reader->global_colormap;
     314        colorMapSize = m_reader->global_colormap_size;
     315    }
    367316    if (!colorMap)
    368317        return true;
    … …  
    375324    // Write one row's worth of data into the frame. 
    376325    for (int x = xBegin; x < xEnd; ++x) {
    377         const unsigned char sourceValue = *(rowBuffer + (m_scaled ? m_scaledColumns[x] : x) - m_reader->frameXOffset());
    378         if ((!m_reader->isTransparent() || (sourceValue != m_reader->transparentPixel())) && (sourceValue < colorMapSize)) {
     326        const unsigned char sourceValue = *(rowBuffer + (m_scaled ? m_scaledColumns[x] : x) - frameReader->x_offset);
     327        if ((!frameReader->is_transparent || (sourceValue != frameReader->tpixel)) && (sourceValue < colorMapSize)) {
    379328            const size_t colorIndex = static_cast<size_t>(sourceValue) * 3;
    380329            buffer.setRGBA(x, yBegin, colorMap[colorIndex], colorMap[colorIndex + 1], colorMap[colorIndex + 2], 255);
    … …  
    449398{
    450399    if (m_reader)
    451         m_repetitionCount = m_reader->repetitionCount();
    452     delete m_reader;
    453     m_reader = 0;
     400        m_repetitionCount = m_reader->loop_count;
     401    m_reader.clear();
    454402}
    455403

  • trunk/WebCore/platform/image-decoders/gif/GIFImageDecoder.h

    r52833 r53411  
    2828
    2929#include "ImageDecoder.h"
     30#include <wtf/OwnPtr.h>
     31
     32class GIFImageReader;
    3033
    3134namespace WebCore {
    32 
    33     class GIFImageDecoderPrivate;
    3435
    3536    // This class decodes the GIF image format.
    … …  
    8182        bool m_currentBufferSawAlpha;
    8283        mutable int m_repetitionCount;
    83         GIFImageDecoderPrivate* m_reader;
     84        OwnPtr<GIFImageReader> m_reader;
     85        unsigned m_readOffset;
    8486    };
    8587

  • trunk/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp

    r53309 r53411  
    401401
    402402JPEGImageDecoder::JPEGImageDecoder()
    403 : m_reader(0)
    404 {}
     403{
     404}
    405405
    406406JPEGImageDecoder::~JPEGImageDecoder()
    407407{
    408     delete m_reader;
    409408}
    410409
    … …  
    420419    // Create the JPEG reader.
    421420    if (!m_reader && !m_failed)
    422         m_reader = new JPEGImageReader(this);
     421        m_reader.set(new JPEGImageReader(this));
    423422}
    424423
    … …  
    463462    m_failed = !m_reader->decode(m_data->buffer(), sizeOnly);
    464463
    465     if (m_failed || (!m_frameBufferCache.isEmpty() && m_frameBufferCache[0].status() == RGBA32Buffer::FrameComplete)) {
    466         delete m_reader;
    467         m_reader = 0;
    468     }
     464    if (m_failed || (!m_frameBufferCache.isEmpty() && m_frameBufferCache[0].status() == RGBA32Buffer::FrameComplete))
     465        m_reader.clear();
    469466}
    470467

  • trunk/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.h

    r53309 r53411  
    2929
    3030#include "ImageDecoder.h"
     31#include <wtf/OwnPtr.h>
    3132
    3233namespace WebCore {
    … …  
    5657        void decode(bool sizeOnly = false);
    5758
    58         JPEGImageReader* reader() { return m_reader; }
    59 
    6059        bool outputScanlines();
    6160        void jpegComplete();
    6261
    6362    private:
    64         JPEGImageReader* m_reader;
     63        OwnPtr<JPEGImageReader> m_reader;
    6564    };
    6665

  • trunk/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp

    r53309 r53411  
    151151
    152152PNGImageDecoder::PNGImageDecoder()
    153     : m_reader(0)
    154153{
    155154}
    … …  
    157156PNGImageDecoder::~PNGImageDecoder()
    158157{
    159     delete m_reader;
    160158}
    161159
    … …  
    171169    // Create the PNG reader.
    172170    if (!m_reader && !m_failed)
    173         m_reader = new PNGImageReader(this);
     171        m_reader.set(new PNGImageReader(this));
    174172}
    175173
    … …  
    206204    m_reader->decode(*m_data, sizeOnly);
    207205   
    208     if (m_failed || (!m_frameBufferCache.isEmpty() && m_frameBufferCache[0].status() == RGBA32Buffer::FrameComplete)) {
    209         delete m_reader;
    210         m_reader = 0;
    211     }
     206    if (m_failed || (!m_frameBufferCache.isEmpty() && m_frameBufferCache[0].status() == RGBA32Buffer::FrameComplete))
     207        m_reader.clear();
    212208}
    213209
    … …  
    238234void PNGImageDecoder::headerAvailable()
    239235{
    240     png_structp png = reader()->pngPtr();
    241     png_infop info = reader()->infoPtr();
     236    png_structp png = m_reader->pngPtr();
     237    png_infop info = m_reader->infoPtr();
    242238    png_uint_32 width = png->width;
    243239    png_uint_32 height = png->height;
    … …  
    306302    ASSERT(channels == 3 || channels == 4);
    307303
    308     reader()->setHasAlpha(channels == 4);
    309 
    310     if (reader()->decodingSizeOnly()) {
     304    m_reader->setHasAlpha(channels == 4);
     305
     306    if (m_reader->decodingSizeOnly()) {
    311307        // If we only needed the size, halt the reader.     
    312         reader()->setReadOffset(reader()->currentBufferSize() - png->buffer_size);
     308        m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
    313309        png->buffer_size = 0;
    314310    }
    … …  
    330326    if (buffer.status() == RGBA32Buffer::FrameEmpty) {
    331327        if (!buffer.setSize(scaledSize().width(), scaledSize().height())) {
    332             static_cast<PNGImageDecoder*>(png_get_progressive_ptr(reader()->pngPtr()))->decodingFailed();
    333             longjmp(reader()->pngPtr()->jmpbuf, 1);
     328            static_cast<PNGImageDecoder*>(png_get_progressive_ptr(m_reader->pngPtr()))->decodingFailed();
     329            longjmp(m_reader->pngPtr()->jmpbuf, 1);
    334330            return;
    335331        }
    … …  
    340336        buffer.setRect(IntRect(IntPoint(), size()));
    341337
    342         if (reader()->pngPtr()->interlaced)
    343             reader()->createInterlaceBuffer((reader()->hasAlpha() ? 4 : 3) * size().width() * size().height());
     338        if (m_reader->pngPtr()->interlaced)
     339            m_reader->createInterlaceBuffer((m_reader->hasAlpha() ? 4 : 3) * size().width() * size().height());
    344340    }
    345341
    … …  
    375371    */
    376372
    377     png_structp png = reader()->pngPtr();
    378     bool hasAlpha = reader()->hasAlpha();
     373    png_structp png = m_reader->pngPtr();
     374    bool hasAlpha = m_reader->hasAlpha();
    379375    unsigned colorChannels = hasAlpha ? 4 : 3;
    380376    png_bytep row;
    381     png_bytep interlaceBuffer = reader()->interlaceBuffer();
     377    png_bytep interlaceBuffer = m_reader->interlaceBuffer();
    382378    if (interlaceBuffer) {
    383379        row = interlaceBuffer + (rowIndex * colorChannels * size().width());

  • trunk/WebCore/platform/image-decoders/png/PNGImageDecoder.h

    r44825 r53411  
    2828
    2929#include "ImageDecoder.h"
     30#include <wtf/OwnPtr.h>
    3031
    3132namespace WebCore {
    … …  
    5152        void decode(bool sizeOnly = false);
    5253
    53         PNGImageReader* reader() { return m_reader; }
    54 
    5554        // Callbacks from libpng
    5655        void decodingFailed();
    … …  
    6059
    6160    private:
    62         PNGImageReader* m_reader;
     61        OwnPtr<PNGImageReader> m_reader;
    6362    };
    6463
Note: See TracChangeset for help on using the changeset viewer.