| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (C) 2006 Apple Computer, Inc. All rights reserved. | |
| 3 * | |
| 4 * Redistribution and use in source and binary forms, with or without | |
| 5 * modification, are permitted provided that the following conditions | |
| 6 * are met: | |
| 7 * 1. Redistributions of source code must retain the above copyright | |
| 8 * notice, this list of conditions and the following disclaimer. | |
| 9 * 2. Redistributions in binary form must reproduce the above copyright | |
| 10 * notice, this list of conditions and the following disclaimer in the | |
| 11 * documentation and/or other materials provided with the distribution. | |
| 12 * | |
| 13 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY | |
| 14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
| 16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR | |
| 17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |
| 18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
| 19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |
| 20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY | |
| 21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 24 */ | |
| 25 | |
| 26 #include "platform/image-decoders/gif/GIFImageDecoder.h" | |
| 27 | |
| 28 #include <limits> | |
| 29 #include "platform/image-decoders/gif/GIFImageReader.h" | |
| 30 #include "platform/wtf/NotFound.h" | |
| 31 #include "platform/wtf/PtrUtil.h" | |
| 32 | |
| 33 namespace blink { | |
| 34 | |
| 35 GIFImageDecoder::GIFImageDecoder(AlphaOption alpha_option, | |
| 36 const ColorBehavior& color_behavior, | |
| 37 size_t max_decoded_bytes) | |
| 38 : ImageDecoder(alpha_option, color_behavior, max_decoded_bytes), | |
| 39 repetition_count_(kAnimationLoopOnce) {} | |
| 40 | |
| 41 GIFImageDecoder::~GIFImageDecoder() {} | |
| 42 | |
| 43 void GIFImageDecoder::OnSetData(SegmentReader* data) { | |
| 44 if (reader_) | |
| 45 reader_->SetData(data); | |
| 46 } | |
| 47 | |
| 48 int GIFImageDecoder::RepetitionCount() const { | |
| 49 // This value can arrive at any point in the image data stream. Most GIFs | |
| 50 // in the wild declare it near the beginning of the file, so it usually is | |
| 51 // set by the time we've decoded the size, but (depending on the GIF and the | |
| 52 // packets sent back by the webserver) not always. If the reader hasn't | |
| 53 // seen a loop count yet, it will return kCLoopCountNotSeen, in which case we | |
| 54 // should default to looping once (the initial value for | |
| 55 // |repetition_count_|). | |
| 56 // | |
| 57 // There are some additional wrinkles here. First, ImageSource::Clear() | |
| 58 // may destroy the reader, making the result from the reader _less_ | |
| 59 // authoritative on future calls if the recreated reader hasn't seen the | |
| 60 // loop count. We don't need to special-case this because in this case the | |
| 61 // new reader will once again return kCLoopCountNotSeen, and we won't | |
| 62 // overwrite the cached correct value. | |
| 63 // | |
| 64 // Second, a GIF might never set a loop count at all, in which case we | |
| 65 // should continue to treat it as a "loop once" animation. We don't need | |
| 66 // special code here either, because in this case we'll never change | |
| 67 // |repetition_count_| from its default value. | |
| 68 // | |
| 69 // Third, we use the same GIFImageReader for counting frames and we might | |
| 70 // see the loop count and then encounter a decoding error which happens | |
| 71 // later in the stream. It is also possible that no frames are in the | |
| 72 // stream. In these cases we should just loop once. | |
| 73 if (IsAllDataReceived() && ParseCompleted() && reader_->ImagesCount() == 1) | |
| 74 repetition_count_ = kAnimationNone; | |
| 75 else if (Failed() || (reader_ && (!reader_->ImagesCount()))) | |
| 76 repetition_count_ = kAnimationLoopOnce; | |
| 77 else if (reader_ && reader_->LoopCount() != kCLoopCountNotSeen) | |
| 78 repetition_count_ = reader_->LoopCount(); | |
| 79 return repetition_count_; | |
| 80 } | |
| 81 | |
| 82 bool GIFImageDecoder::FrameIsCompleteAtIndex(size_t index) const { | |
| 83 return reader_ && (index < reader_->ImagesCount()) && | |
| 84 reader_->FrameContext(index)->IsComplete(); | |
| 85 } | |
| 86 | |
| 87 float GIFImageDecoder::FrameDurationAtIndex(size_t index) const { | |
| 88 return (reader_ && (index < reader_->ImagesCount()) && | |
| 89 reader_->FrameContext(index)->IsHeaderDefined()) | |
| 90 ? reader_->FrameContext(index)->DelayTime() | |
| 91 : 0; | |
| 92 } | |
| 93 | |
| 94 bool GIFImageDecoder::SetFailed() { | |
| 95 reader_.reset(); | |
| 96 return ImageDecoder::SetFailed(); | |
| 97 } | |
| 98 | |
| 99 bool GIFImageDecoder::HaveDecodedRow(size_t frame_index, | |
| 100 GIFRow::const_iterator row_begin, | |
| 101 size_t width, | |
| 102 size_t row_number, | |
| 103 unsigned repeat_count, | |
| 104 bool write_transparent_pixels) { | |
| 105 const GIFFrameContext* frame_context = reader_->FrameContext(frame_index); | |
| 106 // The pixel data and coordinates supplied to us are relative to the frame's | |
| 107 // origin within the entire image size, i.e. | |
| 108 // (frameC_context->xOffset, frame_context->yOffset). There is no guarantee | |
| 109 // that width == (size().width() - frame_context->xOffset), so | |
| 110 // we must ensure we don't run off the end of either the source data or the | |
| 111 // row's X-coordinates. | |
| 112 const int x_begin = frame_context->XOffset(); | |
| 113 const int y_begin = frame_context->YOffset() + row_number; | |
| 114 const int x_end = std::min(static_cast<int>(frame_context->XOffset() + width), | |
| 115 Size().Width()); | |
| 116 const int y_end = std::min( | |
| 117 static_cast<int>(frame_context->YOffset() + row_number + repeat_count), | |
| 118 Size().Height()); | |
| 119 if (!width || (x_begin < 0) || (y_begin < 0) || (x_end <= x_begin) || | |
| 120 (y_end <= y_begin)) | |
| 121 return true; | |
| 122 | |
| 123 const GIFColorMap::Table& color_table = | |
| 124 frame_context->LocalColorMap().IsDefined() | |
| 125 ? frame_context->LocalColorMap().GetTable() | |
| 126 : reader_->GlobalColorMap().GetTable(); | |
| 127 | |
| 128 if (color_table.IsEmpty()) | |
| 129 return true; | |
| 130 | |
| 131 GIFColorMap::Table::const_iterator color_table_iter = color_table.begin(); | |
| 132 | |
| 133 // Initialize the frame if necessary. | |
| 134 ImageFrame& buffer = frame_buffer_cache_[frame_index]; | |
| 135 if (!InitFrameBuffer(frame_index)) | |
| 136 return false; | |
| 137 | |
| 138 const size_t transparent_pixel = frame_context->TransparentPixel(); | |
| 139 GIFRow::const_iterator row_end = row_begin + (x_end - x_begin); | |
| 140 ImageFrame::PixelData* current_address = buffer.GetAddr(x_begin, y_begin); | |
| 141 | |
| 142 // We may or may not need to write transparent pixels to the buffer. | |
| 143 // If we're compositing against a previous image, it's wrong, and if | |
| 144 // we're writing atop a cleared, fully transparent buffer, it's | |
| 145 // unnecessary; but if we're decoding an interlaced gif and | |
| 146 // displaying it "Haeberli"-style, we must write these for passes | |
| 147 // beyond the first, or the initial passes will "show through" the | |
| 148 // later ones. | |
| 149 // | |
| 150 // The loops below are almost identical. One writes a transparent pixel | |
| 151 // and one doesn't based on the value of |write_transparent_pixels|. | |
| 152 // The condition check is taken out of the loop to enhance performance. | |
| 153 // This optimization reduces decoding time by about 15% for a 3MB image. | |
| 154 if (write_transparent_pixels) { | |
| 155 for (; row_begin != row_end; ++row_begin, ++current_address) { | |
| 156 const size_t source_value = *row_begin; | |
| 157 if ((source_value != transparent_pixel) && | |
| 158 (source_value < color_table.size())) { | |
| 159 *current_address = color_table_iter[source_value]; | |
| 160 } else { | |
| 161 *current_address = 0; | |
| 162 current_buffer_saw_alpha_ = true; | |
| 163 } | |
| 164 } | |
| 165 } else { | |
| 166 for (; row_begin != row_end; ++row_begin, ++current_address) { | |
| 167 const size_t source_value = *row_begin; | |
| 168 if ((source_value != transparent_pixel) && | |
| 169 (source_value < color_table.size())) | |
| 170 *current_address = color_table_iter[source_value]; | |
| 171 else | |
| 172 current_buffer_saw_alpha_ = true; | |
| 173 } | |
| 174 } | |
| 175 | |
| 176 // Tell the frame to copy the row data if need be. | |
| 177 if (repeat_count > 1) | |
| 178 buffer.CopyRowNTimes(x_begin, x_end, y_begin, y_end); | |
| 179 | |
| 180 buffer.SetPixelsChanged(true); | |
| 181 return true; | |
| 182 } | |
| 183 | |
| 184 bool GIFImageDecoder::ParseCompleted() const { | |
| 185 return reader_ && reader_->ParseCompleted(); | |
| 186 } | |
| 187 | |
| 188 bool GIFImageDecoder::FrameComplete(size_t frame_index) { | |
| 189 // Initialize the frame if necessary. Some GIFs insert do-nothing frames, | |
| 190 // in which case we never reach HaveDecodedRow() before getting here. | |
| 191 if (!InitFrameBuffer(frame_index)) | |
| 192 return SetFailed(); | |
| 193 | |
| 194 if (!current_buffer_saw_alpha_) | |
| 195 CorrectAlphaWhenFrameBufferSawNoAlpha(frame_index); | |
| 196 | |
| 197 frame_buffer_cache_[frame_index].SetStatus(ImageFrame::kFrameComplete); | |
| 198 | |
| 199 return true; | |
| 200 } | |
| 201 | |
| 202 void GIFImageDecoder::ClearFrameBuffer(size_t frame_index) { | |
| 203 if (reader_ && frame_buffer_cache_[frame_index].GetStatus() == | |
| 204 ImageFrame::kFramePartial) { | |
| 205 // Reset the state of the partial frame in the reader so that the frame | |
| 206 // can be decoded again when requested. | |
| 207 reader_->ClearDecodeState(frame_index); | |
| 208 } | |
| 209 ImageDecoder::ClearFrameBuffer(frame_index); | |
| 210 } | |
| 211 | |
| 212 size_t GIFImageDecoder::DecodeFrameCount() { | |
| 213 Parse(kGIFFrameCountQuery); | |
| 214 // If decoding fails, |reader_| will have been destroyed. Instead of | |
| 215 // returning 0 in this case, return the existing number of frames. This way | |
| 216 // if we get halfway through the image before decoding fails, we won't | |
| 217 // suddenly start reporting that the image has zero frames. | |
| 218 return Failed() ? frame_buffer_cache_.size() : reader_->ImagesCount(); | |
| 219 } | |
| 220 | |
| 221 void GIFImageDecoder::InitializeNewFrame(size_t index) { | |
| 222 ImageFrame* buffer = &frame_buffer_cache_[index]; | |
| 223 const GIFFrameContext* frame_context = reader_->FrameContext(index); | |
| 224 buffer->SetOriginalFrameRect( | |
| 225 Intersection(frame_context->FrameRect(), IntRect(IntPoint(), Size()))); | |
| 226 buffer->SetDuration(frame_context->DelayTime()); | |
| 227 buffer->SetDisposalMethod(frame_context->GetDisposalMethod()); | |
| 228 buffer->SetRequiredPreviousFrameIndex( | |
| 229 FindRequiredPreviousFrame(index, false)); | |
| 230 } | |
| 231 | |
| 232 void GIFImageDecoder::Decode(size_t index) { | |
| 233 Parse(kGIFFrameCountQuery); | |
| 234 | |
| 235 if (Failed()) | |
| 236 return; | |
| 237 | |
| 238 UpdateAggressivePurging(index); | |
| 239 | |
| 240 Vector<size_t> frames_to_decode = FindFramesToDecode(index); | |
| 241 for (auto i = frames_to_decode.rbegin(); i != frames_to_decode.rend(); ++i) { | |
| 242 if (!reader_->Decode(*i)) { | |
| 243 SetFailed(); | |
| 244 return; | |
| 245 } | |
| 246 | |
| 247 // If this returns false, we need more data to continue decoding. | |
| 248 if (!PostDecodeProcessing(*i)) | |
| 249 break; | |
| 250 } | |
| 251 | |
| 252 // It is also a fatal error if all data is received and we have decoded all | |
| 253 // frames available but the file is truncated. | |
| 254 if (index >= frame_buffer_cache_.size() - 1 && IsAllDataReceived() && | |
| 255 reader_ && !reader_->ParseCompleted()) | |
| 256 SetFailed(); | |
| 257 } | |
| 258 | |
| 259 void GIFImageDecoder::Parse(GIFParseQuery query) { | |
| 260 if (Failed()) | |
| 261 return; | |
| 262 | |
| 263 if (!reader_) { | |
| 264 reader_ = WTF::MakeUnique<GIFImageReader>(this); | |
| 265 reader_->SetData(data_); | |
| 266 } | |
| 267 | |
| 268 if (!reader_->Parse(query)) | |
| 269 SetFailed(); | |
| 270 } | |
| 271 | |
| 272 void GIFImageDecoder::OnInitFrameBuffer(size_t frame_index) { | |
| 273 current_buffer_saw_alpha_ = false; | |
| 274 } | |
| 275 | |
| 276 bool GIFImageDecoder::CanReusePreviousFrameBuffer(size_t frame_index) const { | |
| 277 DCHECK(frame_index < frame_buffer_cache_.size()); | |
| 278 return frame_buffer_cache_[frame_index].GetDisposalMethod() != | |
| 279 ImageFrame::kDisposeOverwritePrevious; | |
| 280 } | |
| 281 | |
| 282 } // namespace blink | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2930513004:
[WIP] Move ImageDecoders to SkCodec
