Change hasAlpha to isKnownToBeOpaque and correct the return value for SVG images.
[WebKit-https.git] / Source / WebCore / platform / graphics / BitmapImage.cpp
1 /*
2  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
3  * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "BitmapImage.h"
29
30 #include "FloatRect.h"
31 #include "ImageObserver.h"
32 #include "IntRect.h"
33 #include "MIMETypeRegistry.h"
34 #include "PlatformMemoryInstrumentation.h"
35 #include "Timer.h"
36 #include <wtf/CurrentTime.h>
37 #include <wtf/MemoryInstrumentationVector.h>
38 #include <wtf/MemoryObjectInfo.h>
39 #include <wtf/Vector.h>
40 #include <wtf/text/WTFString.h>
41
42 namespace WebCore {
43
44 BitmapImage::BitmapImage(ImageObserver* observer)
45     : Image(observer)
46     , m_currentFrame(0)
47     , m_frames(0)
48     , m_frameTimer(0)
49     , m_repetitionCount(cAnimationNone)
50     , m_repetitionCountStatus(Unknown)
51     , m_repetitionsComplete(0)
52     , m_desiredFrameStartTime(0)
53     , m_decodedSize(0)
54     , m_decodedPropertiesSize(0)
55     , m_frameCount(0)
56     , m_isSolidColor(false)
57     , m_checkedForSolidColor(false)
58     , m_animationFinished(false)
59     , m_allDataReceived(false)
60     , m_haveSize(false)
61     , m_sizeAvailable(false)
62     , m_hasUniformFrameSize(true)
63     , m_haveFrameCount(false)
64 {
65 }
66
67 BitmapImage::~BitmapImage()
68 {
69     invalidatePlatformData();
70     stopAnimation();
71 }
72
73 bool BitmapImage::isBitmapImage() const
74 {
75     return true;
76 }
77
78 bool BitmapImage::hasSingleSecurityOrigin() const
79 {
80     return true;
81 }
82
83
84 void BitmapImage::destroyDecodedData(bool destroyAll)
85 {
86     unsigned frameBytesCleared = 0;
87     const size_t clearBeforeFrame = destroyAll ? m_frames.size() : m_currentFrame;
88     for (size_t i = 0; i < clearBeforeFrame; ++i) {
89         // The underlying frame isn't actually changing (we're just trying to
90         // save the memory for the framebuffer data), so we don't need to clear
91         // the metadata.
92         unsigned frameBytes = m_frames[i].m_frameBytes;
93         if (m_frames[i].clear(false))
94             frameBytesCleared += frameBytes;
95     }
96
97     destroyMetadataAndNotify(frameBytesCleared);
98
99     m_source.clear(destroyAll, clearBeforeFrame, data(), m_allDataReceived);
100     return;
101 }
102
103 void BitmapImage::destroyDecodedDataIfNecessary(bool destroyAll)
104 {
105     // Animated images >5MB are considered large enough that we'll only hang on
106     // to one frame at a time.
107     static const unsigned cLargeAnimationCutoff = 5242880;
108     unsigned allFrameBytes = 0;
109     for (size_t i = 0; i < m_frames.size(); ++i)
110         allFrameBytes += m_frames[i].m_frameBytes;
111
112     if (allFrameBytes > cLargeAnimationCutoff)
113         destroyDecodedData(destroyAll);
114 }
115
116 void BitmapImage::destroyMetadataAndNotify(unsigned frameBytesCleared)
117 {
118     m_isSolidColor = false;
119     m_checkedForSolidColor = false;
120     invalidatePlatformData();
121
122     ASSERT(m_decodedSize >= frameBytesCleared);
123     m_decodedSize -= frameBytesCleared;
124     if (frameBytesCleared > 0) {
125         frameBytesCleared += m_decodedPropertiesSize;
126         m_decodedPropertiesSize = 0;
127     }
128     if (frameBytesCleared && imageObserver())
129         imageObserver()->decodedSizeChanged(this, -safeCast<int>(frameBytesCleared));
130 }
131
132 void BitmapImage::cacheFrame(size_t index)
133 {
134     size_t numFrames = frameCount();
135     ASSERT(m_decodedSize == 0 || numFrames > 1);
136     
137     if (m_frames.size() < numFrames)
138         m_frames.grow(numFrames);
139
140     m_frames[index].m_frame = m_source.createFrameAtIndex(index);
141     if (numFrames == 1 && m_frames[index].m_frame)
142         checkForSolidColor();
143
144     m_frames[index].m_orientation = m_source.orientationAtIndex(index);
145     m_frames[index].m_haveMetadata = true;
146     m_frames[index].m_isComplete = m_source.frameIsCompleteAtIndex(index);
147     if (repetitionCount(false) != cAnimationNone)
148         m_frames[index].m_duration = m_source.frameDurationAtIndex(index);
149     m_frames[index].m_hasAlpha = m_source.frameHasAlphaAtIndex(index);
150     m_frames[index].m_frameBytes = m_source.frameBytesAtIndex(index);
151
152     const IntSize frameSize(index ? m_source.frameSizeAtIndex(index) : m_size);
153     if (frameSize != m_size)
154         m_hasUniformFrameSize = false;
155     if (m_frames[index].m_frame) {
156         int deltaBytes = safeCast<int>(m_frames[index].m_frameBytes);
157         m_decodedSize += deltaBytes;
158         // The fully-decoded frame will subsume the partially decoded data used
159         // to determine image properties.
160         deltaBytes -= m_decodedPropertiesSize;
161         m_decodedPropertiesSize = 0;
162         if (imageObserver())
163             imageObserver()->decodedSizeChanged(this, deltaBytes);
164     }
165 }
166
167 void BitmapImage::didDecodeProperties() const
168 {
169     if (m_decodedSize)
170         return;
171     size_t updatedSize = m_source.bytesDecodedToDetermineProperties();
172     if (m_decodedPropertiesSize == updatedSize)
173         return;
174     int deltaBytes = updatedSize - m_decodedPropertiesSize;
175 #if !ASSERT_DISABLED
176     bool overflow = updatedSize > m_decodedPropertiesSize && deltaBytes < 0;
177     bool underflow = updatedSize < m_decodedPropertiesSize && deltaBytes > 0;
178     ASSERT(!overflow && !underflow);
179 #endif
180     m_decodedPropertiesSize = updatedSize;
181     if (imageObserver())
182         imageObserver()->decodedSizeChanged(this, deltaBytes);
183 }
184
185 void BitmapImage::updateSize() const
186 {
187     if (!m_sizeAvailable || m_haveSize)
188         return;
189
190     m_size = m_source.size();
191     m_sizeRespectingOrientation = m_source.size(RespectImageOrientation);
192     m_haveSize = true;
193     didDecodeProperties();
194 }
195
196 IntSize BitmapImage::size() const
197 {
198     updateSize();
199     return m_size;
200 }
201
202 IntSize BitmapImage::sizeRespectingOrientation() const
203 {
204     updateSize();
205     return m_sizeRespectingOrientation;
206 }
207
208 IntSize BitmapImage::currentFrameSize() const
209 {
210     if (!m_currentFrame || m_hasUniformFrameSize)
211         return size();
212     IntSize frameSize = m_source.frameSizeAtIndex(m_currentFrame);
213     didDecodeProperties();
214     return frameSize;
215 }
216
217 bool BitmapImage::getHotSpot(IntPoint& hotSpot) const
218 {
219     bool result = m_source.getHotSpot(hotSpot);
220     didDecodeProperties();
221     return result;
222 }
223
224 bool BitmapImage::dataChanged(bool allDataReceived)
225 {
226     // Clear all partially-decoded frames. For most image formats, there is only
227     // one frame, but at least GIF and ICO can have more. With GIFs, the frames
228     // come in order and we ask to decode them in order, waiting to request a
229     // subsequent frame until the prior one is complete. Given that we clear
230     // incomplete frames here, this means there is at most one incomplete frame
231     // (even if we use destroyDecodedData() -- since it doesn't reset the
232     // metadata), and it is after all the complete frames.
233     //
234     // With ICOs, on the other hand, we may ask for arbitrary frames at
235     // different times (e.g. because we're displaying a higher-resolution image
236     // in the content area and using a lower-resolution one for the favicon),
237     // and the frames aren't even guaranteed to appear in the file in the same
238     // order as in the directory, so an arbitrary number of the frames might be
239     // incomplete (if we ask for frames for which we've not yet reached the
240     // start of the frame data), and any or none of them might be the particular
241     // frame affected by appending new data here. Thus we have to clear all the
242     // incomplete frames to be safe.
243     unsigned frameBytesCleared = 0;
244     for (size_t i = 0; i < m_frames.size(); ++i) {
245         // NOTE: Don't call frameIsCompleteAtIndex() here, that will try to
246         // decode any uncached (i.e. never-decoded or
247         // cleared-on-a-previous-pass) frames!
248         unsigned frameBytes = m_frames[i].m_frameBytes;
249         if (m_frames[i].m_haveMetadata && !m_frames[i].m_isComplete)
250             frameBytesCleared += (m_frames[i].clear(true) ? frameBytes : 0);
251     }
252     destroyMetadataAndNotify(frameBytesCleared);
253     
254     // Feed all the data we've seen so far to the image decoder.
255     m_allDataReceived = allDataReceived;
256     m_source.setData(data(), allDataReceived);
257     
258     m_haveFrameCount = false;
259     m_hasUniformFrameSize = true;
260     return isSizeAvailable();
261 }
262
263 String BitmapImage::filenameExtension() const
264 {
265     return m_source.filenameExtension();
266 }
267
268 size_t BitmapImage::frameCount()
269 {
270     if (!m_haveFrameCount) {
271         m_frameCount = m_source.frameCount();
272         // If decoder is not initialized yet, m_source.frameCount() returns 0.
273         if (m_frameCount) {
274             didDecodeProperties();
275             m_haveFrameCount = true;
276         }
277     }
278     return m_frameCount;
279 }
280
281 bool BitmapImage::isSizeAvailable()
282 {
283     if (m_sizeAvailable)
284         return true;
285
286     m_sizeAvailable = m_source.isSizeAvailable();
287     didDecodeProperties();
288
289     return m_sizeAvailable;
290 }
291
292 bool BitmapImage::ensureFrameIsCached(size_t index)
293 {
294     if (index >= frameCount())
295         return false;
296
297     if (index >= m_frames.size() || !m_frames[index].m_frame)
298         cacheFrame(index);
299     return true;
300 }
301
302 NativeImagePtr BitmapImage::frameAtIndex(size_t index)
303 {
304     if (!ensureFrameIsCached(index))
305         return 0;
306     return m_frames[index].m_frame;
307 }
308
309 bool BitmapImage::frameIsCompleteAtIndex(size_t index)
310 {
311     if (!ensureFrameIsCached(index))
312         return false;
313     return m_frames[index].m_isComplete;
314 }
315
316 float BitmapImage::frameDurationAtIndex(size_t index)
317 {
318     if (!ensureFrameIsCached(index))
319         return 0;
320     return m_frames[index].m_duration;
321 }
322
323 NativeImagePtr BitmapImage::nativeImageForCurrentFrame()
324 {
325     return frameAtIndex(currentFrame());
326 }
327
328 bool BitmapImage::frameHasAlphaAtIndex(size_t index)
329 {
330     if (m_frames.size() <= index)
331         return true;
332
333     if (m_frames[index].m_haveMetadata)
334         return m_frames[index].m_hasAlpha;
335
336     return m_source.frameHasAlphaAtIndex(index);
337 }
338
339 bool BitmapImage::currentFrameKnownToBeOpaque()
340 {
341     return !frameHasAlphaAtIndex(currentFrame());
342 }
343
344 ImageOrientation BitmapImage::currentFrameOrientation()
345 {
346     return frameOrientationAtIndex(currentFrame());
347 }
348
349 ImageOrientation BitmapImage::frameOrientationAtIndex(size_t index)
350 {
351     if (m_frames.size() <= index)
352         return DefaultImageOrientation;
353
354     if (m_frames[index].m_haveMetadata)
355         return m_frames[index].m_orientation;
356
357     return m_source.orientationAtIndex(index);
358 }
359
360 #if !ASSERT_DISABLED
361 bool BitmapImage::notSolidColor()
362 {
363     return size().width() != 1 || size().height() != 1 || frameCount() > 1;
364 }
365 #endif
366
367
368
369 int BitmapImage::repetitionCount(bool imageKnownToBeComplete)
370 {
371     if ((m_repetitionCountStatus == Unknown) || ((m_repetitionCountStatus == Uncertain) && imageKnownToBeComplete)) {
372         // Snag the repetition count.  If |imageKnownToBeComplete| is false, the
373         // repetition count may not be accurate yet for GIFs; in this case the
374         // decoder will default to cAnimationLoopOnce, and we'll try and read
375         // the count again once the whole image is decoded.
376         m_repetitionCount = m_source.repetitionCount();
377         didDecodeProperties();
378         m_repetitionCountStatus = (imageKnownToBeComplete || m_repetitionCount == cAnimationNone) ? Certain : Uncertain;
379     }
380     return m_repetitionCount;
381 }
382
383 bool BitmapImage::shouldAnimate()
384 {
385     return (repetitionCount(false) != cAnimationNone && !m_animationFinished && imageObserver());
386 }
387
388 void BitmapImage::startAnimation(bool catchUpIfNecessary)
389 {
390     if (m_frameTimer || !shouldAnimate() || frameCount() <= 1)
391         return;
392
393     // If we aren't already animating, set now as the animation start time.
394     const double time = monotonicallyIncreasingTime();
395     if (!m_desiredFrameStartTime)
396         m_desiredFrameStartTime = time;
397
398     // Don't advance the animation to an incomplete frame.
399     size_t nextFrame = (m_currentFrame + 1) % frameCount();
400     if (!m_allDataReceived && !frameIsCompleteAtIndex(nextFrame))
401         return;
402
403     // Don't advance past the last frame if we haven't decoded the whole image
404     // yet and our repetition count is potentially unset.  The repetition count
405     // in a GIF can potentially come after all the rest of the image data, so
406     // wait on it.
407     if (!m_allDataReceived && repetitionCount(false) == cAnimationLoopOnce && m_currentFrame >= (frameCount() - 1))
408         return;
409
410     // Determine time for next frame to start.  By ignoring paint and timer lag
411     // in this calculation, we make the animation appear to run at its desired
412     // rate regardless of how fast it's being repainted.
413     const double currentDuration = frameDurationAtIndex(m_currentFrame);
414     m_desiredFrameStartTime += currentDuration;
415
416     // When an animated image is more than five minutes out of date, the
417     // user probably doesn't care about resyncing and we could burn a lot of
418     // time looping through frames below.  Just reset the timings.
419     const double cAnimationResyncCutoff = 5 * 60;
420     if ((time - m_desiredFrameStartTime) > cAnimationResyncCutoff)
421         m_desiredFrameStartTime = time + currentDuration;
422
423     // The image may load more slowly than it's supposed to animate, so that by
424     // the time we reach the end of the first repetition, we're well behind.
425     // Clamp the desired frame start time in this case, so that we don't skip
426     // frames (or whole iterations) trying to "catch up".  This is a tradeoff:
427     // It guarantees users see the whole animation the second time through and
428     // don't miss any repetitions, and is closer to what other browsers do; on
429     // the other hand, it makes animations "less accurate" for pages that try to
430     // sync an image and some other resource (e.g. audio), especially if users
431     // switch tabs (and thus stop drawing the animation, which will pause it)
432     // during that initial loop, then switch back later.
433     if (nextFrame == 0 && m_repetitionsComplete == 0 && m_desiredFrameStartTime < time)
434         m_desiredFrameStartTime = time;
435
436     if (!catchUpIfNecessary || time < m_desiredFrameStartTime) {
437         // Haven't yet reached time for next frame to start; delay until then.
438         m_frameTimer = new Timer<BitmapImage>(this, &BitmapImage::advanceAnimation);
439         m_frameTimer->startOneShot(std::max(m_desiredFrameStartTime - time, 0.));
440     } else {
441         // We've already reached or passed the time for the next frame to start.
442         // See if we've also passed the time for frames after that to start, in
443         // case we need to skip some frames entirely.  Remember not to advance
444         // to an incomplete frame.
445         for (size_t frameAfterNext = (nextFrame + 1) % frameCount(); frameIsCompleteAtIndex(frameAfterNext); frameAfterNext = (nextFrame + 1) % frameCount()) {
446             // Should we skip the next frame?
447             double frameAfterNextStartTime = m_desiredFrameStartTime + frameDurationAtIndex(nextFrame);
448             if (time < frameAfterNextStartTime)
449                 break;
450
451             // Yes; skip over it without notifying our observers.
452             if (!internalAdvanceAnimation(true))
453                 return;
454             m_desiredFrameStartTime = frameAfterNextStartTime;
455             nextFrame = frameAfterNext;
456         }
457
458         // Draw the next frame immediately.  Note that m_desiredFrameStartTime
459         // may be in the past, meaning the next time through this function we'll
460         // kick off the next advancement sooner than this frame's duration would
461         // suggest.
462         if (internalAdvanceAnimation(false)) {
463             // The image region has been marked dirty, but once we return to our
464             // caller, draw() will clear it, and nothing will cause the
465             // animation to advance again.  We need to start the timer for the
466             // next frame running, or the animation can hang.  (Compare this
467             // with when advanceAnimation() is called, and the region is dirtied
468             // while draw() is not in the callstack, meaning draw() gets called
469             // to update the region and thus startAnimation() is reached again.)
470             // NOTE: For large images with slow or heavily-loaded systems,
471             // throwing away data as we go (see destroyDecodedData()) means we
472             // can spend so much time re-decoding data above that by the time we
473             // reach here we're behind again.  If we let startAnimation() run
474             // the catch-up code again, we can get long delays without painting
475             // as we race the timer, or even infinite recursion.  In this
476             // situation the best we can do is to simply change frames as fast
477             // as possible, so force startAnimation() to set a zero-delay timer
478             // and bail out if we're not caught up.
479             startAnimation(false);
480         }
481     }
482 }
483
484 void BitmapImage::stopAnimation()
485 {
486     // This timer is used to animate all occurrences of this image.  Don't invalidate
487     // the timer unless all renderers have stopped drawing.
488     delete m_frameTimer;
489     m_frameTimer = 0;
490 }
491
492 void BitmapImage::resetAnimation()
493 {
494     stopAnimation();
495     m_currentFrame = 0;
496     m_repetitionsComplete = 0;
497     m_desiredFrameStartTime = 0;
498     m_animationFinished = false;
499     
500     // For extremely large animations, when the animation is reset, we just throw everything away.
501     destroyDecodedDataIfNecessary(true);
502 }
503
504 unsigned BitmapImage::decodedSize() const
505 {
506     return m_decodedSize;
507 }
508
509
510
511 void BitmapImage::advanceAnimation(Timer<BitmapImage>*)
512 {
513     internalAdvanceAnimation(false);
514     // At this point the image region has been marked dirty, and if it's
515     // onscreen, we'll soon make a call to draw(), which will call
516     // startAnimation() again to keep the animation moving.
517 }
518
519 bool BitmapImage::internalAdvanceAnimation(bool skippingFrames)
520 {
521     // Stop the animation.
522     stopAnimation();
523     
524     // See if anyone is still paying attention to this animation.  If not, we don't
525     // advance and will remain suspended at the current frame until the animation is resumed.
526     if (!skippingFrames && imageObserver()->shouldPauseAnimation(this))
527         return false;
528
529     ++m_currentFrame;
530     bool advancedAnimation = true;
531     bool destroyAll = false;
532     if (m_currentFrame >= frameCount()) {
533         ++m_repetitionsComplete;
534
535         // Get the repetition count again.  If we weren't able to get a
536         // repetition count before, we should have decoded the whole image by
537         // now, so it should now be available.
538         // Note that we don't need to special-case cAnimationLoopOnce here
539         // because it is 0 (see comments on its declaration in ImageSource.h).
540         if (repetitionCount(true) != cAnimationLoopInfinite && m_repetitionsComplete > m_repetitionCount) {
541             m_animationFinished = true;
542             m_desiredFrameStartTime = 0;
543             --m_currentFrame;
544             advancedAnimation = false;
545         } else {
546             m_currentFrame = 0;
547             destroyAll = true;
548         }
549     }
550     destroyDecodedDataIfNecessary(destroyAll);
551
552     // We need to draw this frame if we advanced to it while not skipping, or if
553     // while trying to skip frames we hit the last frame and thus had to stop.
554     if (skippingFrames != advancedAnimation)
555         imageObserver()->animationAdvanced(this);
556     return advancedAnimation;
557 }
558
559 bool BitmapImage::mayFillWithSolidColor()
560 {
561     if (!m_checkedForSolidColor && frameCount() > 0) {
562         checkForSolidColor();
563         // WINCE PORT: checkForSolidColor() doesn't set m_checkedForSolidColor until
564         // it gets enough information to make final decision.
565 #if !OS(WINCE)
566         ASSERT(m_checkedForSolidColor);
567 #endif
568     }
569     return m_isSolidColor && !m_currentFrame;
570 }
571
572 Color BitmapImage::solidColor() const
573 {
574     return m_solidColor;
575 }
576
577 void BitmapImage::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
578 {
579     MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Image);
580     memoryObjectInfo->setClassName("BitmapImage");
581     Image::reportMemoryUsage(memoryObjectInfo);
582     info.addMember(m_source, "source");
583     info.addMember(m_frameTimer, "frameTimer");
584     info.addMember(m_frames, "frames");
585 }
586
587 void FrameData::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
588 {
589     MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Image);
590     memoryObjectInfo->setClassName("FrameData");
591 #if OS(WINCE) && !PLATFORM(QT)
592     info.addRawBuffer(m_frame.get(), m_frameBytes, "NativeImage", "frame");
593 #elif USE(SKIA)
594     info.addMember(m_frame, "frame");
595 #else
596     info.addRawBuffer(m_frame, m_frameBytes, "NativeImage", "frame");
597 #endif
598 }
599
600 }