SkFrameHolder Class Reference

#include <SkFrameHolder.h>

Inheritance diagram for SkFrameHolder:

Public Member Functions
	SkFrameHolder ()
virtual	~SkFrameHolder ()
int	screenWidth () const
int	screenHeight () const
void	setAlphaAndRequiredFrame (SkFrame *)
const SkFrame *	getFrame (int i) const
Public Member Functions inherited from SkNoncopyable
	SkNoncopyable ()=default
	SkNoncopyable (SkNoncopyable &&)=default
SkNoncopyable &	operator= (SkNoncopyable &&)=default

Protected Member Functions
virtual const SkFrame *	onGetFrame (int i) const =0

Protected Attributes
int	fScreenWidth
int	fScreenHeight

Detailed Description

Base class for an object which holds the SkFrames of an image sequence.

Definition at line 169 of file SkFrameHolder.h.

Constructor & Destructor Documentation

SkFrameHolder()

SkFrameHolder::SkFrameHolder ( )

inline

Definition at line 171 of file SkFrameHolder.h.

        : fScreenWidth(0)
        , fScreenHeight(0)
    {}

~SkFrameHolder()

virtual SkFrameHolder::~SkFrameHolder ( )

inlinevirtual

Definition at line 176 of file SkFrameHolder.h.

{}

Member Function Documentation

getFrame()

const SkFrame * SkFrameHolder::getFrame ( int  i ) const

inline

Return the frame with frameId i.

Definition at line 195 of file SkFrameHolder.h.

                                         {
        return this->onGetFrame(i);
    }

onGetFrame()

virtual const SkFrame * SkFrameHolder::onGetFrame ( int  i ) const

protectedpure virtual

Implemented in SkJpegxlCodecPriv, and SkWuffsFrameHolder.

screenHeight()

int SkFrameHolder::screenHeight ( ) const

inline

Definition at line 183 of file SkFrameHolder.h.

{ return fScreenHeight; }

screenWidth()

int SkFrameHolder::screenWidth ( ) const

inline

Size of the image. Each frame will be contained in these dimensions (possibly after clipping).

Definition at line 182 of file SkFrameHolder.h.

{ return fScreenWidth; }

setAlphaAndRequiredFrame()

void SkFrameHolder::setAlphaAndRequiredFrame

(

SkFrame *

frame

)

Compute the opacity and required frame, based on the frame's reportedAlpha and how it blends with prior frames.

Definition at line 972 of file SkCodec.cpp.

                                                           {
    const bool reportsAlpha = frame->reportedAlpha() != SkEncodedInfo::kOpaque_Alpha;
    const auto screenRect = SkIRect::MakeWH(fScreenWidth, fScreenHeight);
    const auto frameRect = frame_rect_on_screen(frame->frameRect(), screenRect);
 
    const int i = frame->frameId();
    if (0 == i) {
        frame->setHasAlpha(reportsAlpha || frameRect != screenRect);
        frame->setRequiredFrame(SkCodec::kNoFrame);  // IND1
        return;
    }
 
 
    const bool blendWithPrevFrame = frame->getBlend() == SkCodecAnimation::Blend::kSrcOver;
    if ((!reportsAlpha || !blendWithPrevFrame) && frameRect == screenRect) {
        frame->setHasAlpha(reportsAlpha);
        frame->setRequiredFrame(SkCodec::kNoFrame);  // IND2
        return;
    }
 
    const SkFrame* prevFrame = this->getFrame(i-1);
    while (prevFrame->getDisposalMethod() == SkCodecAnimation::DisposalMethod::kRestorePrevious) {
        const int prevId = prevFrame->frameId();
        if (0 == prevId) {
            frame->setHasAlpha(true);
            frame->setRequiredFrame(SkCodec::kNoFrame);  // IND3
            return;
        }
 
        prevFrame = this->getFrame(prevId - 1);
    }
 
    const bool clearPrevFrame = restore_bg(*prevFrame);
    auto prevFrameRect = frame_rect_on_screen(prevFrame->frameRect(), screenRect);
 
    if (clearPrevFrame) {
        if (prevFrameRect == screenRect || independent(*prevFrame)) {
            frame->setHasAlpha(true);
            frame->setRequiredFrame(SkCodec::kNoFrame);  // IND4
            return;
        }
    }
 
    if (reportsAlpha && blendWithPrevFrame) {
        // Note: We could be more aggressive here. If prevFrame clears
        // to background color and covers its required frame (and that
        // frame is independent), prevFrame could be marked independent.
        // Would this extra complexity be worth it?
        frame->setRequiredFrame(prevFrame->frameId());  // DEP5
        frame->setHasAlpha(prevFrame->hasAlpha() || clearPrevFrame);
        return;
    }
 
    while (frameRect.contains(prevFrameRect)) {
        const int prevRequiredFrame = prevFrame->getRequiredFrame();
        if (prevRequiredFrame == SkCodec::kNoFrame) {
            frame->setRequiredFrame(SkCodec::kNoFrame);  // IND6
            frame->setHasAlpha(true);
            return;
        }
 
        prevFrame = this->getFrame(prevRequiredFrame);
        prevFrameRect = frame_rect_on_screen(prevFrame->frameRect(), screenRect);
    }
 
    frame->setRequiredFrame(prevFrame->frameId());  // DEP7
    if (restore_bg(*prevFrame)) {
        frame->setHasAlpha(true);
        return;
    }
    SkASSERT(prevFrame->getDisposalMethod() == SkCodecAnimation::DisposalMethod::kKeep);
    frame->setHasAlpha(prevFrame->hasAlpha() || (reportsAlpha && !blendWithPrevFrame));
}

Member Data Documentation

fScreenHeight

int SkFrameHolder::fScreenHeight

protected

Definition at line 201 of file SkFrameHolder.h.

fScreenWidth

int SkFrameHolder::fScreenWidth

protected

Definition at line 200 of file SkFrameHolder.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/codec/SkFrameHolder.h
• third_party/skia/src/codec/SkCodec.cpp