LCOV - code coverage report
Current view: directory - gfx/skia/src/core - SkBitmapProcState_matrixProcs.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 208 0 0.0 %
Date: 2012-06-02 Functions: 18 0 0.0 %

       1                 : /* NEON optimized code (C) COPYRIGHT 2009 Motorola */
       2                 : 
       3                 : #include "SkBitmapProcState.h"
       4                 : #include "SkPerspIter.h"
       5                 : #include "SkShader.h"
       6                 : #include "SkUtils.h"
       7                 : 
       8                 : /*  returns 0...(n-1) given any x (positive or negative).
       9                 :     
      10                 :     As an example, if n (which is always positive) is 5...
      11                 :  
      12                 :           x: -8 -7 -6 -5 -4 -3 -2 -1  0  1  2  3  4  5  6  7  8
      13                 :     returns:  2  3  4  0  1  2  3  4  0  1  2  3  4  0  1  2  3
      14                 :  */
      15               0 : static inline int sk_int_mod(int x, int n) {
      16               0 :     SkASSERT(n > 0);
      17               0 :     if ((unsigned)x >= (unsigned)n) {
      18               0 :         if (x < 0) {
      19               0 :             x = n + ~(~x % n);
      20                 :         } else {
      21               0 :             x = x % n;
      22                 :         }
      23                 :     }
      24               0 :     return x;
      25                 : }
      26                 : 
      27                 : void decal_nofilter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count);
      28                 : void decal_filter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count);
      29                 : 
      30                 : #define MAKENAME(suffix)        ClampX_ClampY ## suffix
      31                 : #define TILEX_PROCF(fx, max)    SkClampMax((fx) >> 16, max)
      32                 : #define TILEY_PROCF(fy, max)    SkClampMax((fy) >> 16, max)
      33                 : #define TILEX_LOW_BITS(fx, max) (((fx) >> 12) & 0xF)
      34                 : #define TILEY_LOW_BITS(fy, max) (((fy) >> 12) & 0xF)
      35                 : #define CHECK_FOR_DECAL
      36                 : #if     defined(__ARM_HAVE_NEON)
      37                 :     #include "SkBitmapProcState_matrix_clamp.h"
      38                 : #else
      39                 :     #include "SkBitmapProcState_matrix.h"
      40                 : #endif
      41                 : 
      42                 : #define MAKENAME(suffix)        RepeatX_RepeatY ## suffix
      43                 : #define TILEX_PROCF(fx, max)    (((fx) & 0xFFFF) * ((max) + 1) >> 16)
      44                 : #define TILEY_PROCF(fy, max)    (((fy) & 0xFFFF) * ((max) + 1) >> 16)
      45                 : #define TILEX_LOW_BITS(fx, max) ((((fx) & 0xFFFF) * ((max) + 1) >> 12) & 0xF)
      46                 : #define TILEY_LOW_BITS(fy, max) ((((fy) & 0xFFFF) * ((max) + 1) >> 12) & 0xF)
      47                 : #if     defined(__ARM_HAVE_NEON)
      48                 :     #include "SkBitmapProcState_matrix_repeat.h"
      49                 : #else
      50                 :     #include "SkBitmapProcState_matrix.h"
      51                 : #endif
      52                 : 
      53                 : #define MAKENAME(suffix)        GeneralXY ## suffix
      54                 : #define PREAMBLE(state)         SkBitmapProcState::FixedTileProc tileProcX = (state).fTileProcX; \
      55                 :                                 SkBitmapProcState::FixedTileProc tileProcY = (state).fTileProcY
      56                 : #define PREAMBLE_PARAM_X        , SkBitmapProcState::FixedTileProc tileProcX
      57                 : #define PREAMBLE_PARAM_Y        , SkBitmapProcState::FixedTileProc tileProcY
      58                 : #define PREAMBLE_ARG_X          , tileProcX
      59                 : #define PREAMBLE_ARG_Y          , tileProcY
      60                 : #define TILEX_PROCF(fx, max)    (tileProcX(fx) * ((max) + 1) >> 16)
      61                 : #define TILEY_PROCF(fy, max)    (tileProcY(fy) * ((max) + 1) >> 16)
      62                 : #define TILEX_LOW_BITS(fx, max) ((tileProcX(fx) * ((max) + 1) >> 12) & 0xF)
      63                 : #define TILEY_LOW_BITS(fy, max) ((tileProcY(fy) * ((max) + 1) >> 12) & 0xF)
      64                 : #include "SkBitmapProcState_matrix.h"
      65                 : 
      66               0 : static inline U16CPU fixed_clamp(SkFixed x)
      67                 : {
      68                 : #ifdef SK_CPU_HAS_CONDITIONAL_INSTR
      69                 :     if (x >> 16)
      70                 :         x = 0xFFFF;
      71                 :     if (x < 0)
      72                 :         x = 0;
      73                 : #else
      74               0 :     if (x >> 16)
      75                 :     {
      76               0 :         if (x < 0)
      77               0 :             x = 0;
      78                 :         else
      79               0 :             x = 0xFFFF;
      80                 :     }
      81                 : #endif
      82               0 :     return x;
      83                 : }
      84                 : 
      85               0 : static inline U16CPU fixed_repeat(SkFixed x)
      86                 : {
      87               0 :     return x & 0xFFFF;
      88                 : }
      89                 : 
      90               0 : static inline U16CPU fixed_mirror(SkFixed x)
      91                 : {
      92               0 :     SkFixed s = x << 15 >> 31;
      93                 :     // s is FFFFFFFF if we're on an odd interval, or 0 if an even interval
      94               0 :     return (x ^ s) & 0xFFFF;
      95                 : }
      96                 : 
      97               0 : static SkBitmapProcState::FixedTileProc choose_tile_proc(unsigned m)
      98                 : {
      99               0 :     if (SkShader::kClamp_TileMode == m)
     100               0 :         return fixed_clamp;
     101               0 :     if (SkShader::kRepeat_TileMode == m)
     102               0 :         return fixed_repeat;
     103               0 :     SkASSERT(SkShader::kMirror_TileMode == m);
     104               0 :     return fixed_mirror;
     105                 : }
     106                 : 
     107               0 : static inline U16CPU int_clamp(int x, int n) {
     108                 : #ifdef SK_CPU_HAS_CONDITIONAL_INSTR
     109                 :     if (x >= n)
     110                 :         x = n - 1;
     111                 :     if (x < 0)
     112                 :         x = 0;
     113                 : #else
     114               0 :     if ((unsigned)x >= (unsigned)n) {
     115               0 :         if (x < 0) {
     116               0 :             x = 0;
     117                 :         } else {
     118               0 :             x = n - 1;
     119                 :         }
     120                 :     }
     121                 : #endif
     122               0 :     return x;
     123                 : }
     124                 : 
     125               0 : static inline U16CPU int_repeat(int x, int n) {
     126               0 :     return sk_int_mod(x, n);
     127                 : }
     128                 : 
     129               0 : static inline U16CPU int_mirror(int x, int n) {
     130               0 :     x = sk_int_mod(x, 2 * n);
     131               0 :     if (x >= n) {
     132               0 :         x = n + ~(x - n);
     133                 :     }
     134               0 :     return x;
     135                 : }
     136                 : 
     137                 : #if 0
     138                 : static void test_int_tileprocs() {
     139                 :     for (int i = -8; i <= 8; i++) {
     140                 :         SkDebugf(" int_mirror(%2d, 3) = %d\n", i, int_mirror(i, 3));
     141                 :     }
     142                 : }
     143                 : #endif
     144                 : 
     145               0 : static SkBitmapProcState::IntTileProc choose_int_tile_proc(unsigned tm) {
     146               0 :     if (SkShader::kClamp_TileMode == tm)
     147               0 :         return int_clamp;
     148               0 :     if (SkShader::kRepeat_TileMode == tm)
     149               0 :         return int_repeat;
     150               0 :     SkASSERT(SkShader::kMirror_TileMode == tm);
     151               0 :     return int_mirror;
     152                 : }
     153                 : 
     154                 : //////////////////////////////////////////////////////////////////////////////
     155                 : 
     156               0 : void decal_nofilter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count)
     157                 : {
     158                 :     int i;
     159                 : 
     160                 : #if     defined(__ARM_HAVE_NEON)
     161                 :     if (count >= 8) {
     162                 :         /* SkFixed is 16.16 fixed point */
     163                 :         SkFixed dx2 = dx+dx;
     164                 :         SkFixed dx4 = dx2+dx2;
     165                 :         SkFixed dx8 = dx4+dx4;
     166                 : 
     167                 :         /* now build fx/fx+dx/fx+2dx/fx+3dx */
     168                 :         SkFixed fx1, fx2, fx3;
     169                 :         int32x2_t lower, upper;
     170                 :         int32x4_t lbase, hbase;
     171                 :         uint16_t *dst16 = (uint16_t *)dst;
     172                 : 
     173                 :         fx1 = fx+dx;
     174                 :         fx2 = fx1+dx;
     175                 :         fx3 = fx2+dx;
     176                 : 
     177                 :         /* avoid an 'lbase unitialized' warning */
     178                 :         lbase = vdupq_n_s32(fx);
     179                 :         lbase = vsetq_lane_s32(fx1, lbase, 1);
     180                 :         lbase = vsetq_lane_s32(fx2, lbase, 2);
     181                 :         lbase = vsetq_lane_s32(fx3, lbase, 3);
     182                 :         hbase = vaddq_s32(lbase, vdupq_n_s32(dx4));
     183                 : 
     184                 :         /* take upper 16 of each, store, and bump everything */
     185                 :         do {
     186                 :             int32x4_t lout, hout;
     187                 :             uint16x8_t hi16;
     188                 : 
     189                 :             lout = lbase;
     190                 :             hout = hbase;
     191                 :             /* gets hi's of all louts then hi's of all houts */
     192                 :             asm ("vuzpq.16 %q0, %q1" : "+w" (lout), "+w" (hout));
     193                 :             hi16 = vreinterpretq_u16_s32(hout);
     194                 :             vst1q_u16(dst16, hi16);
     195                 : 
     196                 :             /* on to the next */
     197                 :             lbase = vaddq_s32 (lbase, vdupq_n_s32(dx8));
     198                 :             hbase = vaddq_s32 (hbase, vdupq_n_s32(dx8));
     199                 :             dst16 += 8;
     200                 :             count -= 8;
     201                 :             fx += dx8;
     202                 :         } while (count >= 8);
     203                 :         dst = (uint32_t *) dst16;
     204                 :     }
     205                 : #else
     206               0 :     for (i = (count >> 2); i > 0; --i)
     207                 :     {
     208               0 :         *dst++ = pack_two_shorts(fx >> 16, (fx + dx) >> 16);
     209               0 :         fx += dx+dx;
     210               0 :         *dst++ = pack_two_shorts(fx >> 16, (fx + dx) >> 16);
     211               0 :         fx += dx+dx;
     212                 :     }
     213               0 :     count &= 3;
     214                 : #endif
     215                 : 
     216               0 :     uint16_t* xx = (uint16_t*)dst;
     217               0 :     for (i = count; i > 0; --i) {
     218               0 :         *xx++ = SkToU16(fx >> 16); fx += dx;
     219                 :     }
     220               0 : }
     221                 : 
     222               0 : void decal_filter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count)
     223                 : {
     224                 : 
     225                 : #if     defined(__ARM_HAVE_NEON)
     226                 :     if (count >= 8) {
     227                 :         int32x4_t wide_fx;
     228                 :         int32x4_t wide_fx2;
     229                 :         int32x4_t wide_dx8 = vdupq_n_s32(dx*8);
     230                 : 
     231                 :         wide_fx = vdupq_n_s32(fx);
     232                 :         wide_fx = vsetq_lane_s32(fx+dx, wide_fx, 1);
     233                 :         wide_fx = vsetq_lane_s32(fx+dx+dx, wide_fx, 2);
     234                 :         wide_fx = vsetq_lane_s32(fx+dx+dx+dx, wide_fx, 3);
     235                 : 
     236                 :         wide_fx2 = vaddq_s32(wide_fx, vdupq_n_s32(dx+dx+dx+dx));
     237                 : 
     238                 :         while (count >= 8) {
     239                 :             int32x4_t wide_out;
     240                 :             int32x4_t wide_out2;
     241                 : 
     242                 :             wide_out = vshlq_n_s32(vshrq_n_s32(wide_fx, 12), 14);
     243                 :             wide_out = vorrq_s32(wide_out,
     244                 :             vaddq_s32(vshrq_n_s32(wide_fx,16), vdupq_n_s32(1)));
     245                 : 
     246                 :             wide_out2 = vshlq_n_s32(vshrq_n_s32(wide_fx2, 12), 14);
     247                 :             wide_out2 = vorrq_s32(wide_out2,
     248                 :             vaddq_s32(vshrq_n_s32(wide_fx2,16), vdupq_n_s32(1)));
     249                 : 
     250                 :             vst1q_u32(dst, vreinterpretq_u32_s32(wide_out));
     251                 :             vst1q_u32(dst+4, vreinterpretq_u32_s32(wide_out2));
     252                 : 
     253                 :             dst += 8;
     254                 :             fx += dx*8;
     255                 :             wide_fx = vaddq_s32(wide_fx, wide_dx8);
     256                 :             wide_fx2 = vaddq_s32(wide_fx2, wide_dx8);
     257                 :             count -= 8;
     258                 :         }
     259                 :     }
     260                 : #endif
     261                 : 
     262               0 :     if (count & 1)
     263                 :     {
     264               0 :         SkASSERT((fx >> (16 + 14)) == 0);
     265               0 :         *dst++ = (fx >> 12 << 14) | ((fx >> 16) + 1);
     266               0 :         fx += dx;
     267                 :     }
     268               0 :     while ((count -= 2) >= 0)
     269                 :     {
     270               0 :         SkASSERT((fx >> (16 + 14)) == 0);
     271               0 :         *dst++ = (fx >> 12 << 14) | ((fx >> 16) + 1);
     272               0 :         fx += dx;
     273                 : 
     274               0 :         *dst++ = (fx >> 12 << 14) | ((fx >> 16) + 1);
     275               0 :         fx += dx;
     276                 :     }
     277               0 : }
     278                 : 
     279                 : ///////////////////////////////////////////////////////////////////////////////
     280                 : // stores the same as SCALE, but is cheaper to compute. Also since there is no
     281                 : // scale, we don't need/have a FILTER version
     282                 : 
     283               0 : static void fill_sequential(uint16_t xptr[], int start, int count) {
     284                 : #if 1
     285               0 :     if (reinterpret_cast<intptr_t>(xptr) & 0x2) {
     286               0 :         *xptr++ = start++;
     287               0 :         count -= 1;
     288                 :     }
     289               0 :     if (count > 3) {
     290               0 :         uint32_t* xxptr = reinterpret_cast<uint32_t*>(xptr);
     291               0 :         uint32_t pattern0 = PACK_TWO_SHORTS(start + 0, start + 1);
     292               0 :         uint32_t pattern1 = PACK_TWO_SHORTS(start + 2, start + 3);
     293               0 :         start += count & ~3;
     294               0 :         int qcount = count >> 2;
     295               0 :         do {
     296               0 :             *xxptr++ = pattern0;
     297               0 :             pattern0 += 0x40004;
     298               0 :             *xxptr++ = pattern1;
     299               0 :             pattern1 += 0x40004;
     300                 :         } while (--qcount != 0);
     301               0 :         xptr = reinterpret_cast<uint16_t*>(xxptr);
     302               0 :         count &= 3;
     303                 :     }
     304               0 :     while (--count >= 0) {
     305               0 :         *xptr++ = start++;
     306                 :     }
     307                 : #else
     308                 :     for (int i = 0; i < count; i++) {
     309                 :         *xptr++ = start++;
     310                 :     }
     311                 : #endif
     312               0 : }
     313                 : 
     314               0 : static int nofilter_trans_preamble(const SkBitmapProcState& s, uint32_t** xy,
     315                 :                                    int x, int y) {
     316                 :     SkPoint pt;
     317               0 :     s.fInvProc(*s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
     318               0 :                SkIntToScalar(y) + SK_ScalarHalf, &pt);
     319                 :     **xy = s.fIntTileProcY(SkScalarToFixed(pt.fY) >> 16,
     320               0 :                            s.fBitmap->height());
     321               0 :     *xy += 1;   // bump the ptr
     322                 :     // return our starting X position
     323               0 :     return SkScalarToFixed(pt.fX) >> 16;
     324                 : }
     325                 : 
     326               0 : static void clampx_nofilter_trans(const SkBitmapProcState& s,
     327                 :                                   uint32_t xy[], int count, int x, int y) {
     328               0 :     SkASSERT((s.fInvType & ~SkMatrix::kTranslate_Mask) == 0);
     329                 : 
     330               0 :     int xpos = nofilter_trans_preamble(s, &xy, x, y);
     331               0 :     const int width = s.fBitmap->width();    
     332               0 :     if (1 == width) {
     333                 :         // all of the following X values must be 0
     334               0 :         memset(xy, 0, count * sizeof(uint16_t));
     335               0 :         return;
     336                 :     }
     337                 :     
     338               0 :     uint16_t* xptr = reinterpret_cast<uint16_t*>(xy);
     339                 :     int n;
     340                 : 
     341                 :     // fill before 0 as needed
     342               0 :     if (xpos < 0) {
     343               0 :         n = -xpos;
     344               0 :         if (n > count) {
     345               0 :             n = count;
     346                 :         }
     347               0 :         memset(xptr, 0, n * sizeof(uint16_t));
     348               0 :         count -= n;
     349               0 :         if (0 == count) {
     350               0 :             return;
     351                 :         }
     352               0 :         xptr += n;
     353               0 :         xpos = 0;
     354                 :     }
     355                 : 
     356                 :     // fill in 0..width-1 if needed
     357               0 :     if (xpos < width) {
     358               0 :         n = width - xpos;
     359               0 :         if (n > count) {
     360               0 :             n = count;
     361                 :         }
     362               0 :         fill_sequential(xptr, xpos, n);
     363               0 :         count -= n;
     364               0 :         if (0 == count) {
     365               0 :             return;
     366                 :         }
     367               0 :         xptr += n;
     368                 :     }
     369                 : 
     370                 :     // fill the remaining with the max value
     371               0 :     sk_memset16(xptr, width - 1, count);
     372                 : }
     373                 : 
     374               0 : static void repeatx_nofilter_trans(const SkBitmapProcState& s,
     375                 :                                    uint32_t xy[], int count, int x, int y) {
     376               0 :     SkASSERT((s.fInvType & ~SkMatrix::kTranslate_Mask) == 0);
     377                 : 
     378               0 :     int xpos = nofilter_trans_preamble(s, &xy, x, y);
     379               0 :     const int width = s.fBitmap->width();    
     380               0 :     if (1 == width) {
     381                 :         // all of the following X values must be 0
     382               0 :         memset(xy, 0, count * sizeof(uint16_t));
     383               0 :         return;
     384                 :     }
     385                 : 
     386               0 :     uint16_t* xptr = reinterpret_cast<uint16_t*>(xy);
     387               0 :     int start = sk_int_mod(xpos, width);
     388               0 :     int n = width - start;
     389               0 :     if (n > count) {
     390               0 :         n = count;
     391                 :     }
     392               0 :     fill_sequential(xptr, start, n);
     393               0 :     xptr += n;
     394               0 :     count -= n;
     395                 : 
     396               0 :     while (count >= width) {
     397               0 :         fill_sequential(xptr, 0, width);
     398               0 :         xptr += width;
     399               0 :         count -= width;
     400                 :     }
     401                 : 
     402               0 :     if (count > 0) {
     403               0 :         fill_sequential(xptr, 0, count);
     404                 :     }
     405                 : }
     406                 : 
     407               0 : static void fill_backwards(uint16_t xptr[], int pos, int count) {
     408               0 :     for (int i = 0; i < count; i++) {
     409               0 :         SkASSERT(pos >= 0);
     410               0 :         xptr[i] = pos--;
     411                 :     }
     412               0 : }
     413                 : 
     414               0 : static void mirrorx_nofilter_trans(const SkBitmapProcState& s,
     415                 :                                    uint32_t xy[], int count, int x, int y) {
     416               0 :     SkASSERT((s.fInvType & ~SkMatrix::kTranslate_Mask) == 0);
     417                 : 
     418               0 :     int xpos = nofilter_trans_preamble(s, &xy, x, y);
     419               0 :     const int width = s.fBitmap->width();    
     420               0 :     if (1 == width) {
     421                 :         // all of the following X values must be 0
     422               0 :         memset(xy, 0, count * sizeof(uint16_t));
     423               0 :         return;
     424                 :     }
     425                 : 
     426               0 :     uint16_t* xptr = reinterpret_cast<uint16_t*>(xy);
     427                 :     // need to know our start, and our initial phase (forward or backward)
     428                 :     bool forward;
     429                 :     int n;
     430               0 :     int start = sk_int_mod(xpos, 2 * width);
     431               0 :     if (start >= width) {
     432               0 :         start = width + ~(start - width);
     433               0 :         forward = false;
     434               0 :         n = start + 1;  // [start .. 0]
     435                 :     } else {
     436               0 :         forward = true;
     437               0 :         n = width - start;  // [start .. width)
     438                 :     }
     439               0 :     if (n > count) {
     440               0 :         n = count;
     441                 :     }
     442               0 :     if (forward) {
     443               0 :         fill_sequential(xptr, start, n);
     444                 :     } else {
     445               0 :         fill_backwards(xptr, start, n);
     446                 :     }
     447               0 :     forward = !forward;
     448               0 :     xptr += n;
     449               0 :     count -= n;
     450                 :     
     451               0 :     while (count >= width) {
     452               0 :         if (forward) {
     453               0 :             fill_sequential(xptr, 0, width);
     454                 :         } else {
     455               0 :             fill_backwards(xptr, width - 1, width);
     456                 :         }
     457               0 :         forward = !forward;
     458               0 :         xptr += width;
     459               0 :         count -= width;
     460                 :     }
     461                 :     
     462               0 :     if (count > 0) {
     463               0 :         if (forward) {
     464               0 :             fill_sequential(xptr, 0, count);
     465                 :         } else {
     466               0 :             fill_backwards(xptr, width - 1, count);
     467                 :         }
     468                 :     }
     469                 : }
     470                 : 
     471                 : ///////////////////////////////////////////////////////////////////////////////
     472                 : 
     473                 : SkBitmapProcState::MatrixProc
     474               0 : SkBitmapProcState::chooseMatrixProc(bool trivial_matrix) {
     475                 : //    test_int_tileprocs();
     476                 :     // check for our special case when there is no scale/affine/perspective
     477               0 :     if (trivial_matrix) {
     478               0 :         SkASSERT(!fDoFilter);
     479               0 :         fIntTileProcY = choose_int_tile_proc(fTileModeY);
     480               0 :         switch (fTileModeX) {
     481                 :             case SkShader::kClamp_TileMode:
     482               0 :                 return clampx_nofilter_trans;
     483                 :             case SkShader::kRepeat_TileMode:
     484               0 :                 return repeatx_nofilter_trans;
     485                 :             case SkShader::kMirror_TileMode:
     486               0 :                 return mirrorx_nofilter_trans;
     487                 :         }
     488                 :     }
     489                 :     
     490               0 :     int index = 0;
     491               0 :     if (fDoFilter) {
     492               0 :         index = 1;
     493                 :     }
     494               0 :     if (fInvType & SkMatrix::kPerspective_Mask) {
     495               0 :         index += 4;
     496               0 :     } else if (fInvType & SkMatrix::kAffine_Mask) {
     497               0 :         index += 2;
     498                 :     }
     499                 :     
     500               0 :     if (SkShader::kClamp_TileMode == fTileModeX &&
     501                 :         SkShader::kClamp_TileMode == fTileModeY)
     502                 :     {
     503                 :         // clamp gets special version of filterOne
     504               0 :         fFilterOneX = SK_Fixed1;
     505               0 :         fFilterOneY = SK_Fixed1;
     506               0 :         return ClampX_ClampY_Procs[index];
     507                 :     }
     508                 :     
     509                 :     // all remaining procs use this form for filterOne
     510               0 :     fFilterOneX = SK_Fixed1 / fBitmap->width();
     511               0 :     fFilterOneY = SK_Fixed1 / fBitmap->height();
     512                 :     
     513               0 :     if (SkShader::kRepeat_TileMode == fTileModeX &&
     514                 :         SkShader::kRepeat_TileMode == fTileModeY)
     515                 :     {
     516               0 :         return RepeatX_RepeatY_Procs[index];
     517                 :     }
     518                 :     
     519               0 :     fTileProcX = choose_tile_proc(fTileModeX);
     520               0 :     fTileProcY = choose_tile_proc(fTileModeY);
     521               0 :     return GeneralXY_Procs[index];
     522                 : }
     523                 : 

Generated by: LCOV version 1.7