SkImagePriv.h File Reference

#include "include/core/SkImage.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTileMode.h"

Go to the source code of this file.

Enumerations
enum	SkCopyPixelsMode { kIfMutable_SkCopyPixelsMode , kAlways_SkCopyPixelsMode , kNever_SkCopyPixelsMode }

Functions
sk_sp< SkShader >	SkMakeBitmapShaderForPaint (const SkPaint &paint, const SkBitmap &src, SkTileMode, SkTileMode, const SkSamplingOptions &, const SkMatrix *localMatrix, SkCopyPixelsMode)
SkRect	SkModifyPaintAndDstForDrawImageRect (const SkImage *image, const SkSamplingOptions &, SkRect src, SkRect dst, bool strictSrcSubset, SkPaint *paint)
SK_SPI sk_sp< SkImage >	SkMakeImageFromRasterBitmap (const SkBitmap &, SkCopyPixelsMode)
const SkPixelRef *	SkBitmapImageGetPixelRef (const SkImage *rasterImage)

Enumeration Type Documentation

SkCopyPixelsMode

enum SkCopyPixelsMode

Enumerator
kIfMutable_SkCopyPixelsMode	only copy src pixels if they are marked mutable
kAlways_SkCopyPixelsMode	always copy src pixels (even if they are marked immutable)
kNever_SkCopyPixelsMode	never copy src pixels (even if they are marked mutable)

Definition at line 17 of file SkImagePriv.h.

                      {
    kIfMutable_SkCopyPixelsMode,  //!< only copy src pixels if they are marked mutable
    kAlways_SkCopyPixelsMode,     //!< always copy src pixels (even if they are marked immutable)
    kNever_SkCopyPixelsMode,      //!< never copy src pixels (even if they are marked mutable)
};

Function Documentation

SkBitmapImageGetPixelRef()

const SkPixelRef * SkBitmapImageGetPixelRef

(

const SkImage *

rasterImage

)

Definition at line 190 of file SkImage_Raster.cpp.

                                                                 {
    return ((const SkImage_Raster*)image)->getPixelRef();
}

SkMakeBitmapShaderForPaint()

sk_sp< SkShader > SkMakeBitmapShaderForPaint	(	const SkPaint &	paint,
		const SkBitmap &	src,
		SkTileMode	tmx,
		SkTileMode	tmy,
		const SkSamplingOptions &	sampling,
		const SkMatrix *	localMatrix,
		SkCopyPixelsMode	mode
	)

Definition at line 358 of file SkImageShader.cpp.

                                                                                               {
    auto s = SkImageShader::Make(SkMakeImageFromRasterBitmap(src, mode),
                                 tmx, tmy, sampling, localMatrix);
    if (!s) {
        return nullptr;
    }
    if (SkColorTypeIsAlphaOnly(src.colorType()) && paint.getShader()) {
        // Compose the image shader with the paint's shader. Alpha images+shaders should output the
        // texture's alpha multiplied by the shader's color. DstIn (d*sa) will achieve this with
        // the source image and dst shader (MakeBlend takes dst first, src second).
        s = SkShaders::Blend(SkBlendMode::kDstIn, paint.refShader(), std::move(s));
    }
    return s;
}

SkMakeImageFromRasterBitmap()

SK_SPI sk_sp< SkImage > SkMakeImageFromRasterBitmap	(	const SkBitmap &	bm,
		SkCopyPixelsMode	cpm
	)

Examines the bitmap to decide if it can share the existing pixelRef, or if it needs to make a deep-copy of the pixels.

The bitmap's pixelref will be shared if either the bitmap is marked as immutable, or CopyPixelsMode allows it. Shared pixel refs are also locked when kLocked_SharedPixelRefMode is specified.

Passing kLocked_SharedPixelRefMode allows the image's peekPixels() method to succeed, but it will force any lazy decodes/generators to execute if they exist on the pixelref.

It is illegal to call this with a texture-backed bitmap.

If the bitmap's colortype cannot be converted into a corresponding SkImageInfo, or the bitmap's pixels cannot be accessed, this will return nullptr.

Definition at line 182 of file SkImage_Raster.cpp.

                                                                                     {
    if (!SkImageInfoIsValid(bm.info()) || bm.rowBytes() < bm.info().minRowBytes()) {
        return nullptr;
    }
 
    return SkMakeImageFromRasterBitmapPriv(bm, cpm, kNeedNewImageUniqueID);
}

SkModifyPaintAndDstForDrawImageRect()

SkRect SkModifyPaintAndDstForDrawImageRect	(	const SkImage *	image,
		const SkSamplingOptions &	sampling,
		SkRect	src,
		SkRect	dst,
		bool	strictSrcSubset,
		SkPaint *	paint
	)

Definition at line 376 of file SkImageShader.cpp.

                                                           {
    // The paint should have already been cleaned for a regular drawImageRect, e.g. no path
    // effect and is a fill.
    SkASSERT(paint);
    SkASSERT(paint->getStyle() == SkPaint::kFill_Style && !paint->getPathEffect());
 
    SkASSERT(image);
    SkRect imgBounds = SkRect::Make(image->bounds());
 
    SkASSERT(src.isFinite() && dst.isFinite() && dst.isSorted());
    SkMatrix localMatrix = SkMatrix::RectToRect(src, dst);
    if (!imgBounds.contains(src)) {
        if (!src.intersect(imgBounds)) {
            return SkRect::MakeEmpty(); // Nothing to draw for this entry
        }
        // Update dst to match smaller src
        dst = localMatrix.mapRect(src);
    }
 
    bool imageIsAlphaOnly = SkColorTypeIsAlphaOnly(image->colorType());
 
    sk_sp<SkShader> imgShader;
    if (strictSrcSubset) {
        imgShader = SkImageShader::MakeSubset(sk_ref_sp(image), src,
                                              SkTileMode::kClamp, SkTileMode::kClamp,
                                              sampling, &localMatrix);
    } else {
        imgShader = image->makeShader(SkTileMode::kClamp, SkTileMode::kClamp,
                                      sampling, &localMatrix);
    }
    if (!imgShader) {
        return SkRect::MakeEmpty();
    }
    if (imageIsAlphaOnly && paint->getShader()) {
        // Compose the image shader with the paint's shader. Alpha images+shaders should output the
        // texture's alpha multiplied by the shader's color. DstIn (d*sa) will achieve this with
        // the source image and dst shader (MakeBlend takes dst first, src second).
        imgShader = SkShaders::Blend(SkBlendMode::kDstIn, paint->refShader(), std::move(imgShader));
    }
 
    paint->setShader(std::move(imgShader));
    return dst;
}