firefox-main/gfx/skia/skia/src/core
Name Description Size Coverage
Sk4px.h 8880 -
SkAAClip.cpp Data runs are packed [count, alpha] 57265 -
SkAAClip.h Allocates a mask the size of the aaclip, and expands its data into the mask, using kA8_Format. Used for tests and visualization purposes. 3513 -
SkAdvancedTypefaceMetrics.h \class SkAdvancedTypefaceMetrics The SkAdvancedTypefaceMetrics class is used by the PDF backend to correctly embed typefaces. This class is created and filled in with information by SkTypeface::getAdvancedMetrics. 2918 -
SkAlphaRuns.cpp 1763 -
SkAlphaRuns.h Sparse array of run-length-encoded alpha (supersampling coverage) values. Sparseness allows us to independently compose several paths into the same SkAlphaRuns buffer. 6127 -
SkAnalyticEdge.cpp 29097 -
SkAnalyticEdge.h 4826 -
SkAnnotation.cpp 1432 -
SkAnnotationKeys.h Returns the canonical key whose payload is a URL 728 -
SkATrace.cpp 3104 -
SkATrace.h This class is used to support ATrace in android apps. It hooks into the SkEventTracer system. It currently supports the macros TRACE_EVENT*, TRACE_EVENT_INSTANT*, and TRACE_EVENT_BEGIN/END*. For versions of these calls that take additoinal args and value pairs we currently just drop them and report only the name. Since ATrace is a simple push and pop system (all traces are fully nested), if using BEGIN and END you should also make sure your calls are properly nested (i.e. if startA is before startB, then endB is before endA). 2225 -
SkAutoBlitterChoose.h 2466 -
SkAutoPixmapStorage.cpp 2047 -
SkAutoPixmapStorage.h Leave the moved-from object in a free-but-valid state. 2795 -
SkBBHFactory.cpp 478 -
SkBigPicture.cpp 2473 -
SkBigPicture.h 2370 -
SkBitmap.cpp 22409 -
SkBitmapCache.cpp Use this for bitmapcache and mipmapcache entries. 10015 -
SkBitmapCache.h Search based on the desc. If found, returns true and result will be set to the matching bitmap with its pixels already locked. 1932 -
SkBitmapDevice.cpp 26572 -
SkBitmapDevice.h Construct a new device with the specified bitmap as its backend. It is valid for the bitmap to have no pixels associated with it. In that case, any drawing to this device will have no effect. 5926 -
SkBitmapProcState.cpp 22887 -
SkBitmapProcState.h Given the byte size of the index buffer to be passed to the matrix proc, return the maximum number of resulting pixels that can be computed (i.e. the number of SkPMColor values to be written by the sample proc). This routine takes into account that filtering and scale-vs-affine affect the amount of buffer space needed. Only valid to call after chooseProcs (setContext) has been called. It is safe to call this inside the shader's shadeSpan() method. 8635 -
SkBitmapProcState_matrixProcs.cpp The decal_ functions require that 1. dx > 0 2. [fx, fx+dx, fx+2dx, fx+3dx, ... fx+(count-1)dx] are all <= maxX In addition, we use SkFixed3232 to keep more precision than just SkFixed, so we will abort the decal_ call if dx is very small, since the decal_ function just operates on SkFixed. If that were changed, we could skip the very_small test here. 19421 -
SkBitmapProcState_opts.cpp 1349 -
SkBitmapProcState_opts_lasx.cpp 1048 -
SkBitmapProcState_opts_ssse3.cpp 997 -
SkBlenderBase.h Encapsulates a blend function, including non-public APIs. Blends combine a source color (the result of our paint) and destination color (from the canvas) into a final color. 2133 -
SkBlendMode.cpp 11000 -
SkBlendModeBlender.cpp 3859 -
SkBlendModeBlender.h 961 -
SkBlendModePriv.h Sentinel value for SkBlendMode enum. Will never be a valid enum value, but will be storable in a byte. 1324 -
SkBlitBWMaskTemplate.h SK_BLITBWMASK_NAME name of function(const SkPixmap& dstPixmap, const SkMask& mask, const SkIRect& clip, SK_BLITBWMASK_ARGS) SK_BLITBWMASK_ARGS list of additional arguments to SK_BLITBWMASK_NAME, beginning with a comma SK_BLITBWMASK_BLIT8 name of function(U8CPU byteMask, SK_BLITBWMASK_DEVTYPE* dst, int x, int y) SK_BLITBWMASK_GETADDR either writable_addr[8,16,32] SK_BLITBWMASK_DEVTYPE either U32 or U16 or U8 4384 -
SkBlitMask.h 572 -
SkBlitMask_opts.cpp 1032 -
SkBlitMask_opts_ssse3.cpp 962 -
SkBlitRow.h Function pointer that blends 32bit colors onto a 32bit destination. @param dst array of dst 32bit colors @param src array of src 32bit colors (w/ or w/o alpha) @param count number of colors to blend @param alpha global alpha to be applied to all src colors 1340 -
SkBlitRow_D32.cpp 19908 -
SkBlitRow_opts.cpp 1276 -
SkBlitRow_opts_hsw.cpp 1015 -
SkBlitRow_opts_lasx.cpp 1094 -
SkBlitter.cpp 27020 -
SkBlitter.h SkBlitter and its subclasses are responsible for actually writing pixels into memory. Besides efficiency, they handle clipping and antialiasing. A SkBlitter subclass contains all the context needed to generate pixels for the destination and how src/generated pixels map to the destination. The coordinates passed to the blitX calls are in destination pixel space. 10975 -
SkBlitter_A8.cpp 9499 -
SkBlitter_A8.h ignored 1828 -
SkBlitter_ARGB32.cpp We want all of these in 5bits, hence the shifts in case one of them (green) is 6bits. 87773 -
SkBlitter_Sprite.cpp 8802 -
SkBlurEngine.cpp 73683 -
SkBlurEngine.h SkBlurEngine is a backend-agnostic provider of blur algorithms. Each Skia backend defines a blur engine with a set of supported algorithms and/or implementations. A given implementation may be optimized for a particular color type, sigma range, or available hardware. Each engine and its algorithms are assumed to operate only on SkImages corresponding to its Skia backend, and will produce output SkImages of the same type. Algorithms are allowed to specify a maximum supported sigma. If the desired sigma is higher than this, the input image and output region must be downscaled by the caller before invoking the algorithm. This is to provide the most flexibility for input representation (e.g. directly rasterize at half resolution or apply deferred filter effects during the first downsample pass). skif::FilterResult::Builder::blur() is a convenient wrapper around the blur engine and automatically handles resizing. 15487 -
SkBlurMask.cpp 24877 -
SkBlurMask.h Helper functions for analytic rectangle blurs 4557 -
SkBlurMaskFilterImpl.cpp 23959 -
SkBlurMaskFilterImpl.h 2769 -
SkCachedData.cpp 4717 -
SkCachedData.h Attaching a data to to a SkResourceCache (only one at a time) enables the data to be unlocked when the cache is the only owner, thus freeing it to be purged (assuming the data is backed by a SkDiscardableMemory). When attached, it also automatically attempts to "lock" the data when the first client ref's the data (typically from a find(key, visitor) call). Thus the data will always be "locked" when a non-cache has a ref on it (whether or not the lock succeeded to recover the memory -- check data() to see if it is nullptr). 3436 -
SkCanvas.cpp Return true if the drawing this rect would hit every pixels in the canvas. Returns false if - rect does not contain the canvas' bounds - paint is not fill - paint would blur or otherwise change the coverage of the rect 119091 -
SkCanvas_Raster.cpp 1780 -
SkCanvasPriv.cpp 13144 -
SkCanvasPriv.h This constant is trying to balance the speed of ref'ing a subpicture into a parent picture, against the playback cost of recursing into the subpicture to get at its actual ops. For now we pick a conservatively small value, though measurement (and other heuristics like the type of ops contained) may justify changing this value. 7072 -
SkCapabilities.cpp 618 -
SkChecksum.cpp 3544 -
SkChecksum.h Our hash functions are exposed as SK_SPI (e.g. SkParagraph) 3969 -
SkClipStack.cpp 34597 -
SkClipStack.h An element of the clip stack. It represents a shape combined with the prevoius clip using a set operator. Each element can be antialiased or not. 19860 -
SkClipStackDevice.cpp doAA= 4301 -
SkClipStackDevice.h 1779 -
SkColor.cpp 4943 -
SkColorData.h See ITU-R Recommendation BT.709 at http://www.itu.int/rec/R-REC-BT.709/ . 14007 -
SkColorFilter.cpp 2469 -
SkColorFilterPriv.h 1242 -
SkColorPriv.h Turn 0..255 into 0..256 by adding 1 at the half-way point. Used to turn a byte into a scale value, so that we can say scale * value >> 8 instead of alpha * value / 255. In debugging, asserts that alpha is 0..255 5339 -
SkColorSpace.cpp 17867 -
SkColorSpacePriv.h 2730 -
SkColorSpaceXformSteps.cpp 11343 -
SkColorSpaceXformSteps.h 2146 -
SkColorTable.cpp 1599 -
SkCompressedDataUtils.cpp 0 11153 -
SkCompressedDataUtils.h Returns the data size for the given SkTextureCompressionType 1613 -
SkContourMeasure.cpp if the dash as a zero-length on segment, add a corresponding zero-length line. The stroke code will add end caps to zero length lines as appropriate 26542 -
SkConvertPixels.cpp 10832 -
SkConvertPixels.h 454 -
SkCoreBlitters.h The storage for shaderContext is owned by the caller, but the object itself is not. The blitter only ensures that the storage always holds a live object, but it may exchange that object. 4898 -
SkCpu.cpp 3787 -
SkCpu.h 3215 -
SkCPUContext.cpp 853 -
SkCPUContextImpl.h 501 -
SkCPURecorder.cpp 452 -
SkCPURecorderImpl.h 672 -
SkCubicClipper.cpp 4707 -
SkCubicClipper.h This class is initialized with a clip rectangle, and then can be fed cubics, which must already be monotonic in Y. In the future, it might return a series of segments, allowing it to clip also in X, to ensure that all segments fit in a finite coordinate system. 959 -
SkCubicMap.cpp 3148 -
SkData.cpp This constructor means we are inline with our fPtr's contents. Thus we set fPtr to point right after this. 6429 -
SkDataTable.cpp 3684 -
SkDebugUtils.h 1600 -
SkDescriptor.cpp 7296 -
SkDescriptor.h 3435 -
SkDevice.cpp 26643 -
SkDevice.h SkDevice is the internal API and implementation that SkCanvas will use to perform rendering and implement the saveLayer abstraction. A device wraps some pixel allocation (for non-document based devices) or wraps some other container that stores rendering operations. The drawing operations perform equivalently to their corresponding functions in SkCanvas except that the canvas is responsible for all SkImageFilters. An image filter is applied by automatically creating a layer, drawing the filter-less paint into the layer, and then evaluating the filter on the layer's image. Each layer in an SkCanvas stack is represented by an SkDevice instance that was created by the parent SkDevice (up to the canvas's base device). In most cases these devices will be pixel aligned with one another but may differ in size based on the known extent of the active clip. In complex image filtering scenarios, they may not be axis aligned, although the effective pixel size should remain approximately equal across all devices in a canvas. While SkCanvas manages a single stack of layers and canvas transforms, SkDevice does not have a stack of transforms. Instead, it has a single active transform that is modified as needed by SkCanvas. However, SkDevices are the means by which SkCanvas manages the clip stack because each layer's clip stack starts anew (although the layer's results are then clipped by its parent's stack when it is restored). 29443 -
SkDistanceFieldGen.cpp 19952 -
SkDistanceFieldGen.h Given 8-bit mask data, generate the associated distance field @param distanceField The distance field to be generated. Should already be allocated by the client with the padding above. @param image 8-bit mask we're using to generate the distance field. @param w Width of the original image. @param h Height of the original image. @param rowBytes Size of each row in the image, in bytes 3749 -
SkDocument.cpp 2139 -
SkDraw.cpp 47238 -
SkDraw.h Helper function that creates a mask from a path and a required maskfilter. Note however, that the resulting mask will not have been actually filtered, that must be done afterwards (by calling filterMask). The maskfilter is provided solelely to assist in computing the mask's bounds (if the mode requests that). 10017 -
SkDraw_atlas.cpp 5647 -
SkDraw_text.cpp UINT16_MIN 5461 -
SkDraw_vertices.cpp 13732 -
SkDrawable.cpp 2507 -
SkDrawProcs.h If the current paint is set to stroke and the stroke-width when applied to the matrix is <= 1.0, then this returns true, and sets coverage (simulating a stroke by drawing a hairline with partial coverage). If any of these conditions are false, then this returns false and coverage is ignored. 1301 -
SkDrawShadowInfo.cpp 9576 -
SkDrawShadowInfo.h 3731 -
SkDrawTypes.h 407 -
SkEdge.cpp In setLine, setQuadratic, setCubic, the first thing we do is to convert the points into FDot6. This is modulated by the shift parameter, which will either be 0, or something like 2 for antialiasing. In the float case, we want to turn the float into .6 by saying pt * 64, or pt * 256 for antialiasing. This is implemented as 1 << (shift + 6). In the fixed case, we want to turn the fixed into .6 by saying pt >> 10, or pt >> 8 for antialiasing. This is implemented as pt >> (10 - shift). 19387 -
SkEdge.h SkEdge approximates monotonic curves with one or more line segments in a way that makes computing scan lines (rows of horizontal pixels between multiple edges) efficient and easier to do. In particular, the line segments will be in terms of Y instead of a general Bezier curve which is in terms of t. The number of segments will be a power of 2 (for easy division) based on internal heuristics about how bendy the curve is. The general flow is to create an SkEdge (or one of its subclasses), use the fields to represent a line segment, and then use updateQuadratic or updateCubic to update the fields with the next line segment's values. 6950 -
SkEdgeBuilder.cpp 12921 -
SkEdgeBuilder.h 2985 -
SkEdgeClipper.cpp src[] must be monotonic in Y. This routine copies src into dst, and sorts it to be increasing in Y. If it had to reverse the order of the points, it returns true, otherwise it returns false 19478 -
SkEdgeClipper.h This is basically an iterator. It is initialized with an edge and a clip, and then next() is called until it returns kDone_Verb. 2317 -
SkEffectPriv.h 992 -
SkEnumerate.h 4443 -
SkExecutor.cpp workList 7458 -
SkFDot6.h This uses the magic number approach suggested here: http://stereopsis.com/sree/fpu2006.html and used in _cairo_fixed_from_double. It does banker's rounding (i.e. round to nearest even) 1924 -
SkFlattenable.cpp 4300 -
SkFont.cpp 13940 -
SkFont_serial.cpp 3475 -
SkFontDescriptor.cpp 11081 -
SkFontDescriptor.h Makes a copy of the data in 'axis'. 6487 -
SkFontMetricsPriv.cpp 2197 -
SkFontMetricsPriv.h 526 -
SkFontMgr.cpp 10242 -
SkFontPriv.h This is the size we use when we ask for a glyph's path. We then post-transform it as we draw to match the request. This is done to try to re-use cache entries for the path. This value is somewhat arbitrary. In theory, it could be 1, since we store paths as floats. However, we get the path from the font scaler, and it may represent its paths as fixed-point (or 26.6), so we shouldn't ask for something too big (might overflow 16.16) or too small (underflow 26.6). This value could track kMaxSizeForGlyphCache, assuming the above constraints, but since we ask for unhinted paths, the two values need not match per-se. 4369 -
SkFontStream.cpp Return the number of tables, or if this is a TTC (collection), return the number of tables in the first element of the collection. In either case, if offsetToDir is not-null, set it to the offset to the beginning of the table headers (SkSFNTDirEntry), relative to the start of the stream. On an error, return 0 for number of tables, and ignore offsetToDir 6746 -
SkFontStream.h Return the number of shared directories inside a TTC sfnt, or return 1 if the stream is a normal sfnt (ttf). If there is an error or no directory is found, return 0. Note: the stream is rewound initially, but is returned at an arbitrary read offset. 1502 -
SkGaussFilter.cpp 3528 -
SkGaussFilter.h 945 -
SkGeometry.cpp From Numerical Recipes in C. Q = -1/2 (B + sign(B) sqrt[B*B - 4*A*C]) x1 = Q / A x2 = C / Q 62158 -
SkGeometry.h Given a quadratic equation Ax^2 + Bx + C = 0, return 0, 1, 2 roots for the equation. 20068 -
SkGlobalInitialization_core.cpp 483 -
SkGlyph.cpp 24765 -
SkGlyph.h 24985 -
SkGlyphRunPainter.cpp 19388 -
SkGlyphRunPainter.h 1235 -
SkGraphics.cpp 3776 -
SkIDChangeListener.cpp Used to be notified when a gen/unique ID is invalidated, typically to preemptively purge associated items from a cache that are no longer reachable. The listener can be marked for deregistration if the cached item is remove before the listener is triggered. This prevents unbounded listener growth when cache items are routinely removed before the gen ID/unique ID is invalidated. 2016 -
SkImageFilter.cpp Returns the number of inputs this filter will accept (some inputs can be NULL). 14993 -
SkImageFilter_Base.h Request a new filtered image to be created from the src image. The returned skif::Image provides both the pixel data and the origin point that it should be drawn at, relative to the layer space defined by the provided context. If the result image cannot be created, or the result would be transparent black, returns a skif::Image that has a null special image, in which its origin should be ignored. TODO: Right now the imagefilters sometimes return empty result bitmaps/ specialimages. That doesn't seem quite right. 18113 -
SkImageFilterCache.cpp 5266 -
SkImageFilterCache.h 3212 -
SkImageFilterTypes.cpp 113072 -
SkImageFilterTypes.h 60560 -
SkImageGenerator.cpp 1348 -
SkImageInfo.cpp 11063 -
SkImageInfoPriv.h 9094 -
SkImagePriv.h 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. 3055 -
SkIPoint16.h \struct SkIPoint16 SkIPoint16 holds two 16 bit integer coordinates. 1263 -
SkKnownRuntimeEffects.cpp 24858 -
SkKnownRuntimeEffects.h 6102 -
SkLatticeIter.cpp Divs must be in increasing order with no duplicates. 10217 -
SkLatticeIter.h Disect a lattice request into an sequence of src-rect / dst-rect pairs 2337 -
SkLineClipper.cpp 8864 -
SkLineClipper.h Clip the line pts[0]...pts[1] against clip, ignoring segments that lie completely above or below the clip. For portions to the left or right, turn those into vertical line segments that are aligned to the edge of the clip. Return the number of line segments that result, and store the end-points of those segments sequentially in lines as follows: 1st segment: lines[0]..lines[1] 2nd segment: lines[1]..lines[2] 3rd segment: lines[2]..lines[3] 1541 -
SkLocalMatrixImageFilter.cpp 3832 -
SkLocalMatrixImageFilter.h Wraps another imagefilter + matrix, such that using this filter will give the same result as using the wrapped filter with the matrix applied to its context. 2454 -
SkLRUCache.h context 3756 -
SkM44.cpp 12755 -
SkMallocPixelRef.cpp 2773 -
SkMask.cpp returns the product if it is positive and fits in 31 bits. Otherwise this returns 0. 3474 -
SkMask.h \class SkMask SkMask is used to describe alpha bitmaps, either 1bit, 8bit, or the 3-channel 3D format. These are passed to SkMaskFilter objects. 11877 -
SkMaskBlurFilter.cpp 37741 -
SkMaskBlurFilter.h 1049 -
SkMaskCache.cpp 6882 -
SkMaskCache.h On success, return a ref to the SkCachedData that holds the pixels, and have mask already point to that memory. On failure, return nullptr. 1706 -
SkMaskFilter.cpp 828 -
SkMaskFilterBase.cpp 12363 -
SkMaskFilterBase.h Returns the format of the resulting mask that this subclass will return when its filterMask() method is called. 8942 -
SkMaskGamma.cpp static 5011 -
SkMaskGamma.h SkColorSpaceLuminance is used to convert luminances to and from linear and perceptual color spaces. Luma is used to specify a linear luminance value [0.0, 1.0]. Luminance is used to specify a luminance value in an arbitrary color space [0.0, 1.0]. 10080 -
SkMasks.cpp Used to convert 1-7 bit color components into 8-bit color components 4699 -
SkMasks.h 1443 -
SkMatrix.cpp 62241 -
SkMatrixInvert.cpp 5244 -
SkMatrixInvert.h Computes the inverse of `inMatrix`, passed in column-major order. `inMatrix` and `outMatrix` are allowed to point to the same array of scalars in memory. `outMatrix` is allowed to be null. The return value is the determinant of the input matrix. If zero is returned, the matrix was non-invertible, and `outMatrix` has been left in an indeterminate state. 868 -
SkMatrixPriv.h Attempt to map the rect through the inverse of the matrix. If it is not invertible, then this returns false and dst is unchanged. 8885 -
SkMatrixUtils.h Given a matrix, size and an antialias setting, return true if the computed dst-rect would align such that there is a 1-to-1 coorspondence between src and dst pixels. This can be called by drawing code to see if drawBitmap can be turned into drawSprite (which is faster). The src-rect is defined to be { 0, 0, size.width(), size.height() } 1352 -
SkMD5.cpp MD5 basic transformation. Transforms state based on block. 10895 -
SkMD5.h Calculate a 128-bit MD5 message-digest of the bytes sent to this stream. 1302 -
SkMemset.h 720 -
SkMemset_opts.cpp 1232 -
SkMemset_opts_avx.cpp 1135 -
SkMemset_opts_erms.cpp 4568 -
SkMesh.cpp 36973 -
SkMeshPriv.h A varying is dead if it is never referenced OR it is only referenced as a passthrough for local coordinates. In the latter case, its index will returned as PassthroughLocalCoordsVaryingIndex. Our analysis is not very sophisticated so this is determined conservatively. 5116 -
SkMessageBus.h The following method must have a specialization for type 'Message': bool SkShouldPostMessageToBus(const Message&, IDType msgBusUniqueID) We may want to consider providing a default template implementation, to avoid this requirement by sending to all inboxes when the specialization for type 'Message' is not present. 6178 -
SkMipmap.cpp 9721 -
SkMipmap.h SkMipmap will generate mipmap levels when given a base mipmap level image. Any function which deals with mipmap levels indices will start with index 0 being the first mipmap level which was generated. Said another way, it does not include the base level in its range. 3841 -
SkMipmapAccessor.cpp 4167 -
SkMipmapAccessor.h 1720 -
SkMipmapBuilder.cpp factoryProc= 1040 -
SkMipmapBuilder.h If these levels are compatible with src, return a new Image that combines src's base level with these levels as mip levels. If not compatible, this returns nullptr. 784 -
SkMipmapDrawDownSampler.cpp 2194 -
SkMipmapHQDownSampler.cpp 21348 -
SkNextID.h Shared between SkPixelRef's generationID and SkImage's uniqueID 386 -
SkOpts.cpp 2781 -
SkOpts.h SkOpts (short for SkOptimizations) is a mechanism where we can ship with multiple implementations of a set of functions and dynamically choose the best one at runtime (e.g. the call to SkGraphics::Init(), which calls SkOpts::Init()) depending on the detected CPU features. This is also referred to as having "specializations" of a given function. For example, Skia might be compiled to support CPUs that only have the sse2 instruction set (https://en.wikipedia.org/wiki/X86_instruction_listings#SSE2_instructions) but may be run on a more modern CPU that supports AVX2 instructions. (https://en.wikipedia.org/wiki/Advanced_Vector_Extensions) SkOpts allow Skia to have two versions of a row-blitting function, one that uses normal C++ code (e.g. loops, scalar integer math) and one that makes use of the AVX2 vector types and intrinsic functions. This function is declared here in the SkOpts namespace, and then the implementation (see SkOpts.cpp) is deferred to a function of the same name in the sse2:: namespace (the minimum Skia is compiled with) using DEFINE_DEFAULT. All implementations of this blit function are done in a header file file in //src/opts (e.g. //src/opts/SkBlitRow_opts.h). ifdefs guard each of the implementations, such that only one implementation is possible for a given SK_CPU_SSE_LEVEL. This header will be compiled *multiple* times with a different SK_CPU_SSE_LEVEL each compilation. Each CPU instruction set that we want specializations for has a .cpp file in //src/opts which defines an Init() function that replaces the function pointers in the SkOpts namespace with the ones from the specialized namespace (e.g. hsw::). These .cpp files don't implement the specializations, they just refer to the specialization created in the header files (e.g. SkBlitRow_opts.h). At compile time: - SkOpts.cpp is compiled with the minimum CPU level (e.g. SSE2). Because this file includes all the headers in //src/opts/, those headers add "the default implementation" of all their functions to the SK_OPTS_NS namespace (e.g. sse2::blit_row_color32). - Each of the specialized .cpp files in //src/opts/ are compiled with their respective compiler flags. Because the specialized .cpp file includes the headers that implement the functions using intrinsics or other CPU-specific code, those specialized functions end up in the specialized namespace, e.g. (hsw::blit_row_color32). At link time, the default implementations and all specializations of all SkOpts functions are included in the resulting library/binary file. At runtime, SkOpts::Init() will run the appropriate Init functions that the current CPU level supports specializations for (e.g. Init_hsw, Init_ssse3). Note multiple Init functions can be called as CPU instruction sets are typically super sets of older instruction sets 4526 -
SkOptsTargets.h 394 -
SkOSFile.h Maps a file into memory. Returns the address and length on success, NULL otherwise. The mapping is read only. When finished with the mapping, free the returned pointer with sk_fmunmap. 3004 -
SkOverdrawCanvas.cpp 10230 -
SkPaint.cpp 8828 -
SkPaintDefaults.h Any of these can be specified by the build system (or SkUserConfig.h) to change the default values for a SkPaint. This file should not be edited directly. 746 -
SkPaintPriv.cpp 11257 -
SkPaintPriv.h Returns true if drawing with this paint (or nullptr) will ovewrite all affected pixels. Note: returns conservative true, meaning it may return false even though the paint might in fact overwrite its pixels. 2261 -
SkPath.cpp Stores the verbs and points as they are given to us, with exceptions: - we only record "Close" if it was immediately preceeded by Move | Line | Quad | Cubic - we insert a Move(0,0) if Line | Quad | Cubic is our first command The iterator does more cleanup, especially if forceClose == true 1. If we encounter degenerate segments, remove them 2. if we encounter Close, return a cons'd up Line() first (if the curr-pt != start-pt) 3. if we encounter Move without a preceeding Close, and forceClose is true, goto #2 4. if we encounter Line | Quad | Cubic after Close, cons up a Move 122216 -
SkPath_serial.cpp 9098 -
SkPathBuilder.cpp Some old behavior in SkPath -- should we keep it? After each edit (i.e. adding a verb) this->setConvexityType(SkPathConvexity::kUnknown); this->setFirstDirection(SkPathPriv::kUnknown_FirstDirection); 37659 -
SkPathEffect.cpp \class SkPairPathEffect Common baseclass for Compose and Sum. This subclass manages two pathEffects, including flattening them. It does nothing in filterPath, and is only useful for managing the lifetimes of its two arguments. 8145 -
SkPathEffectBase.h \class PointData PointData aggregates all the information needed to draw the point primitives returned by an 'asPoints' call. 6011 -
SkPathEnums.h 2827 -
SkPathIter.cpp Close is funny -- it has no explicit point data, but we return 2 points, the logical 2 points that would make up the line connecting the end of the contour, and its beginning. To do this, we have local storage (fClosePointStorage) 2385 -
SkPathMakers.h 2950 -
SkPathMeasure.cpp 2352 -
SkPathMeasurePriv.h 877 -
SkPathPriv.cpp Determines if path is a rect by keeping track of changes in direction and looking for a loop either clockwise or counterclockwise. The direction is computed such that: 0: vertical up 1: horizontal left 2: vertical down 3: horizontal right A rectangle cycles up/right/down/left or up/left/down/right. The test fails if: The path is closed, and followed by a line. A second move creates a new endpoint. A diagonal line is parsed. There's more than four changes of direction. There's a discontinuity on the line (e.g., a move in the middle) The line reverses direction. The path contains a quadratic or cubic. The path contains fewer than four points. The rectangle doesn't complete a cycle. The final point isn't equal to the first point. These last two conditions we relax if we have a 3-edge path that would form a rectangle if it were closed (as we do when we fill a path) It's OK if the path has: Several colinear line segments composing a rectangle side. Single points on the rectangle side. The direction takes advantage of the corners found since opposite sides must travel in opposite directions. FIXME: Allow colinear quads and cubics to be treated like lines. FIXME: If the API passes fill-only, return true if the filled stroke is a rectangle, though the caller failed to close the path. directions values: 0x1 is set if the segment is horizontal 0x2 is set if the segment is moving to the right or down thus: two directions are opposites iff (dirA ^ dirB) == 0x2 two directions are perpendicular iff (dirA ^ dirB) == 0x1 8975 -
SkPathPriv.h Return the opposite of the specified direction. kUnknown is its own opposite. 21460 -
SkPathRaw.cpp 959 -
SkPathRaw.h SkPathRaw is a non-owning, immutable view of the path geometry. It allows us to have stack-allocated paths, see SkPathRawShapes.h It is the responsibility of the creator to ensure that the spans in SkPathRaw point to valid data that outlives the SkPathRaw instance. 1701 -
SkPathRawShapes.cpp 6354 -
SkPathRawShapes.h These classes provide their own stack-based storage for path data, making them efficient alternatives to SkPath for known geometries, avoiding heap allocations. The defaults were chosen to match those in SkPathBuilder.h 1539 -
SkPathRef.cpp 21042 -
SkPathUtils.cpp 2756 -
SkPicture.cpp SkPicture impl. This handles generic responsibilities like unique IDs and serialization. 11843 -
SkPictureData.cpp 21711 -
SkPictureData.h 6767 -
SkPictureFlat.cpp 451 -
SkPictureFlat.h Note: While adding new DrawTypes, it is necessary to add to the end of this list and update LAST_DRAWTYPE_ENUM to avoid having the code read older skps wrong. (which can cause segfaults) Reordering can be done during version updates. 6225 -
SkPicturePlayback.cpp 31032 -
SkPicturePlayback.h 1750 -
SkPicturePriv.h Recreate a picture that was serialized into a buffer. If the creation requires bitmap decoding, the decoder must be set on the SkReadBuffer parameter by calling SkReadBuffer::setBitmapDecoder() before calling SkPicture::MakeFromBuffer(). @param buffer Serialized picture data. @return A new SkPicture representing the serialized data, or NULL if the buffer is invalid. 9082 -
SkPictureRecord.cpp No need for a (potentially very big) layer which we don't actually need at this time (and may not be able to afford since during record our clip starts out the size of the picture, which is often much larger than the size of the actual device we'll use during playback). 34305 -
SkPictureRecord.h Write the 'drawType' operation and chunk size to the skp. 'size' can potentially be increased if the chunk size needs its own storage location (i.e., it overflows 24 bits). Returns the start offset of the chunk. This is the location at which the opcode & size are stored. TODO: since we are handing the size into here we could call reserve and then return a pointer to the memory storage. This could decrease allocation overhead but could lead to more wasted space (the tail end of blocks could go unused). Possibly add a second addDraw that operates in this manner. 10760 -
SkPictureRecorder.cpp bbh 5121 -
SkPixelRef.cpp We are forcing the genID to match an external value. The caller must ensure that this value does not conflict with other content. One use is to force this pixelref's id to match an SkImage's id 4916 -
SkPixelRefPriv.h Return a new SkMallocPixelRef with the provided pixel storage and rowBytes. On destruction, ReleaseProc will be called. If ReleaseProc is NULL, the pixels will never be released. This can be useful if the pixels were stack allocated. However, such an SkMallocPixelRef must not live beyond its pixels (e.g. by copying an SkBitmap pointing to it, or drawing to an SkPicture). Returns NULL on failure. 927 -
SkPixmap.cpp 31602 -
SkPixmapDraw.cpp 3311 -
SkPoint.cpp We have to worry about 2 tricky conditions: 1. underflow of mag2 (compared against nearlyzero^2) 2. overflow of mag2 (compared w/ isfinite) If we underflow, we return false. If we overflow, we compute again using doubles, which is much slower (3x in a desktop test) but will not overflow. 5470 -
SkPoint3.cpp We have to worry about 2 tricky conditions: 1. underflow of magSq (compared against nearlyzero^2) 2. overflow of magSq (compared w/ isfinite) If we underflow, we return false. If we overflow, we compute again using doubles, which is much slower (3x in a desktop test) but will not overflow. 2645 -
SkPointPriv.h 4178 -
SkPtrRecorder.cpp 1796 -
SkPtrRecorder.h Maintains a set of ptrs, assigning each a unique ID [1...N]. Duplicate ptrs return the same ID (since its a set). Subclasses can override inPtr() and decPtr(). incPtr() is called each time a unique ptr is added ot the set. decPtr() is called on each ptr when the set is destroyed or reset. 4709 -
SkQuadClipper.cpp Solve F(t) = y where F(t) := [0](1-t)^2 + 2[1]t(1-t) + [2]t^2 We solve for t, using quadratic equation, hence we have to rearrange our cooefficents to look like At^2 + Bt + C 3450 -
SkQuadClipper.h This class is initialized with a clip rectangle, and then can be fed quads, which must already be monotonic in Y. In the future, it might return a series of segments, allowing it to clip also in X, to ensure that all segments fit in a finite coordinate system. 2062 -
SkRasterClip.cpp Our antialiasing currently has a granularity of 1/4 of a pixel along each axis. Thus we can treat an axis coordinate as an integer if it differs from its nearest int by < half of that value (1/8 in this case). 9127 -
SkRasterClip.h Wraps a SkRegion and SkAAClip, so we have a single object that can represent either our BW or antialiased clips. 5372 -
SkRasterClipStack.h 3432 -
SkRasterPipeline.cpp 30850 -
SkRasterPipeline.h SkRasterPipeline provides a cheap way to chain together a pixel processing pipeline. It's particularly designed for situations where the potential pipeline is extremely combinatoric: {N dst formats} x {M source formats} x {K mask formats} x {C transfer modes} ... No one wants to write specialized routines for all those combinations, and if we did, we'd end up bloating our code size dramatically. SkRasterPipeline stages can be chained together at runtime, so we can scale this problem linearly rather than combinatorically. Each stage is represented by a function conforming to a common interface and by an arbitrary context pointer. The stage function arguments and calling convention are designed to maximize the amount of data we can pass along the pipeline cheaply, and vary depending on CPU feature detection. 7208 -
SkRasterPipelineBlitter.cpp 31114 -
SkRasterPipelineContextUtils.h SkRPCtxUtils::Pack will check if the passed-in struct is small enough to fit directly in the context field. If so, it will return the data bit-casted into a void pointer. If not, it allocates a copy of the struct inside the alloc and then returns a pointer to the copy. 1854 -
SkRasterPipelineOpContexts.h 9151 -
SkRasterPipelineOpList.h `SK_RASTER_PIPELINE_OPS_SKSL` defines ops used by SkSL. Design docs for SkSL in Raster Pipeline: go/sksl-rp https://docs.google.com/document/d/1GCQeAGVGHubOCbmULVdXUkNiXdw9J4umai_M5X3JGS4/edit?usp=sharing 18102 -
SkRasterPipelineVizualizer.h 4379 -
SkReadBuffer.cpp 17025 -
SkReadBuffer.h Returns true IFF the version is older than the specified version. 8389 -
SkReadPixelsRec.cpp 1135 -
SkReadPixelsRec.h Helper class to package and trim the parameters passed to readPixels() 1285 -
SkRecord.cpp 1017 -
SkRecord.h 7054 -
SkRecordCanvas.cpp 17878 -
SkRecordCanvas.h 7081 -
SkRecordDraw.cpp save now, restore at exit 23044 -
SkRecordDraw.h 2288 -
SkRecordedDrawable.cpp 3594 -
SkRecordedDrawable.h 1521 -
SkRecordOpts.cpp 11119 -
SkRecordOpts.h 901 -
SkRecordPattern.h 6236 -
SkRecords.cpp 488 -
SkRecords.h 13292 -
SkRect.cpp Both of these variants compute the same numerics. But, the "simple" one (no explicit skvx) runs faster (most of the time) on 64bit machines, and the tricky skvx version runs faster (most of the time) on 32bit machines. Hence the if/else 14029 -
SkRectPriv.h 4489 -
SkRegion.cpp Region Layout TOP [ Bottom, X-Intervals, [Left, Right]..., X-Sentinel ] ... Y-Sentinel 48084 -
SkRegion_path.cpp Scanline mimics a row in the region, nearly. A row in a region is: [Bottom IntervalCount [L R]... Sentinel] while a Scanline is [LastY XCount [L R]... uninitialized] The two are the same length (which is good), but we have to transmute the scanline a little when we convert it to a region-row. Potentially we could recode this to exactly match the row format, in which case copyToRgn() could be a single memcpy. Not sure that is worth the effort. 19845 -
SkRegionPriv.h Number of spans with different Y values. This does not count the initial Top value, nor does it count the final Y-Sentinel value. In the logical case of a rectangle, this would return 1, and an empty region would return 0. 7953 -
SkResourceCache.cpp 16437 -
SkResourceCache.h Cache object for bitmaps (with possible scale in X Y as part of the key). Multiple caches can be instantiated, but each instance is not implicitly thread-safe, so if a given instance is to be shared across threads, the caller must manage the access itself (e.g. via a mutex). As a convenience, a global instance is also defined, which can be safely access across threads via the static methods (e.g. FindAndLock, etc.). 10572 -
SkRRect.cpp 35901 -
SkRRectPriv.h 2688 -
SkRSXform.cpp 1432 -
SkRTree.cpp 5268 -
SkRTree.h An R-Tree implementation. In short, it is a balanced n-ary tree containing a hierarchy of bounding rectangles. It only supports bulk-loading, i.e. creation from a batch of bounding rectangles. This performs a bottom-up bulk load using the STR (sort-tile-recursive) algorithm. TODO: Experiment with other bulk-load algorithms (in particular the Hilbert pack variant, which groups rects by position on the Hilbert curve, is probably worth a look). There also exist top-down bulk load variants (VAMSplit, TopDownGreedy, etc). For more details see: Beckmann, N.; Kriegel, H. P.; Schneider, R.; Seeger, B. (1990). "The R*-tree: an efficient and robust access method for points and rectangles" 2565 -
SkRuntimeBlender.cpp debugTrace= 3909 -
SkRuntimeBlender.h 1596 -
SkRuntimeEffect.cpp 42409 -
SkRuntimeEffectPriv.h 9952 -
SkSafeRange.h 1144 -
SkSamplingPriv.h 3133 -
SkScalar.cpp 1152 -
SkScalerContext.cpp In order to call cachedDeviceLuminance, cachedPaintLuminance, or cachedMaskGamma the caller must hold the mask_gamma_cache_mutex and continue to hold it until the returned pointer is refed or forgotten. 51013 -
SkScalerContext.h To allow this to be forward-declared, it must be its own typename, rather than a nested struct inside SkScalerContext (where it started). SkScalerContextRec must be dense, and all bytes must be set to a know quantity because this structure is used to calculate a checksum. 20006 -
SkScaleToSides.h 2444 -
SkScan.cpp 2932 -
SkScan.h Defines a fixed-point rectangle, identical to the integer SkIRect, but its coordinates are treated as SkFixed rather than int32_t. 5905 -
SkScan_AAAPath.cpp The following is a high-level overview of our analytic anti-aliasing algorithm. We consider a path as a collection of line segments, as quadratic/cubic curves are converted to small line segments. Without loss of generality, let's assume that the draw region is [0, W] x [0, H]. Our algorithm is based on horizontal scan lines (y = c_i) as the previous sampling-based algorithm did. However, our algorithm uses non-equal-spaced scan lines, while the previous method always uses equal-spaced scan lines, such as (y = 1/2 + 0, 1/2 + 1, 1/2 + 2, ...) in the previous non-AA algorithm, and (y = 1/8 + 1/4, 1/8 + 2/4, 1/8 + 3/4, ...) in the previous 16-supersampling AA algorithm. Our algorithm contains scan lines y = c_i for c_i that is either: 1. an integer between [0, H] 2. the y value of a line segment endpoint 3. the y value of an intersection of two line segments For two consecutive scan lines y = c_i, y = c_{i+1}, we analytically computes the coverage of this horizontal strip of our path on each pixel. This can be done very efficiently because the strip of our path now only consists of trapezoids whose top and bottom edges are y = c_i, y = c_{i+1} (this includes rectangles and triangles as special cases). We now describe how the coverage of single pixel is computed against such a trapezoid. That coverage is essentially the intersection area of a rectangle (e.g., [0, 1] x [c_i, c_{i+1}]) and our trapezoid. However, that intersection could be complicated, as shown in the example region A below: +-----------\----+ | \ C| | \ | \ \ | |\ A \| | \ \ | \ | | B \ | +----\-----------+ However, we don't have to compute the area of A directly. Instead, we can compute the excluded area, which are B and C, quite easily, because they're just triangles. In fact, we can prove that an excluded region (take B as an example) is either itself a simple trapezoid (including rectangles, triangles, and empty regions), or its opposite (the opposite of B is A + C) is a simple trapezoid. In any case, we can compute its area efficiently. In summary, our algorithm has a higher quality because it generates ground- truth coverages analytically. It is also faster because it has much fewer unnessasary horizontal scan lines. For example, given a triangle path, the number of scan lines in our algorithm is only about 3 + H while the 16-supersampling algorithm has about 4H scan lines. 70774 -
SkScan_Antihair.cpp Our attempt to compute the worst case "bounds" for the horizontal and vertical cases has some numerical bug in it, and we sometimes undervalue our extends. The bug is that when this happens, we will set the clip to nullptr (for speed), and thus draw outside of the clip by a pixel, which might only look bad, but it might also access memory outside of the valid range allcoated for the device bitmap. This define enables our fix to outset our "bounds" by 1, thus avoiding the chance of the bug, but at the cost of sometimes taking the rectblitter case (i.e. not setting the clip to nullptr) when we might not actually need to. If we can improve/fix the actual calculations, then we can remove this step. 32735 -
SkScan_AntiPath.cpp Would any of the coordinates of this rectangle not fit in a short, when left-shifted by shift? 5041 -
SkScan_Hairline.cpp 29291 -
SkScan_Path.cpp 25014 -
SkScanPriv.h 2439 -
SkSLTypeShared.cpp Is the shading language type full precision? 7610 -
SkSLTypeShared.h Types of shader-language-specific boxed variables we can create. 7372 -
SkSpecialImage.cpp 7164 -
SkSpecialImage.h This is a restricted form of SkImage solely intended for internal use. It differs from SkImage in that: - it can only be backed by raster or gpu (no generators) - it can be backed by a GrTextureProxy larger than its nominal bounds - it can't be drawn tiled - it can't be drawn with MIPMAPs It is similar to SkImage in that it abstracts how the pixels are stored/represented. Note: the contents of the backing storage outside of the subset rect are undefined. 6219 -
SkSpriteBlitter.h 1486 -
SkSpriteBlitter_ARGB32.cpp 2487 -
SkStream.cpp 27454 -
SkStreamPriv.h Copy the provided stream to an SkData variable. Note: Assumes the stream is at the beginning. If it has a length, but is not at the beginning, this call will fail (return NULL). @param stream SkStream to be copied into data. @return The resulting SkData after the copy, nullptr on failure. 2648 -
SkStrike.cpp 14998 -
SkStrike.h 8496 -
SkStrikeCache.cpp 10475 -
SkStrikeCache.h 4413 -
SkStrikeSpec.cpp 8977 -
SkStrikeSpec.h 5885 -
SkString.cpp 18195 -
SkStringUtils.cpp 3269 -
SkStringUtils.h Indents every non-empty line of the string by tabCnt tabs 2022 -
SkStroke.cpp Enable to show the decisions made in subdividing the curve -- helpful when the resulting stroke has more than the optimal number of quadratics and lines 63041 -
SkStroke.h \class SkStroke SkStroke is the utility class that constructs paths by stroking geometries (lines, rects, ovals, roundrects, paths). This is invoked when a geometry or text is drawn in a canvas with the kStroke_Mask bit set in the paint. 2628 -
SkStrokeRec.cpp 5332 -
SkStrokerPriv.cpp In the degenerate case that the stroke radius is larger than our segments just connecting the two inner segments may "show through" as a funny diagonal. To pseudo-fix this, we go through the pivot point. This adds an extra point/edge, but I can't see a cheap way to know when this is not needed :( 8224 -
SkStrokerPriv.h 1489 -
SkSurfacePriv.h 568 -
SkSwizzle.cpp 329 -
SkSwizzlePriv.h 2385 -
SkSwizzler_opts.cpp 1810 -
SkSwizzler_opts_hsw.cpp 1398 -
SkSwizzler_opts_lasx.cpp 1427 -
SkSwizzler_opts_ssse3.cpp 1523 -
SkSynchronizedResourceCache.cpp 2607 -
SkSynchronizedResourceCache.h 1365 -
SkTaskGroup.cpp workList= 1983 -
SkTaskGroup.h 1519 -
SkTDynamicHash.h 1764 -
SkTextBlob.cpp 38424 -
SkTextBlobPriv.h Serialize to a buffer. 7688 -
SkTextFormatParams.h 1028 -
SkTHash.h 23892 -
SkTMultiMap.h A set that contains pointers to instances of T. Instances can be looked up with key Key. Multiple (possibly same) values can have the same key. 5535 -
SkTraceEvent.h 17272 -
SkTraceEventCommon.h 46177 -
SkTypeface.cpp 19680 -
SkTypeface_remote.cpp 6854 -
SkTypeface_remote.h 6827 -
SkTypefaceCache.cpp 3178 -
SkTypefaceCache.h Callback for FindByProc. Returns true if the given typeface is a match for the given context. The passed typeface is owned by the cache and is not additionally ref()ed. The typeface may be in the disposed state. 2104 -
SkUnPreMultiply.cpp 4478 -
SkValidationUtils.h Returns true if mode's value is in the SkBlendMode enum. 939 -
SkVertices.cpp 13387 -
SkVerticesPriv.h Class that adds methods to SkVertices that are only intended for use internal to Skia. This class is purely a privileged window into SkVertices. It should never have additional data members or virtual methods. 2146 -
SkVertState.cpp 2797 -
SkVertState.h \struct VertState This is a helper for drawVertices(). It is used to iterate over the triangles that are to be rendered based on an SkCanvas::VertexMode and (optionally) an index array. It does not copy the index array and the client must ensure it remains valid for the lifetime of the VertState object. 1625 -
SkWriteBuffer.cpp 10594 -
SkWriteBuffer.h Concrete implementation that serializes to a flat binary blob. 6016 -
SkWritePixelsRec.cpp 1144 -
SkWritePixelsRec.h Helper class to package and trim the parameters passed to writePixels() 1289 -
SkWriter32.cpp 2221 -
SkWriter32.h The caller can specify an initial block of storage, which the caller manages. SkWriter32 will try to back reserve and write calls with this external storage until the first time an allocation doesn't fit. From then it will use dynamically allocated storage. This used to be optional behavior, but pipe now relies on it. 8969 -
SkYUVAInfo.cpp 13968 -
SkYUVAInfoLocation.h The location of Y, U, V, or A values within the planes described by SkYUVAInfo. Computed from a SkYUVAInfo and the set of channels present in a set of pixmaps/textures. 2102 -
SkYUVAPixmaps.cpp 10704 -
SkYUVMath.cpp 32516 -
SkYUVMath.h 453 -
SkYUVPlanesCache.cpp 2953 -
SkYUVPlanesCache.h On success, return a ref to the SkCachedData that holds the pixel data. The SkYUVAPixmaps contains a description of the YUVA data and has a SkPixmap for each plane that points into the SkCachedData. On failure, return nullptr. 1167 -