6302130ba6eff76c52d424240ab8b3baa2ff0f86
[WebKit-https.git] / Source / WebCore / platform / image-decoders / ImageDecoder.h
1 /*
2  * Copyright (C) 2006, 2016 Apple Inc.  All rights reserved.
3  * Copyright (C) 2008-2009 Torch Mobile, Inc.
4  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
5  * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
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 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 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 #pragma once
30
31 #include "ImageFrame.h"
32 #include "IntRect.h"
33 #include "IntSize.h"
34 #include "PlatformScreen.h"
35 #include "SharedBuffer.h"
36 #include <wtf/Assertions.h>
37 #include <wtf/Optional.h>
38 #include <wtf/RefPtr.h>
39 #include <wtf/Vector.h>
40 #include <wtf/text/WTFString.h>
41
42 namespace WebCore {
43
44     // ImageDecoder is a base for all format-specific decoders
45     // (e.g. JPEGImageDecoder).  This base manages the ImageFrame cache.
46     //
47     // ENABLE(IMAGE_DECODER_DOWN_SAMPLING) allows image decoders to downsample
48     // at decode time.  Image decoders will downsample any images larger than
49     // |m_maxNumPixels|.  FIXME: Not yet supported by all decoders.
50     class ImageDecoder {
51         WTF_MAKE_NONCOPYABLE(ImageDecoder); WTF_MAKE_FAST_ALLOCATED;
52     public:
53         ImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
54             : m_premultiplyAlpha(alphaOption == AlphaOption::Premultiplied)
55             , m_ignoreGammaAndColorProfile(gammaAndColorProfileOption == GammaAndColorProfileOption::Ignored)
56         {
57         }
58
59         virtual ~ImageDecoder()
60         {
61         }
62
63         // Returns a caller-owned decoder of the appropriate type.  Returns 0 if
64         // we can't sniff a supported type from the provided data (possibly
65         // because there isn't enough data yet).
66         static std::unique_ptr<ImageDecoder> create(const SharedBuffer& data, AlphaOption, GammaAndColorProfileOption);
67
68         virtual String filenameExtension() const = 0;
69         
70         bool premultiplyAlpha() const { return m_premultiplyAlpha; }
71
72         bool isAllDataReceived() const { return m_isAllDataReceived; }
73
74         virtual void setData(SharedBuffer& data, bool allDataReceived)
75         {
76             if (m_failed)
77                 return;
78             m_data = &data;
79             m_isAllDataReceived = allDataReceived;
80         }
81
82         // Lazily-decodes enough of the image to get the size (if possible).
83         // FIXME: Right now that has to be done by each subclass; factor the
84         // decode call out and use it here.
85         virtual bool isSizeAvailable()
86         {
87             return !m_failed && m_sizeAvailable;
88         }
89
90         virtual IntSize size() { return isSizeAvailable() ? m_size : IntSize(); }
91
92         IntSize scaledSize()
93         {
94             return m_scaled ? IntSize(m_scaledColumns.size(), m_scaledRows.size()) : size();
95         }
96
97         // This will only differ from size() for ICO (where each frame is a
98         // different icon) or other formats where different frames are different
99         // sizes.  This does NOT differ from size() for GIF, since decoding GIFs
100         // composites any smaller frames against previous frames to create full-
101         // size frames.
102         virtual IntSize frameSizeAtIndex(size_t, SubsamplingLevel)
103         {
104             return size();
105         }
106
107         // Returns whether the size is legal (i.e. not going to result in
108         // overflow elsewhere).  If not, marks decoding as failed.
109         virtual bool setSize(const IntSize& size)
110         {
111             if (ImageBackingStore::isOverSize(size))
112                 return setFailed();
113             m_size = size;
114             m_sizeAvailable = true;
115             return true;
116         }
117
118         // Lazily-decodes enough of the image to get the frame count (if
119         // possible), without decoding the individual frames.
120         // FIXME: Right now that has to be done by each subclass; factor the
121         // decode call out and use it here.
122         virtual size_t frameCount() const { return 1; }
123
124         virtual RepetitionCount repetitionCount() const { return RepetitionCountNone; }
125
126         // Decodes as much of the requested frame as possible, and returns an
127         // ImageDecoder-owned pointer.
128         virtual ImageFrame* frameBufferAtIndex(size_t) = 0;
129
130         bool frameIsCompleteAtIndex(size_t);
131
132         // Make the best effort guess to check if the requested frame has alpha channel.
133         bool frameHasAlphaAtIndex(size_t) const;
134
135         // Number of bytes in the decoded frame requested. Return 0 if not yet decoded.
136         unsigned frameBytesAtIndex(size_t) const;
137         
138         float frameDurationAtIndex(size_t);
139         
140         NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const std::optional<IntSize>& sizeForDraw = { });
141
142         void setIgnoreGammaAndColorProfile(bool flag) { m_ignoreGammaAndColorProfile = flag; }
143         bool ignoresGammaAndColorProfile() const { return m_ignoreGammaAndColorProfile; }
144
145         ImageOrientation frameOrientationAtIndex(size_t) const { return m_orientation; }
146         
147         bool frameAllowSubsamplingAtIndex(size_t) const { return false; }
148
149         enum { iccColorProfileHeaderLength = 128 };
150
151         static bool rgbColorProfile(const char* profileData, unsigned profileLength)
152         {
153             ASSERT_UNUSED(profileLength, profileLength >= iccColorProfileHeaderLength);
154
155             return !memcmp(&profileData[16], "RGB ", 4);
156         }
157
158         static size_t bytesDecodedToDetermineProperties() { return 0; }
159         
160         static SubsamplingLevel subsamplingLevelForScale(float, SubsamplingLevel) { return SubsamplingLevel::Default; }
161
162         static bool inputDeviceColorProfile(const char* profileData, unsigned profileLength)
163         {
164             ASSERT_UNUSED(profileLength, profileLength >= iccColorProfileHeaderLength);
165
166             return !memcmp(&profileData[12], "mntr", 4) || !memcmp(&profileData[12], "scnr", 4);
167         }
168
169         // Sets the "decode failure" flag.  For caller convenience (since so
170         // many callers want to return false after calling this), returns false
171         // to enable easy tailcalling.  Subclasses may override this to also
172         // clean up any local data.
173         virtual bool setFailed()
174         {
175             m_failed = true;
176             return false;
177         }
178
179         bool failed() const { return m_failed; }
180
181         // Clears decoded pixel data from before the provided frame unless that
182         // data may be needed to decode future frames (e.g. due to GIF frame
183         // compositing).
184         virtual void clearFrameBufferCache(size_t) { }
185
186         // If the image has a cursor hot-spot, stores it in the argument
187         // and returns true. Otherwise returns false.
188         virtual std::optional<IntPoint> hotSpot() const { return std::nullopt; }
189
190     protected:
191         void prepareScaleDataIfNecessary();
192         int upperBoundScaledX(int origX, int searchStart = 0);
193         int lowerBoundScaledX(int origX, int searchStart = 0);
194         int upperBoundScaledY(int origY, int searchStart = 0);
195         int lowerBoundScaledY(int origY, int searchStart = 0);
196         int scaledY(int origY, int searchStart = 0);
197
198         RefPtr<SharedBuffer> m_data; // The encoded data.
199         Vector<ImageFrame, 1> m_frameBufferCache;
200         bool m_scaled { false };
201         Vector<int> m_scaledColumns;
202         Vector<int> m_scaledRows;
203         bool m_premultiplyAlpha;
204         bool m_ignoreGammaAndColorProfile;
205         ImageOrientation m_orientation;
206
207     private:
208         IntSize m_size;
209         bool m_sizeAvailable { false };
210 #if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
211         static const int m_maxNumPixels { 1024 * 1024 };
212 #else
213         static const int m_maxNumPixels { -1 };
214 #endif
215         bool m_isAllDataReceived { false };
216         bool m_failed { false };
217     };
218
219 } // namespace WebCore