1/*
2 * Copyright (C) 2006 Friedemann Kleint <fkleint@trolltech.com>
3 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
4 *
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
20 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
24 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include "config.h"
30#include "ImageDecoderQt.h"
31
32#include <QtCore/QByteArray>
33#include <QtCore/QBuffer>
34
35#include <QtGui/QImageReader>
36#include <qdebug.h>
37
38namespace WebCore {
39
40ImageDecoder* ImageDecoder::create(const SharedBuffer& data, ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
41{
42    // We need at least 4 bytes to figure out what kind of image we're dealing with.
43    if (data.size() < 4)
44        return 0;
45
46    return new ImageDecoderQt(alphaOption, gammaAndColorProfileOption);
47}
48
49ImageDecoderQt::ImageDecoderQt(ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
50    : ImageDecoder(alphaOption, gammaAndColorProfileOption)
51    , m_repetitionCount(cAnimationNone)
52{
53}
54
55ImageDecoderQt::~ImageDecoderQt()
56{
57}
58
59void ImageDecoderQt::setData(SharedBuffer* data, bool allDataReceived)
60{
61    if (failed())
62        return;
63
64    // No progressive loading possible
65    if (!allDataReceived)
66        return;
67
68    // Cache our own new data.
69    ImageDecoder::setData(data, allDataReceived);
70
71    // We expect to be only called once with allDataReceived
72    ASSERT(!m_buffer);
73    ASSERT(!m_reader);
74
75    // Attempt to load the data
76    QByteArray imageData = QByteArray::fromRawData(m_data->data(), m_data->size());
77    m_buffer.set(new QBuffer);
78    m_buffer->setData(imageData);
79    m_buffer->open(QIODevice::ReadOnly | QIODevice::Unbuffered);
80    m_reader.set(new QImageReader(m_buffer.get(), m_format));
81
82    // This will force the JPEG decoder to use JDCT_IFAST
83    m_reader->setQuality(49);
84
85    // QImageReader only allows retrieving the format before reading the image
86    m_format = m_reader->format();
87}
88
89bool ImageDecoderQt::isSizeAvailable()
90{
91    if (!ImageDecoder::isSizeAvailable() && m_reader)
92        internalDecodeSize();
93
94    return ImageDecoder::isSizeAvailable();
95}
96
97size_t ImageDecoderQt::frameCount()
98{
99    if (m_frameBufferCache.isEmpty() && m_reader) {
100        if (m_reader->supportsAnimation()) {
101            int imageCount = m_reader->imageCount();
102
103            // Fixup for Qt decoders... imageCount() is wrong
104            // and jumpToNextImage does not work either... so
105            // we will have to parse everything...
106            if (!imageCount)
107                forceLoadEverything();
108            else {
109                m_frameBufferCache.resize(imageCount);
110                for (size_t i = 0; i < m_frameBufferCache.size(); ++i)
111                    m_frameBufferCache[i].setPremultiplyAlpha(m_premultiplyAlpha);
112            }
113        } else {
114            m_frameBufferCache.resize(1);
115            m_frameBufferCache[0].setPremultiplyAlpha(m_premultiplyAlpha);
116        }
117    }
118
119    return m_frameBufferCache.size();
120}
121
122int ImageDecoderQt::repetitionCount() const
123{
124    if (m_reader && m_reader->supportsAnimation())
125        m_repetitionCount = m_reader->loopCount();
126    return m_repetitionCount;
127}
128
129String ImageDecoderQt::filenameExtension() const
130{
131    return String(m_format.constData(), m_format.length());
132};
133
134ImageFrame* ImageDecoderQt::frameBufferAtIndex(size_t index)
135{
136    // In case the ImageDecoderQt got recreated we don't know
137    // yet how many images we are going to have and need to
138    // find that out now.
139    size_t count = m_frameBufferCache.size();
140    if (!failed() && !count) {
141        internalDecodeSize();
142        count = frameCount();
143    }
144
145    if (index >= count)
146        return 0;
147
148    ImageFrame& frame = m_frameBufferCache[index];
149    if (frame.status() != ImageFrame::FrameComplete && m_reader)
150        internalReadImage(index);
151    return &frame;
152}
153
154void ImageDecoderQt::clearFrameBufferCache(size_t /*index*/)
155{
156}
157
158void ImageDecoderQt::internalDecodeSize()
159{
160    ASSERT(m_reader);
161
162    // If we have a QSize() something failed
163    QSize size = m_reader->size();
164    if (size.isEmpty()) {
165        setFailed();
166        return clearPointers();
167    }
168
169    setSize(size.width(), size.height());
170}
171
172void ImageDecoderQt::internalReadImage(size_t frameIndex)
173{
174    ASSERT(m_reader);
175
176    if (m_reader->supportsAnimation())
177        m_reader->jumpToImage(frameIndex);
178    else if (frameIndex) {
179        setFailed();
180        return clearPointers();
181    }
182
183    if (!internalHandleCurrentImage(frameIndex))
184      setFailed();
185
186    // Attempt to return some memory
187    for (int i = 0; i < m_frameBufferCache.size(); ++i) {
188        if (m_frameBufferCache[i].status() != ImageFrame::FrameComplete)
189            return;
190    }
191
192    clearPointers();
193}
194
195bool ImageDecoderQt::internalHandleCurrentImage(size_t frameIndex)
196{
197    QPixmap pixmap = QPixmap::fromImageReader(m_reader.get());
198
199    if (pixmap.isNull()) {
200        frameCount();
201        repetitionCount();
202        clearPointers();
203        return false;
204    }
205
206    // now into the ImageFrame - even if the image is not
207    ImageFrame* const buffer = &m_frameBufferCache[frameIndex];
208    buffer->setOriginalFrameRect(m_reader->currentImageRect());
209    buffer->setStatus(ImageFrame::FrameComplete);
210    buffer->setDuration(m_reader->nextImageDelay());
211    buffer->setPixmap(pixmap);
212    return true;
213}
214
215// The QImageIOHandler is not able to tell us how many frames
216// we have and we need to parse every image. We do this by
217// increasing the m_frameBufferCache by one and try to parse
218// the image. We stop when QImage::read fails and then need
219// to resize the m_frameBufferCache to the final size and update
220// the failed bit. If we failed to decode the first image
221// then we truly failed to decode, otherwise we're OK.
222
223// TODO: Do not increment the m_frameBufferCache.size() by one but more than one
224void ImageDecoderQt::forceLoadEverything()
225{
226    int imageCount = 0;
227
228    do {
229        m_frameBufferCache.resize(++imageCount);
230    } while (internalHandleCurrentImage(imageCount - 1));
231
232    // If we failed decoding the first image we actually
233    // have no images and need to set the failed bit.
234    // Otherwise, we want to forget about
235    // the last attempt to decode a image.
236    m_frameBufferCache.resize(imageCount - 1);
237    for (size_t i = 0; i < m_frameBufferCache.size(); ++i)
238        m_frameBufferCache[i].setPremultiplyAlpha(m_premultiplyAlpha);
239    if (imageCount == 1)
240      setFailed();
241}
242
243void ImageDecoderQt::clearPointers()
244{
245    m_reader.clear();
246    m_buffer.clear();
247}
248}
249
250// vim: ts=4 sw=4 et
251