/* * Copyright 2008 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "include/core/SkMatrix.h" #include "include/core/SkPixmap.h" #include "include/core/SkTileMode.h" #include "include/core/SkTypes.h" #include "include/private/base/SkCPUTypes.h" #include "include/private/base/SkFixed.h" #include "include/private/base/SkMath.h" #include "include/private/base/SkTFitsIn.h" #include "include/private/base/SkTPin.h" #include "include/private/base/SkTo.h" #include "src/core/SkBitmapProcState.h" #include "src/core/SkMemset.h" #include <cstdint> #include <cstring> /* * 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 SkFractionalInt to keep more fractional 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. */ static inline bool can_truncate_to_fixed_for_decal(SkFixed fx, SkFixed dx, int count, unsigned max) { … } // When not filtering, we store 32-bit y, 16-bit x, 16-bit x, 16-bit x, ... // When filtering we write out 32-bit encodings, pairing 14.4 x0 with 14-bit x1. // The clamp routines may try to fall into one of these unclamped decal fast-paths. // (Only clamp works in the right coordinate space to check for decal.) static void decal_nofilter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count) { … } // A generic implementation for unfiltered scale+translate, templated on tiling method. template <unsigned (*tilex)(SkFixed, int), unsigned (*tiley)(SkFixed, int), bool tryDecal> static void nofilter_scale(const SkBitmapProcState& s, uint32_t xy[], int count, int x, int y) { … } template <unsigned (*tilex)(SkFixed, int), unsigned (*tiley)(SkFixed, int)> static void nofilter_affine(const SkBitmapProcState& s, uint32_t xy[], int count, int x, int y) { … } // used when both tilex and tiley are clamp // Extract the high four fractional bits from fx, the lerp parameter when filtering. static unsigned extract_low_bits_clamp_clamp(SkFixed fx, int /*max*/) { … } //used when one of tilex and tiley is not clamp static unsigned extract_low_bits_general(SkFixed fx, int max) { … } // Takes a SkFixed number and packs it into a 32bit integer in the following schema: // 14 bits to represent the low integer value (n) // 4 bits to represent a linear distance between low and high (floored to nearest 1/16) // 14 bits to represent the high integer value (n+1) // If f is less than 0, then both integers will be 0. If f is greater than or equal to max, both // integers will be that max value. In all cases, the middle 4 bits will represent the fractional // part (to a resolution of 1/16). If the two integers are equal, doing any linear interpolation // will result in the same integer, so the fractional part does not matter. // // The "one" parameter corresponds to the maximum distance between the high and low coordinate. // For the clamp operation, this is just SkFixed1, but for others it is 1 / pixmap width because the // distances are already normalized to between 0 and 1.0. // // See also SK_OPTS_NS::decode_packed_coordinates_and_weight for unpacking this value. template <unsigned (*tile)(SkFixed, int), unsigned (*extract_low_bits)(SkFixed, int)> SK_NO_SANITIZE("signed-integer-overflow") static uint32_t pack(SkFixed f, unsigned max, SkFixed one) { … } template <unsigned (*tilex)(SkFixed, int), unsigned (*tiley)(SkFixed, int), unsigned (*extract_low_bits)(SkFixed, int), bool tryDecal> static void filter_scale(const SkBitmapProcState& s, uint32_t xy[], int count, int x, int y) { … } template <unsigned (*tilex)(SkFixed, int), unsigned (*tiley)(SkFixed, int), unsigned (*extract_low_bits)(SkFixed, int)> static void filter_affine(const SkBitmapProcState& s, uint32_t xy[], int count, int x, int y) { … } // Helper to ensure that when we shift down, we do it w/o sign-extension // so the caller doesn't have to manually mask off the top 16 bits. static inline unsigned SK_USHIFT16(unsigned x) { … } static unsigned repeat(SkFixed fx, int max) { … } static unsigned mirror(SkFixed fx, int max) { … } static unsigned clamp(SkFixed fx, int max) { … } static const SkBitmapProcState::MatrixProc ClampX_ClampY_Procs[] = …; static const SkBitmapProcState::MatrixProc RepeatX_RepeatY_Procs[] = …; static const SkBitmapProcState::MatrixProc MirrorX_MirrorY_Procs[] = …; /////////////////////////////////////////////////////////////////////////////// // This next chunk has some specializations for unfiltered translate-only matrices. static inline U16CPU int_clamp(int x, int n) { … } /* returns 0...(n-1) given any x (positive or negative). As an example, if n (which is always positive) is 5... x: -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 returns: 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 */ static inline int sk_int_mod(int x, int n) { … } static inline U16CPU int_repeat(int x, int n) { … } static inline U16CPU int_mirror(int x, int n) { … } static void fill_sequential(uint16_t xptr[], int pos, int count) { … } static void fill_backwards(uint16_t xptr[], int pos, int count) { … } template< U16CPU (tiley)(int x, int n) > static void clampx_nofilter_trans(const SkBitmapProcState& s, uint32_t xy[], int count, int x, int y) { … } template< U16CPU (tiley)(int x, int n) > static void repeatx_nofilter_trans(const SkBitmapProcState& s, uint32_t xy[], int count, int x, int y) { … } template< U16CPU (tiley)(int x, int n) > static void mirrorx_nofilter_trans(const SkBitmapProcState& s, uint32_t xy[], int count, int x, int y) { … } /////////////////////////////////////////////////////////////////////////////// // The main entry point to the file, choosing between everything above. SkBitmapProcState::MatrixProc SkBitmapProcState::chooseMatrixProc(bool translate_only_matrix) { … } uint32_t sktests::pack_clamp(SkFixed f, unsigned max) { … } uint32_t sktests::pack_repeat(SkFixed f, unsigned max, size_t width) { … } uint32_t sktests::pack_mirror(SkFixed f, unsigned max, size_t width) { … }
Codebase Browser
chromium