diff options
author | Allan Sandfeld Jensen <allan.jensen@qt.io> | 2018-12-10 16:19:40 +0100 |
---|---|---|
committer | Allan Sandfeld Jensen <allan.jensen@qt.io> | 2018-12-10 16:01:50 +0000 |
commit | 51f6c2793adab2d864b3d2b360000ef8db1d3e92 (patch) | |
tree | 835b3b4446b012c75e80177cef9fbe6972cc7dbe /chromium/third_party/blink/renderer/platform/image-decoders/gif/gif_image_decoder.cc | |
parent | 6036726eb981b6c4b42047513b9d3f4ac865daac (diff) | |
download | qtwebengine-chromium-51f6c2793adab2d864b3d2b360000ef8db1d3e92.tar.gz |
BASELINE: Update Chromium to 71.0.3578.93
Change-Id: I6a32086c33670e1b033f8b10e6bf1fd4da1d105d
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
Diffstat (limited to 'chromium/third_party/blink/renderer/platform/image-decoders/gif/gif_image_decoder.cc')
-rw-r--r-- | chromium/third_party/blink/renderer/platform/image-decoders/gif/gif_image_decoder.cc | 461 |
1 files changed, 270 insertions, 191 deletions
diff --git a/chromium/third_party/blink/renderer/platform/image-decoders/gif/gif_image_decoder.cc b/chromium/third_party/blink/renderer/platform/image-decoders/gif/gif_image_decoder.cc index 860215b58e7..087126ea5ec 100644 --- a/chromium/third_party/blink/renderer/platform/image-decoders/gif/gif_image_decoder.cc +++ b/chromium/third_party/blink/renderer/platform/image-decoders/gif/gif_image_decoder.cc @@ -26,261 +26,340 @@ #include "third_party/blink/renderer/platform/image-decoders/gif/gif_image_decoder.h" #include <limits> -#include <memory> -#include "third_party/blink/renderer/platform/image-decoders/gif/gif_image_reader.h" +#include "third_party/blink/renderer/platform/image-decoders/segment_stream.h" #include "third_party/blink/renderer/platform/wtf/not_found.h" +#include "third_party/skia/include/core/SkImageInfo.h" namespace blink { +namespace { + +ImageFrame::DisposalMethod ConvertDisposalMethod( + SkCodecAnimation::DisposalMethod disposal_method) { + switch (disposal_method) { + case SkCodecAnimation::DisposalMethod::kKeep: + return ImageFrame::kDisposeKeep; + case SkCodecAnimation::DisposalMethod::kRestoreBGColor: + return ImageFrame::kDisposeOverwriteBgcolor; + case SkCodecAnimation::DisposalMethod::kRestorePrevious: + return ImageFrame::kDisposeOverwritePrevious; + default: + return ImageFrame::kDisposeNotSpecified; + } +} + +} // anonymous namespace + GIFImageDecoder::GIFImageDecoder(AlphaOption alpha_option, const ColorBehavior& color_behavior, size_t max_decoded_bytes) : ImageDecoder(alpha_option, ImageDecoder::kDefaultBitDepth, color_behavior, - max_decoded_bytes), - repetition_count_(kAnimationLoopOnce) {} + max_decoded_bytes) {} GIFImageDecoder::~GIFImageDecoder() = default; void GIFImageDecoder::OnSetData(SegmentReader* data) { - if (reader_) - reader_->SetData(data); + if (!data) { + if (segment_stream_) + segment_stream_->SetReader(nullptr); + return; + } + + std::unique_ptr<SegmentStream> segment_stream; + if (!segment_stream_) { + segment_stream = std::make_unique<SegmentStream>(); + segment_stream_ = segment_stream.get(); + } + + segment_stream_->SetReader(data); + + if (!codec_) { + SkCodec::Result codec_creation_result; + codec_ = SkCodec::MakeFromStream(std::move(segment_stream), + &codec_creation_result, nullptr); + switch (codec_creation_result) { + case SkCodec::kSuccess: { + // SkCodec::MakeFromStream will read enough of the image to get the + // image size. + SkImageInfo image_info = codec_->getInfo(); + SetSize(image_info.width(), image_info.height()); + return; + } + case SkCodec::kIncompleteInput: + // |segment_stream_|'s ownership is passed into MakeFromStream. + // It is deleted if MakeFromStream fails. + // If MakeFromStream fails, we set |segment_stream_| to null so + // we aren't pointing to reclaimed memory. + segment_stream_ = nullptr; + return; + default: + SetFailed(); + return; + } + } } int GIFImageDecoder::RepetitionCount() const { + if (!codec_ || segment_stream_->IsCleared()) + return repetition_count_; + + DCHECK(!Failed()); + // This value can arrive at any point in the image data stream. Most GIFs // in the wild declare it near the beginning of the file, so it usually is // set by the time we've decoded the size, but (depending on the GIF and the - // packets sent back by the webserver) not always. If the reader hasn't - // seen a loop count yet, it will return kCLoopCountNotSeen, in which case we - // should default to looping once (the initial value for - // |repetition_count_|). - // - // There are some additional wrinkles here. First, ImageSource::Clear() - // may destroy the reader, making the result from the reader _less_ - // authoritative on future calls if the recreated reader hasn't seen the - // loop count. We don't need to special-case this because in this case the - // new reader will once again return kCLoopCountNotSeen, and we won't - // overwrite the cached correct value. + // packets sent back by the webserver) not always. // - // Second, a GIF might never set a loop count at all, in which case we - // should continue to treat it as a "loop once" animation. We don't need - // special code here either, because in this case we'll never change - // |repetition_count_| from its default value. - // - // Third, we use the same GIFImageReader for counting frames and we might - // see the loop count and then encounter a decoding error which happens - // later in the stream. It is also possible that no frames are in the - // stream. In these cases we should just loop once. - if (IsAllDataReceived() && ParseCompleted() && reader_->ImagesCount() == 1) - repetition_count_ = kAnimationNone; - else if (Failed() || (reader_ && (!reader_->ImagesCount()))) - repetition_count_ = kAnimationLoopOnce; - else if (reader_ && reader_->LoopCount() != kCLoopCountNotSeen) - repetition_count_ = reader_->LoopCount(); + // SkCodec will parse forward in the file if the repetition count has not been + // seen yet. + int repetition_count = codec_->getRepetitionCount(); + + switch (repetition_count) { + case 0: { + // SkCodec returns 0 for both still images and animated images which only + // play once. + if (IsAllDataReceived() && codec_->getFrameCount() == 1) { + repetition_count_ = kAnimationNone; + break; + } + + repetition_count_ = kAnimationLoopOnce; + break; + } + case SkCodec::kRepetitionCountInfinite: + repetition_count_ = kAnimationLoopInfinite; + break; + default: + repetition_count_ = repetition_count; + break; + } + return repetition_count_; } bool GIFImageDecoder::FrameIsReceivedAtIndex(size_t index) const { - return reader_ && (index < reader_->ImagesCount()) && - reader_->FrameContext(index)->IsComplete(); + SkCodec::FrameInfo frame_info; + if (!codec_ || !codec_->getFrameInfo(index, &frame_info)) + return false; + return frame_info.fFullyReceived; } TimeDelta GIFImageDecoder::FrameDurationAtIndex(size_t index) const { - return (reader_ && (index < reader_->ImagesCount()) && - reader_->FrameContext(index)->IsHeaderDefined()) - ? TimeDelta::FromMilliseconds( - reader_->FrameContext(index)->DelayTime()) - : TimeDelta(); + if (index < frame_buffer_cache_.size()) + return frame_buffer_cache_[index].Duration(); + return TimeDelta(); } bool GIFImageDecoder::SetFailed() { - reader_.reset(); + segment_stream_ = nullptr; + codec_.reset(); return ImageDecoder::SetFailed(); } -bool GIFImageDecoder::HaveDecodedRow(size_t frame_index, - GIFRow::const_iterator row_begin, - size_t width, - size_t row_number, - unsigned repeat_count, - bool write_transparent_pixels) { - const GIFFrameContext* frame_context = reader_->FrameContext(frame_index); - // The pixel data and coordinates supplied to us are relative to the frame's - // origin within the entire image size, i.e. - // (frameC_context->xOffset, frame_context->yOffset). There is no guarantee - // that width == (size().width() - frame_context->xOffset), so - // we must ensure we don't run off the end of either the source data or the - // row's X-coordinates. - const int x_begin = frame_context->XOffset(); - const int y_begin = frame_context->YOffset() + row_number; - const int x_end = std::min(static_cast<int>(frame_context->XOffset() + width), - Size().Width()); - const int y_end = std::min( - static_cast<int>(frame_context->YOffset() + row_number + repeat_count), - Size().Height()); - if (!width || (x_begin < 0) || (y_begin < 0) || (x_end <= x_begin) || - (y_end <= y_begin)) - return true; - - const GIFColorMap::Table& color_table = - frame_context->LocalColorMap().IsDefined() - ? frame_context->LocalColorMap().GetTable() - : reader_->GlobalColorMap().GetTable(); - - if (color_table.IsEmpty()) - return true; - - GIFColorMap::Table::const_iterator color_table_iter = color_table.begin(); - - // Initialize the frame if necessary. - ImageFrame& buffer = frame_buffer_cache_[frame_index]; - if (!InitFrameBuffer(frame_index)) - return false; - - const size_t transparent_pixel = frame_context->TransparentPixel(); - GIFRow::const_iterator row_end = row_begin + (x_end - x_begin); - ImageFrame::PixelData* current_address = buffer.GetAddr(x_begin, y_begin); - - // We may or may not need to write transparent pixels to the buffer. - // If we're compositing against a previous image, it's wrong, and if - // we're writing atop a cleared, fully transparent buffer, it's - // unnecessary; but if we're decoding an interlaced gif and - // displaying it "Haeberli"-style, we must write these for passes - // beyond the first, or the initial passes will "show through" the - // later ones. - // - // The loops below are almost identical. One writes a transparent pixel - // and one doesn't based on the value of |write_transparent_pixels|. - // The condition check is taken out of the loop to enhance performance. - // This optimization reduces decoding time by about 15% for a 3MB image. - if (write_transparent_pixels) { - for (; row_begin != row_end; ++row_begin, ++current_address) { - const size_t source_value = *row_begin; - if ((source_value != transparent_pixel) && - (source_value < color_table.size())) { - *current_address = color_table_iter[source_value]; - } else { - *current_address = 0; - current_buffer_saw_alpha_ = true; - } - } - } else { - for (; row_begin != row_end; ++row_begin, ++current_address) { - const size_t source_value = *row_begin; - if ((source_value != transparent_pixel) && - (source_value < color_table.size())) - *current_address = color_table_iter[source_value]; - else - current_buffer_saw_alpha_ = true; +size_t GIFImageDecoder::ClearCacheExceptFrame(size_t index) { + if (frame_buffer_cache_.size() <= 1) + return 0; + + // SkCodec attempts to report the earliest possible required frame. But it is + // possible that frame has been evicted. A later frame which could also + // be used as the required frame may still be cached. Try to preserve a frame + // that is still cached. + size_t index2 = kNotFound; + if (index < frame_buffer_cache_.size()) { + const ImageFrame& frame = frame_buffer_cache_[index]; + if (frame.RequiredPreviousFrameIndex() != kNotFound && + (!FrameStatusSufficientForSuccessors(index) || + frame.GetDisposalMethod() == ImageFrame::kDisposeOverwritePrevious)) { + index2 = GetViableReferenceFrameIndex(index); } } - // Tell the frame to copy the row data if need be. - if (repeat_count > 1) - buffer.CopyRowNTimes(x_begin, x_end, y_begin, y_end); - - buffer.SetPixelsChanged(true); - return true; + return ClearCacheExceptTwoFrames(index, index2); } -bool GIFImageDecoder::ParseCompleted() const { - return reader_ && reader_->ParseCompleted(); -} - -bool GIFImageDecoder::FrameComplete(size_t frame_index) { - // Initialize the frame if necessary. Some GIFs insert do-nothing frames, - // in which case we never reach HaveDecodedRow() before getting here. - if (!InitFrameBuffer(frame_index)) - return SetFailed(); - - if (!current_buffer_saw_alpha_) - CorrectAlphaWhenFrameBufferSawNoAlpha(frame_index); - - frame_buffer_cache_[frame_index].SetStatus(ImageFrame::kFrameComplete); +size_t GIFImageDecoder::DecodeFrameCount() { + if (!codec_ || segment_stream_->IsCleared()) + return frame_buffer_cache_.size(); - return true; + return codec_->getFrameCount(); } -void GIFImageDecoder::ClearFrameBuffer(size_t frame_index) { - if (reader_ && frame_buffer_cache_[frame_index].GetStatus() == - ImageFrame::kFramePartial) { - // Reset the state of the partial frame in the reader so that the frame - // can be decoded again when requested. - reader_->ClearDecodeState(frame_index); +void GIFImageDecoder::InitializeNewFrame(size_t index) { + DCHECK(codec_); + + ImageFrame& frame = frame_buffer_cache_[index]; + // SkCodec does not inform us if only a portion of the image was updated in + // the current frame. Because of this, rather than correctly filling in the + // frame rect, we set the frame rect to be the image's full size. + // The original frame rect is not used, anyway. + IntSize full_image_size = Size(); + frame.SetOriginalFrameRect(IntRect(IntPoint(), full_image_size)); + + SkCodec::FrameInfo frame_info; + bool frame_info_received = codec_->getFrameInfo(index, &frame_info); + DCHECK(frame_info_received); + frame.SetDuration(TimeDelta::FromMilliseconds(frame_info.fDuration)); + size_t required_previous_frame_index; + if (frame_info.fRequiredFrame == SkCodec::kNoFrame) { + required_previous_frame_index = kNotFound; + } else { + required_previous_frame_index = + static_cast<size_t>(frame_info.fRequiredFrame); } - ImageDecoder::ClearFrameBuffer(frame_index); + frame.SetRequiredPreviousFrameIndex(required_previous_frame_index); + frame.SetDisposalMethod(ConvertDisposalMethod(frame_info.fDisposalMethod)); } -size_t GIFImageDecoder::DecodeFrameCount() { - Parse(kGIFFrameCountQuery); - // If decoding fails, |reader_| will have been destroyed. Instead of - // returning 0 in this case, return the existing number of frames. This way - // if we get halfway through the image before decoding fails, we won't - // suddenly start reporting that the image has zero frames. - return Failed() ? frame_buffer_cache_.size() : reader_->ImagesCount(); -} +void GIFImageDecoder::Decode(size_t index) { + if (!codec_ || segment_stream_->IsCleared()) + return; -void GIFImageDecoder::InitializeNewFrame(size_t index) { - ImageFrame* buffer = &frame_buffer_cache_[index]; - const GIFFrameContext* frame_context = reader_->FrameContext(index); - buffer->SetOriginalFrameRect( - Intersection(frame_context->FrameRect(), IntRect(IntPoint(), Size()))); - buffer->SetDuration(TimeDelta::FromMilliseconds(frame_context->DelayTime())); - buffer->SetDisposalMethod(frame_context->GetDisposalMethod()); - buffer->SetRequiredPreviousFrameIndex( - FindRequiredPreviousFrame(index, false)); -} + DCHECK(!Failed()); -void GIFImageDecoder::Decode(size_t index) { - Parse(kGIFFrameCountQuery); + DCHECK_LT(index, frame_buffer_cache_.size()); - if (Failed()) + ImageFrame& frame = frame_buffer_cache_[index]; + if (frame.GetStatus() == ImageFrame::kFrameComplete) return; UpdateAggressivePurging(index); - Vector<size_t> frames_to_decode = FindFramesToDecode(index); - for (auto i = frames_to_decode.rbegin(); i != frames_to_decode.rend(); ++i) { - if (!reader_->Decode(*i)) { - SetFailed(); - return; - } + if (frame.GetStatus() == ImageFrame::kFrameEmpty) { + size_t required_previous_frame_index = frame.RequiredPreviousFrameIndex(); + if (required_previous_frame_index == kNotFound) { + frame.AllocatePixelData(Size().Width(), Size().Height(), + ColorSpaceForSkImages()); + frame.ZeroFillPixelData(); + prior_frame_ = SkCodec::kNoFrame; + } else { + size_t previous_frame_index = GetViableReferenceFrameIndex(index); + if (previous_frame_index == kNotFound) { + previous_frame_index = required_previous_frame_index; + Decode(previous_frame_index); + if (Failed()) { + return; + } + } - // If this returns false, we need more data to continue decoding. - if (!PostDecodeProcessing(*i)) - break; + // We try to reuse |previous_frame| as starting state to avoid copying. + // If CanReusePreviousFrameBuffer returns false, we must copy the data + // since |previous_frame| is necessary to decode this or later frames. + // In that case copy the data instead. + ImageFrame& previous_frame = frame_buffer_cache_[previous_frame_index]; + if ((!CanReusePreviousFrameBuffer(index) || + !frame.TakeBitmapDataIfWritable(&previous_frame)) && + !frame.CopyBitmapData(previous_frame)) { + SetFailed(); + return; + } + prior_frame_ = previous_frame_index; + } } - // It is also a fatal error if all data is received and we have decoded all - // frames available but the file is truncated. - if (index >= frame_buffer_cache_.size() - 1 && IsAllDataReceived() && - reader_ && !reader_->ParseCompleted()) - SetFailed(); -} + if (frame.GetStatus() == ImageFrame::kFrameInitialized) { + SkCodec::FrameInfo frame_info; + bool frame_info_received = codec_->getFrameInfo(index, &frame_info); + DCHECK(frame_info_received); -void GIFImageDecoder::Parse(GIFParseQuery query) { - if (Failed()) - return; + SkAlphaType alpha_type = kOpaque_SkAlphaType; + if (frame_info.fAlphaType != kOpaque_SkAlphaType) { + if (premultiply_alpha_) { + alpha_type = kPremul_SkAlphaType; + } else { + alpha_type = kUnpremul_SkAlphaType; + } + } - if (!reader_) { - reader_ = std::make_unique<GIFImageReader>(this); - reader_->SetData(data_); + SkImageInfo image_info = codec_->getInfo() + .makeColorType(kN32_SkColorType) + .makeColorSpace(ColorSpaceForSkImages()) + .makeAlphaType(alpha_type); + + SkCodec::Options options; + options.fFrameIndex = index; + options.fPriorFrame = prior_frame_; + options.fZeroInitialized = SkCodec::kNo_ZeroInitialized; + + SkCodec::Result start_incremental_decode_result = + codec_->startIncrementalDecode(image_info, frame.Bitmap().getPixels(), + frame.Bitmap().rowBytes(), &options); + switch (start_incremental_decode_result) { + case SkCodec::kSuccess: + break; + case SkCodec::kIncompleteInput: + return; + default: + SetFailed(); + return; + } + frame.SetStatus(ImageFrame::kFramePartial); } - if (!reader_->Parse(query)) - SetFailed(); -} - -void GIFImageDecoder::OnInitFrameBuffer(size_t frame_index) { - current_buffer_saw_alpha_ = false; + SkCodec::Result incremental_decode_result = codec_->incrementalDecode(); + switch (incremental_decode_result) { + case SkCodec::kSuccess: { + SkCodec::FrameInfo frame_info; + bool frame_info_received = codec_->getFrameInfo(index, &frame_info); + DCHECK(frame_info_received); + frame.SetHasAlpha(frame_info.fAlphaType != + SkAlphaType::kOpaque_SkAlphaType); + frame.SetPixelsChanged(true); + frame.SetStatus(ImageFrame::kFrameComplete); + PostDecodeProcessing(index); + break; + } + case SkCodec::kIncompleteInput: + frame.SetPixelsChanged(true); + if (FrameIsReceivedAtIndex(index) || IsAllDataReceived()) { + SetFailed(); + } + break; + default: + frame.SetPixelsChanged(true); + SetFailed(); + break; + } } bool GIFImageDecoder::CanReusePreviousFrameBuffer(size_t frame_index) const { - DCHECK(frame_index < frame_buffer_cache_.size()); + DCHECK_LT(frame_index, frame_buffer_cache_.size()); return frame_buffer_cache_[frame_index].GetDisposalMethod() != ImageFrame::kDisposeOverwritePrevious; } +size_t GIFImageDecoder::GetViableReferenceFrameIndex( + size_t dependent_index) const { + DCHECK_LT(dependent_index, frame_buffer_cache_.size()); + + size_t required_previous_frame_index = + frame_buffer_cache_[dependent_index].RequiredPreviousFrameIndex(); + + // Any frame in the range [|required_previous_frame_index|, |dependent_index|) + // which has a disposal method other than kRestorePrevious can be provided as + // the prior frame to SkCodec. + // + // SkCodec sets SkCodec::FrameInfo::fRequiredFrame to the earliest frame which + // can be used. This might come up when several frames update the same + // subregion. If that same subregion is about to be overwritten, it doesn't + // matter which frame in that chain is provided. + DCHECK_NE(required_previous_frame_index, kNotFound); + // Loop backwards because the frames most likely to be in cache are the most + // recent. + for (size_t i = dependent_index - 1; i != required_previous_frame_index; + i--) { + const ImageFrame& frame = frame_buffer_cache_[i]; + + if (frame.GetDisposalMethod() == ImageFrame::kDisposeOverwritePrevious) + continue; + + if (frame.GetStatus() == ImageFrame::kFrameComplete) { + return i; + } + } + + return kNotFound; +} + } // namespace blink |