1 /*

     2  * Copyright 1998-2003 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 

    27 

    28 #include "vis_proto.h"

    29 #include "mlib_image.h"

    30 #include "mlib_v_ImageLookUpFunc.h"

    31 

    32 /***************************************************************/

    33 static void mlib_v_ImageLookUpSI_U8_U8_2_SrcOff0_D1(const mlib_u8  *src,

    34                                                     mlib_u8        *dst,

    35                                                     mlib_s32       xsize,

    36                                                     const mlib_u16 *table);

    37 

    38 static void mlib_v_ImageLookUpSI_U8_U8_2_SrcOff1_D1(const mlib_u8  *src,

    39                                                     mlib_u8        *dst,

    40                                                     mlib_s32       xsize,

    41                                                     const mlib_u16 *table);

    42 

    43 static void mlib_v_ImageLookUpSI_U8_U8_2_SrcOff2_D1(const mlib_u8  *src,

    44                                                     mlib_u8        *dst,

    45                                                     mlib_s32       xsize,

    46                                                     const mlib_u16 *table);

    47 

    48 static void mlib_v_ImageLookUpSI_U8_U8_2_SrcOff3_D1(const mlib_u8  *src,

    49                                                     mlib_u8        *dst,

    50                                                     mlib_s32       xsize,

    51                                                     const mlib_u16 *table);

    52 

    53 static void mlib_v_ImageLookUpSI_U8_U8_2_DstNonAl_D1(const mlib_u8  *src,

    54                                                      mlib_u8        *dst,

    55                                                      mlib_s32       xsize,

    56                                                      const mlib_u16 *table);

    57 

    58 static void mlib_v_ImageLookUpSI_U8_U8_2_DstA8D1_SMALL(const mlib_u8 *src,

    59                                                        mlib_u8       *dst,

    60                                                        mlib_s32      xsize,

    61                                                        const mlib_u8 **table);

    62 

    63 static void mlib_v_ImageLookUpSI_U8_U8_2_D1_SMALL(const mlib_u8 *src,

    64                                                   mlib_u8       *dst,

    65                                                   mlib_s32      xsize,

    66                                                   const mlib_u8 **table);

    67 

    68 static void mlib_v_ImageLookUpSI_U8_U8_3_SrcOff0_D1(const mlib_u8  *src,

    69                                                     mlib_u8        *dst,

    70                                                     mlib_s32       xsize,

    71                                                     const mlib_d64 *table);

    72 

    73 static void mlib_v_ImageLookUpSI_U8_U8_3_SrcOff1_D1(const mlib_u8  *src,

    74                                                     mlib_u8        *dst,

    75                                                     mlib_s32       xsize,

    76                                                     const mlib_d64 *table);

    77 

    78 static void mlib_v_ImageLookUpSI_U8_U8_3_SrcOff2_D1(const mlib_u8  *src,

    79                                                     mlib_u8        *dst,

    80                                                     mlib_s32       xsize,

    81                                                     const mlib_d64 *table);

    82 

    83 static void mlib_v_ImageLookUpSI_U8_U8_3_SrcOff3_D1(const mlib_u8  *src,

    84                                                     mlib_u8        *dst,

    85                                                     mlib_s32       xsize,

    86                                                     const mlib_d64 *table);

    87 

    88 static void mlib_v_ImageLookUpSI_U8_U8_3_D1_SMALL(const mlib_u8 *src,

    89                                                   mlib_u8       *dst,

    90                                                   mlib_s32      xsize,

    91                                                   const mlib_u8 **table);

    92 

    93 static void mlib_v_ImageLookUpSI_U8_U8_4_SrcOff0_D1(const mlib_u8  *src,

    94                                                     mlib_u8        *dst,

    95                                                     mlib_s32       xsize,

    96                                                     const mlib_f32 *table);

    97 

    98 static void mlib_v_ImageLookUpSI_U8_U8_4_DstNonAl_D1(const mlib_u8  *src,

    99                                                      mlib_u8        *dst,

   100                                                      mlib_s32       xsize,

   101                                                      const mlib_f32 *table);

   102 

   103 static void mlib_v_ImageLookUpSI_U8_U8_4_DstOff0_D1_SMALL(const mlib_u8 *src,

   104                                                           mlib_u8       *dst,

   105                                                           mlib_s32      xsize,

   106                                                           const mlib_u8 **table);

   107 

   108 static void mlib_v_ImageLookUpSI_U8_U8_4_DstOff1_D1_SMALL(const mlib_u8 *src,

   109                                                           mlib_u8       *dst,

   110                                                           mlib_s32      xsize,

   111                                                           const mlib_u8 **table);

   112 

   113 static void mlib_v_ImageLookUpSI_U8_U8_4_DstOff2_D1_SMALL(const mlib_u8 *src,

   114                                                           mlib_u8       *dst,

   115                                                           mlib_s32      xsize,

   116                                                           const mlib_u8 **table);

   117 

   118 static void mlib_v_ImageLookUpSI_U8_U8_4_DstOff3_D1_SMALL(const mlib_u8 *src,

   119                                                           mlib_u8       *dst,

   120                                                           mlib_s32      xsize,

   121                                                           const mlib_u8 **table);

   122 

   123 /***************************************************************/

   124 #define VIS_LD_U8_I(X, Y)       vis_ld_u8_i((void *)(X), (Y))

   125 #define VIS_LD_U16_I(X, Y)      vis_ld_u16_i((void *)(X), (Y))

   126 

   127 /***************************************************************/

   128 void mlib_v_ImageLookUpSI_U8_U8_2_SrcOff0_D1(const mlib_u8  *src,

   129                                              mlib_u8        *dst,

   130                                              mlib_s32       xsize,

   131                                              const mlib_u16 *table)

   132 {

   133   mlib_u32 *sa;          /* aligned pointer to source data */

   134   mlib_u8  *sp;          /* pointer to source data */

   135   mlib_u32 s0;           /* source data */

   136   mlib_u16 *dl;          /* pointer to start of destination */

   137   mlib_u16 *dend;        /* pointer to end of destination */

   138   mlib_d64 *dp;          /* aligned pointer to destination */

   139   mlib_d64 t0, t1, t2;   /* destination data */

   140   mlib_d64 t3, acc;      /* destination data */

   141   mlib_s32 emask;        /* edge mask */

   142   mlib_s32 i, num;       /* loop variable */

   143 

   144   sa   = (mlib_u32*)src;

   145   dl   = (mlib_u16*)dst;

   146   dp   = (mlib_d64 *) dl;

   147   dend = dl + xsize - 1;

   148 

   149   vis_alignaddr((void *) 0, 6);

   150 

   151   if (xsize >= 4) {

   152 

   153     s0 = sa[0];

   154     sa ++;

   155 

   156 #pragma pipeloop(0)

   157     for(i = 0; i <= xsize - 8; i+=4, sa++) {

   158       t3 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   159       t2 = VIS_LD_U16_I(table, (s0 >> 7) & 0x1FE);

   160       t1 = VIS_LD_U16_I(table, (s0 >> 15) & 0x1FE);

   161       t0 = VIS_LD_U16_I(table, (s0 >> 23) & 0x1FE);

   162       acc = vis_faligndata(t3, acc);

   163       acc = vis_faligndata(t2, acc);

   164       acc = vis_faligndata(t1, acc);

   165       acc = vis_faligndata(t0, acc);

   166       s0 = sa[0];

   167       *dp++ = acc;

   168     }

   169 

   170     t3 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   171     t2 = VIS_LD_U16_I(table, (s0 >> 7) & 0x1FE);

   172     t1 = VIS_LD_U16_I(table, (s0 >> 15) & 0x1FE);

   173     t0 = VIS_LD_U16_I(table, (s0 >> 23) & 0x1FE);

   174     acc = vis_faligndata(t3, acc);

   175     acc = vis_faligndata(t2, acc);

   176     acc = vis_faligndata(t1, acc);

   177     acc = vis_faligndata(t0, acc);

   178     *dp++ = acc;

   179   }

   180 

   181   sp = (mlib_u8*)sa;

   182 

   183   if ((mlib_addr) dp <= (mlib_addr) dend) {

   184 

   185     num = (mlib_u16*) dend - (mlib_u16*) dp;

   186     sp  += num;

   187     num ++;

   188 #pragma pipeloop(0)

   189     for (i = 0; i < num; i ++) {

   190       s0 = (mlib_s32) *sp;

   191       sp --;

   192 

   193       t0  = VIS_LD_U16_I(table, 2*s0);

   194       acc = vis_faligndata(t0, acc);

   195     }

   196 

   197     emask = vis_edge16(dp, dend);

   198     vis_pst_16(acc, dp, emask);

   199   }

   200 }

   201 

   202 /***************************************************************/

   203 void mlib_v_ImageLookUpSI_U8_U8_2_SrcOff1_D1(const mlib_u8  *src,

   204                                              mlib_u8        *dst,

   205                                              mlib_s32       xsize,

   206                                              const mlib_u16 *table)

   207 {

   208   mlib_u32 *sa;          /* aligned pointer to source data */

   209   mlib_u8  *sp;          /* pointer to source data */

   210   mlib_u32 s0, s1;       /* source data */

   211   mlib_u16 *dl;          /* pointer to start of destination */

   212   mlib_u16 *dend;        /* pointer to end of destination */

   213   mlib_d64 *dp;          /* aligned pointer to destination */

   214   mlib_d64 t0, t1, t2;   /* destination data */

   215   mlib_d64 t3, acc;      /* destination data */

   216   mlib_s32 emask;        /* edge mask */

   217   mlib_s32 i, num;       /* loop variable */

   218 

   219   sa   = (mlib_u32*)(src-1);

   220   dl   = (mlib_u16*)dst;

   221   dp   = (mlib_d64 *) dl;

   222   dend = dl + xsize - 1;

   223 

   224   vis_alignaddr((void *) 0, 6);

   225 

   226   s0 = *sa++;

   227 

   228   if (xsize >= 4) {

   229 

   230     s1 = sa[0];

   231     sa ++;

   232 

   233 #pragma pipeloop(0)

   234     for(i = 0; i <= xsize - 8; i+=4, sa++) {

   235       t3 = VIS_LD_U16_I(table, (s1 >> 23) & 0x1FE);

   236       t2 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   237       t1 = VIS_LD_U16_I(table, (s0 >> 7) & 0x1FE);

   238       t0 = VIS_LD_U16_I(table, (s0 >> 15) & 0x1FE);

   239       acc = vis_faligndata(t3, acc);

   240       acc = vis_faligndata(t2, acc);

   241       acc = vis_faligndata(t1, acc);

   242       acc = vis_faligndata(t0, acc);

   243       s0 = s1;

   244       s1 = sa[0];

   245       *dp++ = acc;

   246     }

   247 

   248     t3 = VIS_LD_U16_I(table, (s1 >> 23) & 0x1FE);

   249     t2 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   250     t1 = VIS_LD_U16_I(table, (s0 >> 7) & 0x1FE);

   251     t0 = VIS_LD_U16_I(table, (s0 >> 15) & 0x1FE);

   252     acc = vis_faligndata(t3, acc);

   253     acc = vis_faligndata(t2, acc);

   254     acc = vis_faligndata(t1, acc);

   255     acc = vis_faligndata(t0, acc);

   256     *dp++ = acc;

   257   }

   258 

   259   sp = (mlib_u8*)sa;

   260   sp -= 3;

   261 

   262   if ((mlib_addr) dp <= (mlib_addr) dend) {

   263 

   264     num = (mlib_u16*) dend - (mlib_u16*) dp;

   265     sp  += num;

   266     num ++;

   267 #pragma pipeloop(0)

   268     for (i = 0; i < num; i ++) {

   269       s0 = (mlib_s32) *sp;

   270       sp --;

   271 

   272       t0  = VIS_LD_U16_I(table, 2*s0);

   273       acc = vis_faligndata(t0, acc);

   274     }

   275 

   276     emask = vis_edge16(dp, dend);

   277     vis_pst_16(acc, dp, emask);

   278   }

   279 }

   280 

   281 /***************************************************************/

   282 void mlib_v_ImageLookUpSI_U8_U8_2_SrcOff2_D1(const mlib_u8  *src,

   283                                              mlib_u8        *dst,

   284                                              mlib_s32       xsize,

   285                                              const mlib_u16 *table)

   286 {

   287   mlib_u32 *sa;          /* pointer to source data */

   288   mlib_u8  *sp;          /* pointer to source data */

   289   mlib_u32 s0, s1;       /* source data */

   290   mlib_u16 *dl;          /* pointer to start of destination */

   291   mlib_u16 *dend;        /* pointer to end of destination */

   292   mlib_d64 *dp;          /* aligned pointer to destination */

   293   mlib_d64 t0, t1, t2;   /* destination data */

   294   mlib_d64 t3, acc;      /* destination data */

   295   mlib_s32 emask;        /* edge mask */

   296   mlib_s32 i, num;       /* loop variable */

   297 

   298   sa   = (mlib_u32*)(src-2);

   299   dl   = (mlib_u16*)dst;

   300   dp   = (mlib_d64 *) dl;

   301   dend = dl + xsize - 1;

   302 

   303   vis_alignaddr((void *) 0, 6);

   304 

   305   s0 = *sa++;

   306 

   307   if (xsize >= 4) {

   308 

   309     s1 = sa[0];

   310     sa ++;

   311 

   312 #pragma pipeloop(0)

   313     for(i = 0; i <= xsize - 8; i+=4, sa++) {

   314       t3 = VIS_LD_U16_I(table, (s1 >> 15) & 0x1FE);

   315       t2 = VIS_LD_U16_I(table, (s1 >> 23) & 0x1FE);

   316       t1 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   317       t0 = VIS_LD_U16_I(table, (s0 >> 7) & 0x1FE);

   318       acc = vis_faligndata(t3, acc);

   319       acc = vis_faligndata(t2, acc);

   320       acc = vis_faligndata(t1, acc);

   321       acc = vis_faligndata(t0, acc);

   322       s0 = s1;

   323       s1 = sa[0];

   324       *dp++ = acc;

   325     }

   326 

   327     t3 = VIS_LD_U16_I(table, (s1 >> 15) & 0x1FE);

   328     t2 = VIS_LD_U16_I(table, (s1 >> 23) & 0x1FE);

   329     t1 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   330     t0 = VIS_LD_U16_I(table, (s0 >> 7) & 0x1FE);

   331     acc = vis_faligndata(t3, acc);

   332     acc = vis_faligndata(t2, acc);

   333     acc = vis_faligndata(t1, acc);

   334     acc = vis_faligndata(t0, acc);

   335     *dp++ = acc;

   336   }

   337 

   338   sp = (mlib_u8*)sa;

   339   sp -= 2;

   340 

   341   if ((mlib_addr) dp <= (mlib_addr) dend) {

   342 

   343     num = (mlib_u16*) dend - (mlib_u16*) dp;

   344     sp  += num;

   345     num ++;

   346 #pragma pipeloop(0)

   347     for (i = 0; i < num; i ++) {

   348       s0 = (mlib_s32) *sp;

   349       sp --;

   350 

   351       t0  = VIS_LD_U16_I(table, 2*s0);

   352       acc = vis_faligndata(t0, acc);

   353     }

   354 

   355     emask = vis_edge16(dp, dend);

   356     vis_pst_16(acc, dp, emask);

   357   }

   358 }

   359 

   360 /***************************************************************/

   361 void mlib_v_ImageLookUpSI_U8_U8_2_SrcOff3_D1(const mlib_u8  *src,

   362                                              mlib_u8        *dst,

   363                                              mlib_s32       xsize,

   364                                              const mlib_u16 *table)

   365 {

   366   mlib_u32 *sa;          /* aligned pointer to source data */

   367   mlib_u8  *sp;          /* pointer to source data */

   368   mlib_u32 s0, s1;       /* source data */

   369   mlib_u16 *dl;          /* pointer to start of destination */

   370   mlib_u16 *dend;        /* pointer to end of destination */

   371   mlib_d64 *dp;          /* aligned pointer to destination */

   372   mlib_d64 t0, t1, t2;   /* destination data */

   373   mlib_d64 t3, acc;      /* destination data */

   374   mlib_s32 emask;        /* edge mask */

   375   mlib_s32 i, num;       /* loop variable */

   376 

   377   sa   = (mlib_u32*)(src-3);

   378   dl   = (mlib_u16*)dst;

   379   dp   = (mlib_d64 *) dl;

   380   dend = dl + xsize - 1;

   381 

   382   vis_alignaddr((void *) 0, 6);

   383 

   384   s0 = *sa++;

   385 

   386   if (xsize >= 4) {

   387 

   388     s1 = sa[0];

   389     sa ++;

   390 

   391 #pragma pipeloop(0)

   392     for(i = 0; i <= xsize - 8; i+=4, sa++) {

   393       t3 = VIS_LD_U16_I(table, (s1 >> 7) & 0x1FE);

   394       t2 = VIS_LD_U16_I(table, (s1 >> 15) & 0x1FE);

   395       t1 = VIS_LD_U16_I(table, (s1 >> 23) & 0x1FE);

   396       t0 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   397       acc = vis_faligndata(t3, acc);

   398       acc = vis_faligndata(t2, acc);

   399       acc = vis_faligndata(t1, acc);

   400       acc = vis_faligndata(t0, acc);

   401       s0 = s1;

   402       s1 = sa[0];

   403       *dp++ = acc;

   404     }

   405 

   406     t3 = VIS_LD_U16_I(table, (s1 >> 7) & 0x1FE);

   407     t2 = VIS_LD_U16_I(table, (s1 >> 15) & 0x1FE);

   408     t1 = VIS_LD_U16_I(table, (s1 >> 23) & 0x1FE);

   409     t0 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   410     acc = vis_faligndata(t3, acc);

   411     acc = vis_faligndata(t2, acc);

   412     acc = vis_faligndata(t1, acc);

   413     acc = vis_faligndata(t0, acc);

   414     *dp++ = acc;

   415   }

   416 

   417   sp = (mlib_u8*)sa;

   418   sp -= 1;

   419 

   420   if ((mlib_addr) dp <= (mlib_addr) dend) {

   421 

   422     num = (mlib_u16*) dend - (mlib_u16*) dp;

   423     sp  += num;

   424     num ++;

   425 #pragma pipeloop(0)

   426     for (i = 0; i < num; i ++) {

   427       s0 = (mlib_s32) *sp;

   428       sp --;

   429 

   430       t0  = VIS_LD_U16_I(table, 2*s0);

   431       acc = vis_faligndata(t0, acc);

   432     }

   433 

   434     emask = vis_edge16(dp, dend);

   435     vis_pst_16(acc, dp, emask);

   436   }

   437 }

   438 

   439 /***************************************************************/

   440 void mlib_v_ImageLookUpSI_U8_U8_2_DstNonAl_D1(const mlib_u8  *src,

   441                                               mlib_u8        *dst,

   442                                               mlib_s32       xsize,

   443                                               const mlib_u16 *table)

   444 {

   445   mlib_u32 *sa;             /* aligned pointer to source data */

   446   mlib_u8  *sp;             /* pointer to source data */

   447   mlib_u32 s0, s1, s2, s3;  /* source data */

   448   mlib_u8  *dl;             /* pointer to start of destination */

   449   mlib_u8  *dend;           /* pointer to end of destination */

   450   mlib_d64 *dp;             /* aligned pointer to destination */

   451   mlib_d64 t0, t1, t2;      /* destination data */

   452   mlib_d64 t3, t4, t5;      /* destination data */

   453   mlib_d64 t6, t7, acc0;    /* destination data */

   454   mlib_d64 acc1, acc2;      /* destination data */

   455   mlib_d64 acc3, acc4;      /* destination data */

   456   mlib_s32 emask;           /* edge mask */

   457   mlib_s32 i, num;          /* loop variable */

   458   mlib_s32 off;             /* offset */

   459 

   460   sa   = (mlib_u32*)src;

   461   dl   = dst;

   462   sp   = (void *)src;

   463   dend = dl + 2*xsize - 1;

   464   dp   = (mlib_d64 *) ((mlib_addr) dl & (~7));

   465   off  = (mlib_addr) dp - (mlib_addr) dl;

   466 

   467   emask = vis_edge8(dl, dend);

   468   num = (xsize < 4) ? xsize : 4;

   469 

   470   sp += (num-1);

   471 

   472   vis_alignaddr(dp, 6);

   473 

   474   for (i = 0; i < num; i ++) {

   475     s0 = (mlib_s32) *sp;

   476     sp --;

   477 

   478     t0  = VIS_LD_U16_I(table, 2*s0);

   479     acc0 = vis_faligndata(t0, acc0);

   480   }

   481 

   482   vis_alignaddr(dp, off);

   483   vis_pst_8(vis_faligndata(acc0, acc0), dp++, emask);

   484 

   485   sa++;

   486 

   487   xsize -= 4;

   488 

   489   i = 0;

   490 

   491   if (xsize >= 16) {

   492 

   493     s0 = sa[0];

   494     s1 = sa[1];

   495     s2 = sa[2];

   496     s3 = sa[3];

   497     sa += 4;

   498 

   499 #pragma pipeloop(0)

   500     for(i = 0; i <= xsize - 32; i+=16, sa+=4) {

   501       vis_alignaddr(dp, 6);

   502       t3 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   503       t2 = VIS_LD_U16_I(table, (s0 >> 7) & 0x1FE);

   504       t1 = VIS_LD_U16_I(table, (s0 >> 15) & 0x1FE);

   505       t0 = VIS_LD_U16_I(table, (s0 >> 23) & 0x1FE);

   506       acc1 = vis_faligndata(t3, acc1);

   507       acc1 = vis_faligndata(t2, acc1);

   508       acc1 = vis_faligndata(t1, acc1);

   509       acc1 = vis_faligndata(t0, acc1);

   510       t7 = VIS_LD_U16_I(table, (s1 << 1) & 0x1FE);

   511       t6 = VIS_LD_U16_I(table, (s1 >> 7) & 0x1FE);

   512       t5 = VIS_LD_U16_I(table, (s1 >> 15) & 0x1FE);

   513       t4 = VIS_LD_U16_I(table, (s1 >> 23) & 0x1FE);

   514       acc2 = vis_faligndata(t7, acc2);

   515       acc2 = vis_faligndata(t6, acc2);

   516       acc2 = vis_faligndata(t5, acc2);

   517       acc2 = vis_faligndata(t4, acc2);

   518       t3 = VIS_LD_U16_I(table, (s2 << 1) & 0x1FE);

   519       t2 = VIS_LD_U16_I(table, (s2 >> 7) & 0x1FE);

   520       t1 = VIS_LD_U16_I(table, (s2 >> 15) & 0x1FE);

   521       t0 = VIS_LD_U16_I(table, (s2 >> 23) & 0x1FE);

   522       acc3 = vis_faligndata(t3, acc3);

   523       acc3 = vis_faligndata(t2, acc3);

   524       acc3 = vis_faligndata(t1, acc3);

   525       acc3 = vis_faligndata(t0, acc3);

   526       t7 = VIS_LD_U16_I(table, (s3 << 1) & 0x1FE);

   527       t6 = VIS_LD_U16_I(table, (s3 >> 7) & 0x1FE);

   528       t5 = VIS_LD_U16_I(table, (s3 >> 15) & 0x1FE);

   529       t4 = VIS_LD_U16_I(table, (s3 >> 23) & 0x1FE);

   530       acc4 = vis_faligndata(t7, acc4);

   531       acc4 = vis_faligndata(t6, acc4);

   532       acc4 = vis_faligndata(t5, acc4);

   533       acc4 = vis_faligndata(t4, acc4);

   534       vis_alignaddr(dp, off);

   535       s0 = sa[0];

   536       s1 = sa[1];

   537       s2 = sa[2];

   538       s3 = sa[3];

   539       *dp++ = vis_faligndata(acc0, acc1);

   540       *dp++ = vis_faligndata(acc1, acc2);

   541       *dp++ = vis_faligndata(acc2, acc3);

   542       *dp++ = vis_faligndata(acc3, acc4);

   543       acc0 = acc4;

   544     }

   545 

   546     vis_alignaddr(dp, 6);

   547     t3 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   548     t2 = VIS_LD_U16_I(table, (s0 >> 7) & 0x1FE);

   549     t1 = VIS_LD_U16_I(table, (s0 >> 15) & 0x1FE);

   550     t0 = VIS_LD_U16_I(table, (s0 >> 23) & 0x1FE);

   551     acc1 = vis_faligndata(t3, acc1);

   552     acc1 = vis_faligndata(t2, acc1);

   553     acc1 = vis_faligndata(t1, acc1);

   554     acc1 = vis_faligndata(t0, acc1);

   555     t7 = VIS_LD_U16_I(table, (s1 << 1) & 0x1FE);

   556     t6 = VIS_LD_U16_I(table, (s1 >> 7) & 0x1FE);

   557     t5 = VIS_LD_U16_I(table, (s1 >> 15) & 0x1FE);

   558     t4 = VIS_LD_U16_I(table, (s1 >> 23) & 0x1FE);

   559     acc2 = vis_faligndata(t7, acc2);

   560     acc2 = vis_faligndata(t6, acc2);

   561     acc2 = vis_faligndata(t5, acc2);

   562     acc2 = vis_faligndata(t4, acc2);

   563     t3 = VIS_LD_U16_I(table, (s2 << 1) & 0x1FE);

   564     t2 = VIS_LD_U16_I(table, (s2 >> 7) & 0x1FE);

   565     t1 = VIS_LD_U16_I(table, (s2 >> 15) & 0x1FE);

   566     t0 = VIS_LD_U16_I(table, (s2 >> 23) & 0x1FE);

   567     acc3 = vis_faligndata(t3, acc3);

   568     acc3 = vis_faligndata(t2, acc3);

   569     acc3 = vis_faligndata(t1, acc3);

   570     acc3 = vis_faligndata(t0, acc3);

   571     t7 = VIS_LD_U16_I(table, (s3 << 1) & 0x1FE);

   572     t6 = VIS_LD_U16_I(table, (s3 >> 7) & 0x1FE);

   573     t5 = VIS_LD_U16_I(table, (s3 >> 15) & 0x1FE);

   574     t4 = VIS_LD_U16_I(table, (s3 >> 23) & 0x1FE);

   575     acc4 = vis_faligndata(t7, acc4);

   576     acc4 = vis_faligndata(t6, acc4);

   577     acc4 = vis_faligndata(t5, acc4);

   578     acc4 = vis_faligndata(t4, acc4);

   579     vis_alignaddr(dp, off);

   580     *dp++ = vis_faligndata(acc0, acc1);

   581     *dp++ = vis_faligndata(acc1, acc2);

   582     *dp++ = vis_faligndata(acc2, acc3);

   583     *dp++ = vis_faligndata(acc3, acc4);

   584     acc0 = acc4; i+=16;

   585   }

   586 

   587   if (i <= xsize - 8) {

   588     s0 = sa[0];

   589     s1 = sa[1];

   590     vis_alignaddr(dp, 6);

   591     t3 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   592     t2 = VIS_LD_U16_I(table, (s0 >> 7) & 0x1FE);

   593     t1 = VIS_LD_U16_I(table, (s0 >> 15) & 0x1FE);

   594     t0 = VIS_LD_U16_I(table, (s0 >> 23) & 0x1FE);

   595     acc1 = vis_faligndata(t3, acc1);

   596     acc1 = vis_faligndata(t2, acc1);

   597     acc1 = vis_faligndata(t1, acc1);

   598     acc1 = vis_faligndata(t0, acc1);

   599     t7 = VIS_LD_U16_I(table, (s1 << 1) & 0x1FE);

   600     t6 = VIS_LD_U16_I(table, (s1 >> 7) & 0x1FE);

   601     t5 = VIS_LD_U16_I(table, (s1 >> 15) & 0x1FE);

   602     t4 = VIS_LD_U16_I(table, (s1 >> 23) & 0x1FE);

   603     acc2 = vis_faligndata(t7, acc2);

   604     acc2 = vis_faligndata(t6, acc2);

   605     acc2 = vis_faligndata(t5, acc2);

   606     acc2 = vis_faligndata(t4, acc2);

   607     vis_alignaddr(dp, off);

   608     *dp++ = vis_faligndata(acc0, acc1);

   609     *dp++ = vis_faligndata(acc1, acc2);

   610     acc0 = acc2; i += 8; sa += 2;

   611   }

   612 

   613   if (i <= xsize - 4) {

   614     s0 = *sa++;

   615     vis_alignaddr(dp, 6);

   616     t3 = VIS_LD_U16_I(table, (s0 << 1) & 0x1FE);

   617     t2 = VIS_LD_U16_I(table, (s0 >> 7) & 0x1FE);

   618     t1 = VIS_LD_U16_I(table, (s0 >> 15) & 0x1FE);

   619     t0 = VIS_LD_U16_I(table, (s0 >> 23) & 0x1FE);

   620     acc1 = vis_faligndata(t3, acc1);

   621     acc1 = vis_faligndata(t2, acc1);

   622     acc1 = vis_faligndata(t1, acc1);

   623     acc1 = vis_faligndata(t0, acc1);

   624     vis_alignaddr(dp, off);

   625     *dp++ = vis_faligndata(acc0, acc1);

   626     acc0 = acc1;

   627   }

   628 

   629   sp = (mlib_u8*)sa;

   630 

   631   if ((mlib_addr) dp <= (mlib_addr) dend) {

   632 

   633     num = (((mlib_u8*) dend - (mlib_u8*) dp) + off + 1) >> 1;

   634     sp  += (num - 1);

   635     vis_alignaddr(dp, 6);

   636 #pragma pipeloop(0)

   637     for (i = 0; i < num; i ++) {

   638       s0 = (mlib_s32) *sp;

   639       sp --;

   640 

   641       t0  = VIS_LD_U16_I(table, 2*s0);

   642       acc1 = vis_faligndata(t0, acc1);

   643     }

   644 

   645     vis_alignaddr(dp, off);

   646     emask = vis_edge8(dp, dend);

   647     vis_pst_8(vis_faligndata(acc0, acc1), dp++, emask);

   648   }

   649 

   650   if ((mlib_addr) dp <= (mlib_addr) dend) {

   651     emask = vis_edge8(dp, dend);

   652     vis_pst_8(vis_faligndata(acc1, acc1), dp++, emask);

   653   }

   654 }

   655 

   656 /***************************************************************/

   657 void mlib_v_ImageLookUpSI_U8_U8_2_DstA8D1_SMALL(const mlib_u8 *src,

   658                                                 mlib_u8       *dst,

   659                                                 mlib_s32      xsize,

   660                                                 const mlib_u8 **table)

   661 {

   662   mlib_u8  *sp;              /* pointer to source data */

   663   mlib_u32 s0, s1, s2, s3;   /* source data */

   664   mlib_u16 *dl;              /* pointer to start of destination */

   665   mlib_u16 *dend;            /* pointer to end of destination */

   666   mlib_d64 *dp;              /* aligned pointer to destination */

   667   mlib_d64 t0, t1, t2;       /* destination data */

   668   mlib_d64 t3, t4, t5;       /* destination data */

   669   mlib_d64 t6, t7, acc;      /* destination data */

   670   mlib_s32 emask;            /* edge mask */

   671   mlib_s32 i, num;           /* loop variable */

   672   const mlib_u8  *tab0 = table[0];

   673   const mlib_u8  *tab1 = table[1];

   674 

   675   sp   = (void *)src;

   676   dl   = (mlib_u16*)dst;

   677   dp   = (mlib_d64 *) dl;

   678   dend = dl + xsize - 1;

   679 

   680   vis_alignaddr((void *) 0, 7);

   681 

   682   if (xsize >= 4) {

   683 

   684     s0 = sp[0];

   685     s1 = sp[1];

   686     s2 = sp[2];

   687     s3 = sp[3];

   688     sp += 4;

   689 

   690 #pragma pipeloop(0)

   691     for(i = 0; i <= xsize - 8; i+=4, sp+=4) {

   692       t7 = VIS_LD_U8_I(tab1, s3);

   693       t6 = VIS_LD_U8_I(tab0, s3);

   694       t5 = VIS_LD_U8_I(tab1, s2);

   695       t4 = VIS_LD_U8_I(tab0, s2);

   696       t3 = VIS_LD_U8_I(tab1, s1);

   697       t2 = VIS_LD_U8_I(tab0, s1);

   698       t1 = VIS_LD_U8_I(tab1, s0);

   699       t0 = VIS_LD_U8_I(tab0, s0);

   700       acc = vis_faligndata(t7, acc);

   701       acc = vis_faligndata(t6, acc);

   702       acc = vis_faligndata(t5, acc);

   703       acc = vis_faligndata(t4, acc);

   704       acc = vis_faligndata(t3, acc);

   705       acc = vis_faligndata(t2, acc);

   706       acc = vis_faligndata(t1, acc);

   707       acc = vis_faligndata(t0, acc);

   708       s0 = sp[0];

   709       s1 = sp[1];

   710       s2 = sp[2];

   711       s3 = sp[3];

   712       *dp++ = acc;

   713     }

   714 

   715     t7 = VIS_LD_U8_I(tab1, s3);

   716     t6 = VIS_LD_U8_I(tab0, s3);

   717     t5 = VIS_LD_U8_I(tab1, s2);

   718     t4 = VIS_LD_U8_I(tab0, s2);

   719     t3 = VIS_LD_U8_I(tab1, s1);

   720     t2 = VIS_LD_U8_I(tab0, s1);

   721     t1 = VIS_LD_U8_I(tab1, s0);

   722     t0 = VIS_LD_U8_I(tab0, s0);

   723     acc = vis_faligndata(t7, acc);

   724     acc = vis_faligndata(t6, acc);

   725     acc = vis_faligndata(t5, acc);

   726     acc = vis_faligndata(t4, acc);

   727     acc = vis_faligndata(t3, acc);

   728     acc = vis_faligndata(t2, acc);

   729     acc = vis_faligndata(t1, acc);

   730     acc = vis_faligndata(t0, acc);

   731     *dp++ = acc;

   732   }

   733 

   734   if ((mlib_addr) dp <= (mlib_addr) dend) {

   735 

   736     num = (mlib_u16*) dend - (mlib_u16*) dp;

   737     sp  += num;

   738     num ++;

   739 #pragma pipeloop(0)

   740     for (i = 0; i < num; i ++) {

   741       s0 = (mlib_s32) *sp;

   742       sp --;

   743 

   744       t0  = VIS_LD_U8_I(tab1, s0);

   745       acc = vis_faligndata(t0, acc);

   746 

   747       t0  = VIS_LD_U8_I(tab0, s0);

   748       acc = vis_faligndata(t0, acc);

   749     }

   750 

   751     emask = vis_edge16(dp, dend);

   752     vis_pst_16(acc, dp, emask);

   753   }

   754 }

   755 

   756 /***************************************************************/

   757 void mlib_v_ImageLookUpSI_U8_U8_2_D1_SMALL(const mlib_u8 *src,

   758                                            mlib_u8       *dst,

   759                                            mlib_s32      xsize,

   760                                            const mlib_u8 **table)

   761 {

   762   mlib_u8  *sp;                /* pointer to source data */

   763   mlib_u32 s0, s1, s2, s3, s4; /* source data */

   764   mlib_u8  *dl;                /* pointer to start of destination */

   765   mlib_u8  *dend;              /* pointer to end of destination */

   766   mlib_d64 *dp;                /* aligned pointer to destination */

   767   mlib_d64 t0, t1, t2;         /* destination data */

   768   mlib_d64 t3, t4, t5;         /* destination data */

   769   mlib_d64 t6, t7, acc;        /* destination data */

   770   mlib_s32 emask;              /* edge mask */

   771   mlib_s32 i, num;             /* loop variable */

   772   const mlib_u8  *tab0 = table[0];

   773   const mlib_u8  *tab1 = table[1];

   774 

   775   sp   = (void *)src;

   776   dl   = dst;

   777 

   778   dend = dl + 2 * xsize - 1;

   779 

   780   vis_alignaddr((void *) 0, 7);

   781 

   782   s0 = *sp++;

   783   *dl++ = tab0[s0];

   784   dp   = (mlib_d64 *) dl;

   785   xsize--;

   786 

   787   if (xsize >= 4) {

   788 

   789     s1 = sp[0];

   790     s2 = sp[1];

   791     s3 = sp[2];

   792     s4 = sp[3];

   793     sp += 4;

   794 

   795 #pragma pipeloop(0)

   796     for(i = 0; i <= xsize - 8; i+=4, sp+=4) {

   797       t7 = VIS_LD_U8_I(tab0, s4);

   798       t6 = VIS_LD_U8_I(tab1, s3);

   799       t5 = VIS_LD_U8_I(tab0, s3);

   800       t4 = VIS_LD_U8_I(tab1, s2);

   801       t3 = VIS_LD_U8_I(tab0, s2);

   802       t2 = VIS_LD_U8_I(tab1, s1);

   803       t1 = VIS_LD_U8_I(tab0, s1);

   804       t0 = VIS_LD_U8_I(tab1, s0);

   805       acc = vis_faligndata(t7, acc);

   806       acc = vis_faligndata(t6, acc);

   807       acc = vis_faligndata(t5, acc);

   808       acc = vis_faligndata(t4, acc);

   809       acc = vis_faligndata(t3, acc);

   810       acc = vis_faligndata(t2, acc);

   811       acc = vis_faligndata(t1, acc);

   812       acc = vis_faligndata(t0, acc);

   813       s0 = s4;

   814       s1 = sp[0];

   815       s2 = sp[1];

   816       s3 = sp[2];

   817       s4 = sp[3];

   818       *dp++ = acc;

   819     }

   820 

   821     t7 = VIS_LD_U8_I(tab0, s4);

   822     t6 = VIS_LD_U8_I(tab1, s3);

   823     t5 = VIS_LD_U8_I(tab0, s3);

   824     t4 = VIS_LD_U8_I(tab1, s2);

   825     t3 = VIS_LD_U8_I(tab0, s2);

   826     t2 = VIS_LD_U8_I(tab1, s1);

   827     t1 = VIS_LD_U8_I(tab0, s1);

   828     t0 = VIS_LD_U8_I(tab1, s0);

   829     acc = vis_faligndata(t7, acc);

   830     acc = vis_faligndata(t6, acc);

   831     acc = vis_faligndata(t5, acc);

   832     acc = vis_faligndata(t4, acc);

   833     acc = vis_faligndata(t3, acc);

   834     acc = vis_faligndata(t2, acc);

   835     acc = vis_faligndata(t1, acc);

   836     acc = vis_faligndata(t0, acc);

   837     s0 = s4;

   838     *dp++ = acc;

   839   }

   840 

   841   num = ((mlib_u8*) dend - (mlib_u8*) dp) >> 1;

   842   sp  += num;

   843   num ++;

   844 

   845 #pragma pipeloop(0)

   846   for (i = 0; i < num; i ++) {

   847     s1 = (mlib_s32) *sp;

   848     sp --;

   849 

   850     t0  = VIS_LD_U8_I(tab1, s1);

   851     acc = vis_faligndata(t0, acc);

   852 

   853     t0  = VIS_LD_U8_I(tab0, s1);

   854     acc = vis_faligndata(t0, acc);

   855   }

   856 

   857   t0  = VIS_LD_U8_I(tab1, s0);

   858   acc = vis_faligndata(t0, acc);

   859   emask = vis_edge8(dp, dend);

   860   vis_pst_8(acc, dp, emask);

   861 }

   862 

   863 /***************************************************************/

   864 void mlib_v_ImageLookUpSI_U8_U8_2(const mlib_u8 *src,

   865                                   mlib_s32      slb,

   866                                   mlib_u8       *dst,

   867                                   mlib_s32      dlb,

   868                                   mlib_s32      xsize,

   869                                   mlib_s32      ysize,

   870                                   const mlib_u8 **table)

   871 {

   872   if ((xsize * ysize) < 650) {

   873     mlib_u8  *sl;

   874     mlib_u8  *dl;

   875     mlib_s32 i, j;

   876 

   877     sl = (void *)src;

   878     dl = dst;

   879 

   880     /* row loop */

   881     for (j = 0; j < ysize; j ++) {

   882       mlib_u8 *sp = sl;

   883       mlib_u8 *dp = dl;

   884       mlib_s32 off, s0, size = xsize;

   885 

   886       off = ((8 - ((mlib_addr)dp & 7)) & 7) >> 1;

   887       off = (off < size) ? off : size;

   888 

   889       for (i = 0; i < off; i++) {

   890         s0 = *sp++;

   891         *dp++ = table[0][s0];

   892         *dp++ = table[1][s0];

   893         size--;

   894       }

   895 

   896       if (size > 0) {

   897 

   898         if (((mlib_addr)dp & 1) == 0) {

   899           mlib_v_ImageLookUpSI_U8_U8_2_DstA8D1_SMALL(sp, dp, size, table);

   900         } else {

   901           mlib_v_ImageLookUpSI_U8_U8_2_D1_SMALL(sp, dp, size, table);

   902         }

   903       }

   904 

   905       sl = (mlib_u8 *) ((mlib_u8 *) sl + slb);

   906       dl = (mlib_u8 *) ((mlib_u8 *) dl + dlb);

   907     }

   908 

   909   } else {

   910     mlib_u8  *sl;

   911     mlib_u8  *dl;

   912     mlib_u16 tab[256];

   913     const mlib_u8  *tab0 = table[0];

   914     const mlib_u8  *tab1 = table[1];

   915     mlib_s32 i, j, s0, s1, s2;

   916 

   917     s0 = tab0[0];

   918     s1 = tab1[0];

   919     for (i = 1; i < 256; i++) {

   920       s2 = (s0 << 8) + s1;

   921       s0 = tab0[i];

   922       s1 = tab1[i];

   923       tab[i-1] = (mlib_u16)s2;

   924     }

   925 

   926     s2 = (s0 << 8) + s1;

   927     tab[255] = (mlib_u16)s2;

   928 

   929     sl = (void *)src;

   930     dl = dst;

   931 

   932     /* row loop */

   933     for (j = 0; j < ysize; j ++) {

   934       mlib_u8 *sp = sl;

   935       mlib_u8 *dp = dl;

   936       mlib_s32 off, s0, size = xsize;

   937 

   938       if (((mlib_addr)dp & 1) == 0) {

   939 

   940         off = ((8 - ((mlib_addr)dp & 7)) & 7) >> 1;

   941         off = (off < size) ? off : size;

   942 

   943         for (i = 0; i < off; i++) {

   944           *(mlib_u16*)dp = tab[(*sp)];

   945           dp += 2;

   946           size--; sp++;

   947         }

   948 

   949         if (size > 0) {

   950 

   951           off = (mlib_addr)sp & 3;

   952 

   953           if (off == 0) {

   954             mlib_v_ImageLookUpSI_U8_U8_2_SrcOff0_D1(sp, dp, size, tab);

   955           } else if (off == 1) {

   956             mlib_v_ImageLookUpSI_U8_U8_2_SrcOff1_D1(sp, dp, size, tab);

   957           } else if (off == 2) {

   958             mlib_v_ImageLookUpSI_U8_U8_2_SrcOff2_D1(sp, dp, size, tab);

   959           } else {

   960             mlib_v_ImageLookUpSI_U8_U8_2_SrcOff3_D1(sp, dp, size, tab);

   961           }

   962         }

   963 

   964       } else {

   965 

   966         off = ((4 - ((mlib_addr)sp & 3)) & 3);

   967         off = (off < size) ? off : size;

   968 

   969         for (i = 0; i < off; i++) {

   970           s0 = tab[(*sp)];

   971           *dp++ = (s0 >> 8);

   972           *dp++ = (s0 & 0xFF);

   973           size--; sp++;

   974         }

   975 

   976         if (size > 0) {

   977           mlib_v_ImageLookUpSI_U8_U8_2_DstNonAl_D1(sp, dp, size, tab);

   978         }

   979       }

   980 

   981       sl = (mlib_u8 *) ((mlib_u8 *) sl + slb);

   982       dl = (mlib_u8 *) ((mlib_u8 *) dl + dlb);

   983     }

   984   }

   985 }

   986 

   987 /***************************************************************/

   988 void mlib_v_ImageLookUpSI_U8_U8_3_SrcOff0_D1(const mlib_u8  *src,

   989                                              mlib_u8        *dst,

   990                                              mlib_s32       xsize,

   991                                              const mlib_d64 *table)

   992 {

   993   mlib_u8  *sp;            /* pointer to source data */

   994   mlib_u32 *sa;            /* aligned pointer to source data */

   995   mlib_u32 s0;             /* source data */

   996   mlib_u8  *dl;            /* pointer to start of destination */

   997   mlib_f32 *dp;            /* aligned pointer to destination */

   998   mlib_d64 t0, t1, t2, t3; /* destination data */

   999   mlib_d64 acc0, acc1;     /* destination data */

  1000   mlib_s32 i;              /* loop variable */

  1001   mlib_u8  *ptr;

  1002 

  1003   dl   =  dst;

  1004   dp   = (mlib_f32 *) dl;

  1005   sp = (void *)src;

  1006   sa = (mlib_u32*)sp;

  1007 

  1008   vis_alignaddr((void *) 0, 3);

  1009 

  1010   i = 0;

  1011 

  1012   if (xsize >= 4) {

  1013 

  1014     s0 = *sa++;

  1015 

  1016 #pragma pipeloop(0)

  1017     for(i = 0; i <= xsize - 8; i+=4, dp+=3) {

  1018       t0 = *(mlib_d64*)((mlib_u8*)table + ((s0 >> 21) & 0x7F8 ));

  1019       t1 = *(mlib_d64*)((mlib_u8*)table + ((s0 >> 13) & 0x7F8 ));

  1020       t2 = *(mlib_d64*)((mlib_u8*)table + ((s0 >> 5) & 0x7F8 ));

  1021       t3 = *(mlib_d64*)((mlib_u8*)table + ((s0 << 3) & 0x7F8 ));

  1022       acc0 = vis_faligndata(t0, t0);

  1023       acc0 = vis_faligndata(acc0, t1);

  1024       acc1 = vis_faligndata(acc0, acc0);

  1025       acc0 = vis_faligndata(acc0, t2);

  1026       acc1 = vis_faligndata(acc1, acc0);

  1027       acc0 = vis_faligndata(acc0, t3);

  1028       s0 = *sa++;

  1029       dp[0] = vis_read_lo(acc1);

  1030       dp[1] = vis_read_hi(acc0);

  1031       dp[2] = vis_read_lo(acc0);

  1032     }

  1033 

  1034     t0 = *(mlib_d64*)((mlib_u8*)table + ((s0 >> 21) & 0x7F8 ));

  1035     t1 = *(mlib_d64*)((mlib_u8*)table + ((s0 >> 13) & 0x7F8 ));

  1036     t2 = *(mlib_d64*)((mlib_u8*)table + ((s0 >> 5) & 0x7F8 ));

  1037     t3 = *(mlib_d64*)((mlib_u8*)table + ((s0 << 3) & 0x7F8 ));

  1038     acc0 = vis_faligndata(t0, t0);

  1039     acc0 = vis_faligndata(acc0, t1);

  1040     acc1 = vis_faligndata(acc0, acc0);

  1041     acc0 = vis_faligndata(acc0, t2);

  1042     acc1 = vis_faligndata(acc1, acc0);

  1043     acc0 = vis_faligndata(acc0, t3);

  1044     dp[0] = vis_read_lo(acc1);

  1045     dp[1] = vis_read_hi(acc0);

  1046     dp[2] = vis_read_lo(acc0);

  1047     dp += 3;

  1048     i += 4;

  1049   }

  1050 

  1051   dl = (mlib_u8*)dp;

  1052 

  1053 #pragma pipeloop(0)

  1054   for (; i < xsize; i++) {

  1055     ptr = (mlib_u8*)(table + src[i]);

  1056     dl[0] = ptr[0];

  1057     dl[1] = ptr[1];

  1058     dl[2] = ptr[2];

  1059     dl += 3;

  1060   }

  1061 }

  1062 

  1063 /***************************************************************/

  1064 void mlib_v_ImageLookUpSI_U8_U8_3_SrcOff1_D1(const mlib_u8  *src,

  1065                                              mlib_u8        *dst,

  1066                                              mlib_s32       xsize,

  1067                                              const mlib_d64 *table)

  1068 {

  1069   mlib_u8  *sp;            /* pointer to source data */

  1070   mlib_u32 *sa;            /* aligned pointer to source data */

  1071   mlib_u32 s0, s1;         /* source data */

  1072   mlib_u8  *dl;            /* pointer to start of destination */

  1073   mlib_f32 *dp;            /* aligned pointer to destination */

  1074   mlib_d64 t0, t1, t2, t3; /* destination data */

  1075   mlib_d64 acc0, acc1;     /* destination data */

  1076   mlib_s32 i;              /* loop variable */

  1077   mlib_u8  *ptr;

  1078 

  1079   dl   =  dst;

  1080   dp   = (mlib_f32 *) dl;

  1081   sp = (void *)src;

  1082   sa = (mlib_u32*)(sp - 1);

  1083 

  1084   vis_alignaddr((void *) 0, 3);

  1085 

  1086   i = 0;

  1087   s0 = *sa++;

  1088 

  1089   if (xsize >= 4) {

  1090 

  1091     s1 = *sa++;

  1092 

  1093 #pragma pipeloop(0)

  1094     for(i = 0; i <= xsize - 8; i+=4, dp+=3) {

  1095       t0 = *(mlib_d64*)((mlib_u8*)table + ((s0 >> 13) & 0x7F8 ));

  1096       t1 = *(mlib_d64*)((mlib_u8*)table + ((s0 >> 5) & 0x7F8 ));

  1097       t2 = *(mlib_d64*)((mlib_u8*)table + ((s0 << 3) & 0x7F8 ));

  1098       t3 = *(mlib_d64*)((mlib_u8*)table + ((s1 >> 21) & 0x7F8 ));

  1099       acc0 = vis_faligndata(t0, t0);

  1100       acc0 = vis_faligndata(acc0, t1);

  1101       acc1 = vis_faligndata(acc0, acc0);

  1102       acc0 = vis_faligndata(acc0, t2);

  1103       acc1 = vis_faligndata(acc1, acc0);

  1104       acc0 = vis_faligndata(acc0, t3);

  1105       s0 = s1;

  1106       s1 = *sa++;

  1107       dp[0] = vis_read_lo(acc1);

  1108       dp[1] = vis_read_hi(acc0);

  1109       dp[2] = vis_read_lo(acc0);

  1110     }

  1111 

  1112     t0 = *(mlib_d64*)((mlib_u8*)table + ((s0 >> 13) & 0x7F8 ));

  1113     t1 = *(mlib_d64*)((mlib_u8*)table + ((s0 >> 5) & 0x7F8 ));

  1114     t2 = *(mlib_d64*)((mlib_u8*)table + ((s0 << 3) & 0x7F8 ));

  1115     t3 = *(mlib_d64*)((mlib_u8*)table + ((s1 >> 21) & 0x7F8 ));

  1116     acc0 = vis_faligndata(t0, t0);

  1117     acc0 = vis_faligndata(acc0, t1);

  1118     acc1 = vis_faligndata(acc0, acc0);

  1119     acc0 = vis_faligndata(acc0, t2);

  1120     acc1 = vis_faligndata(acc1, acc0);

  1121     acc0 = vis_faligndata(acc0, t3);

  1122     dp[0] = vis_read_lo(acc1);

  1123     dp[1] = vis_read_hi(acc0);

  1124     dp[2] = vis_read_lo(acc0);

  1125     dp += 3;

  1126     i += 4;

  1127   }

  1128 

  1129   dl = (mlib_u8*)dp;

  1130 

  1131 #pragma pipeloop(0)

  1132   for (; i < xsize; i++) {

  1133     ptr = (mlib_u8*)(table + src[i]);

  1134     dl[0] = ptr[0];

  1135     dl[1] = ptr[1];