1 /* 2 * Copyright 2012 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SkImagePriv_DEFINED 9 #define SkImagePriv_DEFINED 10 11 #include "SkImage.h" 12 #include "SkSurface.h" 13 14 enum SkCopyPixelsMode { 15 kIfMutable_SkCopyPixelsMode, //!< only copy src pixels if they are marked mutable 16 kAlways_SkCopyPixelsMode, //!< always copy src pixels (even if they are marked immutable) 17 kNever_SkCopyPixelsMode, //!< never copy src pixels (even if they are marked mutable) 18 }; 19 20 // A good size for creating shader contexts on the stack. 21 enum {kSkBlitterContextSize = 3332}; 22 23 // If alloc is non-nullptr, it will be used to allocate the returned SkShader, and MUST outlive 24 // the SkShader. 25 sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode, SkShader::TileMode, 26 const SkMatrix* localMatrix, SkCopyPixelsMode); 27 28 /** 29 * Examines the bitmap to decide if it can share the existing pixelRef, or 30 * if it needs to make a deep-copy of the pixels. 31 * 32 * The bitmap's pixelref will be shared if either the bitmap is marked as 33 * immutable, or CopyPixelsMode allows it. Shared pixel refs are also 34 * locked when kLocked_SharedPixelRefMode is specified. 35 * 36 * Passing kLocked_SharedPixelRefMode allows the image's peekPixels() method 37 * to succeed, but it will force any lazy decodes/generators to execute if 38 * they exist on the pixelref. 39 * 40 * It is illegal to call this with a texture-backed bitmap. 41 * 42 * If the bitmap's colortype cannot be converted into a corresponding 43 * SkImageInfo, or the bitmap's pixels cannot be accessed, this will return 44 * nullptr. 45 */ 46 extern sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap&, SkCopyPixelsMode); 47 48 /** 49 * Similar to SkMakeImageFromRasterBitmap, this wraps a |src| bitmap in an image. 50 * 51 * It also promises to transform the bitmap into the |dst| color space before it 52 * is drawn. The transform will happen lazily. 53 * 54 * If |id| is non-zero, the output image will use that as its unique id. Otherwise, 55 * it will generate a new id. 56 */ 57 extern sk_sp<SkImage> SkMakeImageInColorSpace(const SkBitmap& src, sk_sp<SkColorSpace> dst, 58 uint32_t id, 59 SkCopyPixelsMode = kNever_SkCopyPixelsMode); 60 61 // Given an image created from SkNewImageFromBitmap, return its pixelref. This 62 // may be called to see if the surface and the image share the same pixelref, 63 // in which case the surface may need to perform a copy-on-write. 64 extern const SkPixelRef* SkBitmapImageGetPixelRef(const SkImage* rasterImage); 65 66 /** 67 * Will attempt to upload and lock the contents of the image as a texture, so that subsequent 68 * draws to a gpu-target will come from that texture (and not by looking at the original image 69 * src). In particular this is intended to use the texture even if the image's original content 70 * changes subsequent to this call (i.e. the src is mutable!). 71 * 72 * All successful calls must be balanced by an equal number of calls to SkImage_unpinAsTexture(). 73 * 74 * Once in this "pinned" state, the image has all of the same thread restrictions that exist 75 * for a natively created gpu image (e.g. SkImage::MakeFromTexture) 76 * - all drawing, pinning, unpinning must happen in the same thread as the GrContext. 77 * 78 * @return true if the image was successfully uploaded and locked into a texture 79 */ 80 bool SkImage_pinAsTexture(const SkImage*, GrContext*); 81 82 /** 83 * The balancing call to a successful invokation of SkImage_pinAsTexture. When a balanced number of 84 * calls have been made, then the "pinned" texture is free to be purged, etc. This also means that a 85 * subsequent "pin" call will look at the original content again, and if its uniqueID/generationID 86 * has changed, then a newer texture will be uploaded/pinned. 87 * 88 * The context passed to unpin must match the one passed to pin. 89 */ 90 void SkImage_unpinAsTexture(const SkImage*, GrContext*); 91 92 /** 93 * Returns a new image containing the same pixel values as the source, but with a different color 94 * space assigned. This performs no color space conversion. Primarily used in tests, to visualize 95 * the results of rendering in wide or narrow gamuts. 96 */ 97 sk_sp<SkImage> SkImageMakeRasterCopyAndAssignColorSpace(const SkImage*, SkColorSpace*); 98 99 #endif 100