CoCalc -- mlib_ImageLookUp

GitHub Repository: PojavLauncherTeam/mobile
Path: blob/master/src/java.desktop/share/native/libmlib_image/mlib_ImageLookUp_64.c
⁴¹¹⁵² views
1
/*
2
 * Copyright (c) 1999, 2020, Oracle and/or its affiliates. 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.  Oracle designates this
8
 * particular file as subject to the "Classpath" exception as provided
9
 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22
 * or visit www.oracle.com if you need additional information or have any
23
 * questions.
24
 */
25

26

27
/*
28
 * FUNCTION
29
 *      mlib_ImageLookUp_U8D64 - table lookup
30
 *      mlib_ImageLookUp_S16D64 - table lookup
31
 *      mlib_ImageLookUp_U16D64 - table lookup
32
 *      mlib_ImageLookUp_S32D64 - table lookup
33
 *
34
 * SYNOPSIS
35
 *      void mlib_ImageLookUp_U8_D64(src, slb,
36
 *                                   dst, dlb,
37
 *                                   xsize, ysize,
38
 *                                   csize, table)
39
 *
40
 *      void mlib_ImageLookUp_S16_D64(src, slb,
41
 *                                    dst, dlb,
42
 *                                    xsize, ysize,
43
 *                                    csize, table)
44
 *
45
 *      void mlib_ImageLookUp_U16_D64(src, slb,
46
 *                                    dst, dlb,
47
 *                                    xsize, ysize,
48
 *                                    csize, table)
49
 *
50
 *      void mlib_ImageLookUp_S32_D64(src, slb,
51
 *                                    dst, dlb,
52
 *                                    xsize, ysize,
53
 *                                    csize, table)
54
 *
55
 * ARGUMENT
56
 *      src     pointer to input image (BYTE, SHORT, USHORT, INT)
57
 *      slb     stride of input image (in pixels)
58
 *      dst     pointer to output image (DOUBLE)
59
 *      dlb     stride of output image (in pixels)
60
 *      xsize   image width
61
 *      ysize   image height
62
 *      csize   number of channels
63
 *      table   lookup table
64
 *
65
 * DESCRIPTION
66
 *      dst = table[src] (c, vis version)
67
 */
68

69
#include "mlib_image.h"
70
#include "mlib_ImageLookUp.h"
71

72
/***************************************************************/
73
#define MLIB_C_IMAGELOOKUP(DTYPE, STYPE, TABLE)                 \
74
{                                                               \
75
  mlib_s32 i, j, k;                                             \
76
                                                                \
77
  if (xsize < 2) {                                              \
78
    for(j = 0; j < ysize; j++, dst += dlb, src += slb){         \
79
      for(k = 0; k < csize; k++) {                              \
80
        DTYPE *da = dst + k;                                    \
81
        const STYPE *sa = src + k;                              \
82
        DTYPE *tab = (DTYPE*) TABLE[k];                         \
83
                                                                \
84
        for(i = 0; i < xsize; i++, da += csize, sa += csize)    \
85
        *da=tab[*sa];                                           \
86
      }                                                         \
87
    }                                                           \
88
  } else {                                                      \
89
    for(j = 0; j < ysize; j++, dst += dlb, src += slb) {        \
90
      for(k = 0; k < csize; k++) {                              \
91
        DTYPE *da = dst + k;                                    \
92
        const STYPE *sa = src + k;                              \
93
        DTYPE *tab = (DTYPE*) TABLE[k];                         \
94
        mlib_s32 s0, s1;                                        \
95
        DTYPE t0, t1;                                           \
96
                                                                \
97
        s0 = (mlib_s32)sa[0];                                   \
98
        s1 = (mlib_s32)sa[csize];                               \
99
        sa += 2*csize;                                          \
100
                                                                \
101
        for(i = 0;                                              \
102
            i < xsize - 3;                                      \
103
            i+=2, da += 2*csize, sa += 2*csize) {               \
104
          t0 = tab[s0];                                         \
105
          t1 = tab[s1];                                         \
106
          s0 = (mlib_s32)sa[0];                                 \
107
          s1 = (mlib_s32)sa[csize];                             \
108
          da[0] = (DTYPE)t0;                                    \
109
          da[csize] = (DTYPE)t1;                                \
110
        }                                                       \
111
        t0 = tab[s0];                                           \
112
        t1 = tab[s1];                                           \
113
        da[0] = (DTYPE)t0;                                      \
114
        da[csize] = (DTYPE)t1;                                  \
115
        if (xsize & 1) da[2*csize] = tab[sa[0]];                \
116
      }                                                         \
117
    }                                                           \
118
  }                                                             \
119
}
120

121
/***************************************************************/
122
#define MLIB_C_IMAGELOOKUPSI(DTYPE, STYPE, TABLE)               \
123
{                                                               \
124
  mlib_s32 i, j, k;                                             \
125
                                                                \
126
  if (xsize < 2) {                                              \
127
    for(j = 0; j < ysize; j++, dst += dlb, src += slb){         \
128
      for(k = 0; k < csize; k++) {                              \
129
        DTYPE *da = dst + k;                                    \
130
        const STYPE *sa = (void *)src;                                  \
131
        DTYPE *tab = (DTYPE*) TABLE[k];                         \
132
                                                                \
133
        for(i = 0; i < xsize; i++, da += csize, sa ++)          \
134
        *da=tab[*sa];                                           \
135
      }                                                         \
136
    }                                                           \
137
  } else {                                                      \
138
    for(j = 0; j < ysize; j++, dst += dlb, src += slb) {        \
139
      for(k = 0; k < csize; k++) {                              \
140
        DTYPE *da = dst + k;                                    \
141
        const STYPE *sa = (void *)src;                                  \
142
        DTYPE *tab = (DTYPE*) TABLE[k];                         \
143
        mlib_s32 s0, s1;                                        \
144
        DTYPE t0, t1;                                           \
145
                                                                \
146
        s0 = (mlib_s32)sa[0];                                   \
147
        s1 = (mlib_s32)sa[1];                                   \
148
        sa += 2;                                                \
149
                                                                \
150
        for(i = 0;                                              \
151
            i < xsize - 3;                                      \
152
            i+=2, da += 2*csize, sa += 2) {                     \
153
          t0 = tab[s0];                                         \
154
          t1 = tab[s1];                                         \
155
          s0 = (mlib_s32)sa[0];                                 \
156
          s1 = (mlib_s32)sa[1];                                 \
157
          da[0] = (DTYPE)t0;                                    \
158
          da[csize] = (DTYPE)t1;                                \
159
        }                                                       \
160
        t0 = tab[s0];                                           \
161
        t1 = tab[s1];                                           \
162
        da[0] = (DTYPE)t0;                                      \
163
        da[csize] = (DTYPE)t1;                                  \
164
        if (xsize & 1) da[2*csize] = tab[sa[0]];                \
165
      }                                                         \
166
    }                                                           \
167
  }                                                             \
168
}
169

170
/***************************************************************/
171
#ifdef _LITTLE_ENDIAN
172

173
#define READ_U8_D64(table0, table1, table2, table3)             \
174
  t0 = *(mlib_d64*)((mlib_u8*)table0 + ((s0 << 3) & 0x7F8));    \
175
  t1 = *(mlib_d64*)((mlib_u8*)table1 + ((s0 >> 5) & 0x7F8));    \
176
  t2 = *(mlib_d64*)((mlib_u8*)table2 + ((s0 >> 13)  & 0x7F8));  \
177
  t3 = *(mlib_d64*)((mlib_u8*)table3 + ((s0 >> 21)  & 0x7F8))
178

179
#else
180

181
#define READ_U8_D64(table0, table1, table2, table3)             \
182
  t0 = *(mlib_d64*)((mlib_u8*)table0 + ((s0 >> 21) & 0x7F8));   \
183
  t1 = *(mlib_d64*)((mlib_u8*)table1 + ((s0 >> 13) & 0x7F8));   \
184
  t2 = *(mlib_d64*)((mlib_u8*)table2 + ((s0 >> 5)  & 0x7F8));   \
185
  t3 = *(mlib_d64*)((mlib_u8*)table3 + ((s0 << 3)  & 0x7F8))
186

187
#endif /* _LITTLE_ENDIAN */
188

189
/***************************************************************/
190
void mlib_ImageLookUp_U8_D64(const mlib_u8  *src,
191
                             mlib_s32       slb,
192
                             mlib_d64       *dst,
193
                             mlib_s32       dlb,
194
                             mlib_s32       xsize,
195
                             mlib_s32       ysize,
196
                             mlib_s32       csize,
197
                             const mlib_d64 **table)
198
{
199

200
  if (xsize * csize < 7) {
201
    MLIB_C_IMAGELOOKUP(mlib_d64, mlib_u8, table);
202
  }
203
  else if (csize == 1) {
204
    mlib_s32 i, j;
205

206
    for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
207
      mlib_u32 *sa;
208
      mlib_d64 *tab = (mlib_d64 *) table[0];
209
      mlib_u32 s0;
210
      mlib_d64 t0, t1, t2, t3;
211
      mlib_s32 off;
212
      mlib_s32 size = xsize;
213
      mlib_d64 *dp = (mlib_d64 *) dst;
214
      mlib_u8 *sp = (void *)src;
215

216
      off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
217

218
      for (i = 0; i < off; i++, sp++) {
219
        *dp++ = tab[sp[0]];
220
        size--;
221
      }
222

223
      sa = (mlib_u32 *) sp;
224

225
      s0 = sa[0];
226
      sa++;
227

228
      for (i = 0; i < size - 7; i += 4, dp += 4, sa++) {
229
        READ_U8_D64(tab, tab, tab, tab);
230
        s0 = sa[0];
231
        dp[0] = t0;
232
        dp[1] = t1;
233
        dp[2] = t2;
234
        dp[3] = t3;
235
      }
236

237
      READ_U8_D64(tab, tab, tab, tab);
238
      dp[0] = t0;
239
      dp[1] = t1;
240
      dp[2] = t2;
241
      dp[3] = t3;
242
      dp += 4;
243
      sp = (mlib_u8 *) sa;
244
      i += 4;
245
      for (; i < size; i++, dp++, sp++)
246
        dp[0] = tab[sp[0]];
247
    }
248
  }
249
  else if (csize == 2) {
250
    mlib_s32 i, j;
251

252
    for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
253
      mlib_u32 *sa;
254
      mlib_d64 *tab0 = (mlib_d64 *) table[0];
255
      mlib_d64 *tab1 = (mlib_d64 *) table[1];
256
      mlib_d64 *tab;
257
      mlib_u32 s0;
258
      mlib_d64 t0, t1, t2, t3;
259
      mlib_s32 off;
260
      mlib_s32 size = xsize * 2;
261
      mlib_d64 *dp = (mlib_d64 *) dst;
262
      mlib_u8 *sp = (void *)src;
263

264
      off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
265

266
      for (i = 0; i < off - 1; i += 2, sp += 2) {
267
        *dp++ = tab0[sp[0]];
268
        *dp++ = tab1[sp[1]];
269
        size -= 2;
270
      }
271

272
      if ((off & 1) != 0) {
273
        *dp++ = tab0[*sp];
274
        size--;
275
        sp++;
276
        tab = tab0;
277
        tab0 = tab1;
278
        tab1 = tab;
279
      }
280

281
      sa = (mlib_u32 *) sp;
282

283
      s0 = sa[0];
284
      sa++;
285

286
      for (i = 0; i < size - 7; i += 4, dp += 4, sa++) {
287
        READ_U8_D64(tab0, tab1, tab0, tab1);
288
        s0 = sa[0];
289
        dp[0] = t0;
290
        dp[1] = t1;
291
        dp[2] = t2;
292
        dp[3] = t3;
293
      }
294

295
      READ_U8_D64(tab0, tab1, tab0, tab1);
296
      dp[0] = t0;
297
      dp[1] = t1;
298
      dp[2] = t2;
299
      dp[3] = t3;
300
      dp += 4;
301
      sp = (mlib_u8 *) sa;
302
      i += 4;
303

304
      for (; i < size - 1; i += 2, sp += 2) {
305
        *dp++ = tab0[sp[0]];
306
        *dp++ = tab1[sp[1]];
307
      }
308

309
      if (i < size)
310
        *dp = tab0[(*sp)];
311
    }
312
  }
313
  else if (csize == 3) {
314
    mlib_s32 i, j;
315

316
    for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
317
      mlib_u32 *sa;
318
      mlib_d64 *tab0 = (mlib_d64 *) table[0];
319
      mlib_d64 *tab1 = (mlib_d64 *) table[1];
320
      mlib_d64 *tab2 = (mlib_d64 *) table[2];
321
      mlib_d64 *tab;
322
      mlib_u32 s0;
323
      mlib_d64 t0, t1, t2, t3;
324
      mlib_s32 off;
325
      mlib_s32 size = xsize * 3;
326
      mlib_d64 *dp = (mlib_d64 *) dst;
327
      mlib_u8 *sp = (void *)src;
328

329
      off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
330

331
      if (off == 1) {
332
        *dp++ = tab0[(*sp)];
333
        tab = tab0;
334
        tab0 = tab1;
335
        tab1 = tab2;
336
        tab2 = tab;
337
        size--;
338
        sp++;
339
      }
340
      else if (off == 2) {
341
        *dp++ = tab0[sp[0]];
342
        *dp++ = tab1[sp[1]];
343
        tab = tab2;
344
        tab2 = tab1;
345
        tab1 = tab0;
346
        tab0 = tab;
347
        size -= 2;
348
        sp += 2;
349
      }
350
      else if (off == 3) {
351
        *dp++ = tab0[sp[0]];
352
        *dp++ = tab1[sp[1]];
353
        *dp++ = tab2[sp[2]];
354
        size -= 3;
355
        sp += 3;
356
      }
357

358
      sa = (mlib_u32 *) sp;
359

360
      s0 = sa[0];
361
      sa++;
362

363
      for (i = 0; i < size - 7; i += 4, dp += 4, sa++) {
364
        READ_U8_D64(tab0, tab1, tab2, tab0);
365
        tab = tab0;
366
        tab0 = tab1;
367
        tab1 = tab2;
368
        tab2 = tab;
369
        s0 = sa[0];
370
        dp[0] = t0;
371
        dp[1] = t1;
372
        dp[2] = t2;
373
        dp[3] = t3;
374
      }
375

376
      READ_U8_D64(tab0, tab1, tab2, tab0);
377
      dp[0] = t0;
378
      dp[1] = t1;
379
      dp[2] = t2;
380
      dp[3] = t3;
381
      dp += 4;
382
      sp = (mlib_u8 *) sa;
383
      i += 4;
384

385
      if (i < size) {
386
        *dp++ = tab1[(*sp)];
387
        i++;
388
        sp++;
389
      }
390

391
      if (i < size) {
392
        *dp++ = tab2[(*sp)];
393
        i++;
394
        sp++;
395
      }
396

397
      if (i < size) {
398
        *dp = tab0[(*sp)];
399
      }
400
    }
401
  }
402
  else if (csize == 4) {
403
    mlib_s32 i, j;
404

405
    for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
406
      mlib_u32 *sa;
407
      mlib_d64 *tab0 = (mlib_d64 *) table[0];
408
      mlib_d64 *tab1 = (mlib_d64 *) table[1];
409
      mlib_d64 *tab2 = (mlib_d64 *) table[2];
410
      mlib_d64 *tab3 = (mlib_d64 *) table[3];
411
      mlib_d64 *tab;
412
      mlib_u32 s0;
413
      mlib_d64 t0, t1, t2, t3;
414
      mlib_s32 off;
415
      mlib_s32 size = xsize * 4;
416
      mlib_d64 *dp = (mlib_d64 *) dst;
417
      mlib_u8 *sp = (void *)src;
418

419
      off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
420

421
      if (off == 1) {
422
        *dp++ = tab0[(*sp)];
423
        tab = tab0;
424
        tab0 = tab1;
425
        tab1 = tab2;
426
        tab2 = tab3;
427
        tab3 = tab;
428
        size--;
429
        sp++;
430
      }
431
      else if (off == 2) {
432
        *dp++ = tab0[sp[0]];
433
        *dp++ = tab1[sp[1]];
434
        tab = tab0;
435
        tab0 = tab2;
436
        tab2 = tab;
437
        tab = tab1;
438
        tab1 = tab3;
439
        tab3 = tab;
440
        size -= 2;
441
        sp += 2;
442
      }
443
      else if (off == 3) {
444
        *dp++ = tab0[sp[0]];
445
        *dp++ = tab1[sp[1]];
446
        *dp++ = tab2[sp[2]];
447
        tab = tab3;
448
        tab3 = tab2;
449
        tab2 = tab1;
450
        tab1 = tab0;
451
        tab0 = tab;
452
        size -= 3;
453
        sp += 3;
454
      }
455

456
      sa = (mlib_u32 *) sp;
457

458
      s0 = sa[0];
459
      sa++;
460

461
      for (i = 0; i < size - 7; i += 4, dp += 4, sa++) {
462
        READ_U8_D64(tab0, tab1, tab2, tab3);
463
        s0 = sa[0];
464
        dp[0] = t0;
465
        dp[1] = t1;
466
        dp[2] = t2;
467
        dp[3] = t3;
468
      }
469

470
      READ_U8_D64(tab0, tab1, tab2, tab3);
471
      dp[0] = t0;
472
      dp[1] = t1;
473
      dp[2] = t2;
474
      dp[3] = t3;
475
      dp += 4;
476
      sp = (mlib_u8 *) sa;
477
      i += 4;
478

479
      if (i < size) {
480
        *dp++ = tab0[(*sp)];
481
        i++;
482
        sp++;
483
      }
484

485
      if (i < size) {
486
        *dp++ = tab1[(*sp)];
487
        i++;
488
        sp++;
489
      }
490

491
      if (i < size) {
492
        *dp = tab2[(*sp)];
493
      }
494
    }
495
  }
496
}
497

498
/***************************************************************/
499
void mlib_ImageLookUp_S16_D64(const mlib_s16 *src,
500
                              mlib_s32       slb,
501
                              mlib_d64       *dst,
502
                              mlib_s32       dlb,
503
                              mlib_s32       xsize,
504
                              mlib_s32       ysize,
505
                              mlib_s32       csize,
506
                              const mlib_d64 **table)
507
{
508
  const mlib_d64 *table_base[4];
509
  mlib_s32 c;
510

511
  for (c = 0; c < csize; c++) {
512
    table_base[c] = &table[c][32768];
513
  }
514

515
  MLIB_C_IMAGELOOKUP(mlib_d64, mlib_s16, table_base);
516
}
517

518
/***************************************************************/
519
void mlib_ImageLookUp_U16_D64(const mlib_u16 *src,
520
                              mlib_s32       slb,
521
                              mlib_d64       *dst,
522
                              mlib_s32       dlb,
523
                              mlib_s32       xsize,
524
                              mlib_s32       ysize,
525
                              mlib_s32       csize,
526
                              const mlib_d64 **table)
527
{
528
  const mlib_d64 *table_base[4];
529
  mlib_s32 c;
530

531
  for (c = 0; c < csize; c++) {
532
    table_base[c] = &table[c][0];
533
  }
534

535
  MLIB_C_IMAGELOOKUP(mlib_d64, mlib_u16, table_base);
536
}
537

538
/***************************************************************/
539
void mlib_ImageLookUp_S32_D64(const mlib_s32 *src,
540
                              mlib_s32       slb,
541
                              mlib_d64       *dst,
542
                              mlib_s32       dlb,
543
                              mlib_s32       xsize,
544
                              mlib_s32       ysize,
545
                              mlib_s32       csize,
546
                              const mlib_d64 **table)
547
{
548
  const mlib_d64 *table_base[4];
549
  mlib_u32 shift = TABLE_SHIFT_S32;
550
  mlib_s32 c;
551

552
  for (c = 0; c < csize; c++) {
553
    table_base[c] = &table[c][shift];
554
  }
555

556
  MLIB_C_IMAGELOOKUP(mlib_d64, mlib_s32, table_base);
557
}
558

559
/***************************************************************/
560
void mlib_ImageLookUpSI_U8_D64(const mlib_u8  *src,
561
                               mlib_s32       slb,
562
                               mlib_d64       *dst,
563
                               mlib_s32       dlb,
564
                               mlib_s32       xsize,
565
                               mlib_s32       ysize,
566
                               mlib_s32       csize,
567
                               const mlib_d64 **table)
568
{
569

570
  if (xsize < 7) {
571
    MLIB_C_IMAGELOOKUPSI(mlib_d64, mlib_u8, table);
572
  }
573
  else if (csize == 2) {
574
    mlib_s32 i, j;
575

576
    for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
577
      mlib_u32 *sa;
578
      mlib_d64 *tab0 = (mlib_d64 *) table[0];
579
      mlib_d64 *tab1 = (mlib_d64 *) table[1];
580
      mlib_u32 s0;
581
      mlib_d64 t0, t1, t2, t3;
582
      mlib_s32 off;
583
      mlib_s32 size = xsize;
584
      mlib_d64 *dp = (mlib_d64 *) dst;
585
      mlib_u8 *sp = (void *)src;
586

587
      off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
588

589
      for (i = 0; i < off; i++, sp++) {
590
        *dp++ = tab0[sp[0]];
591
        *dp++ = tab1[sp[0]];
592
        size--;
593
      }
594

595
      sa = (mlib_u32 *) sp;
596

597
      s0 = sa[0];
598
      sa++;
599

600
      for (i = 0; i < size - 7; i += 4, dp += 8, sa++) {
601
#ifdef _LITTLE_ENDIAN
602
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
603
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
604
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
605
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
606
#else
607
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
608
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
609
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
610
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
611
#endif /* _LITTLE_ENDIAN */
612
        dp[0] = t0;
613
        dp[1] = t1;
614
        dp[2] = t2;
615
        dp[3] = t3;
616
#ifdef _LITTLE_ENDIAN
617
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
618
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
619
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
620
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
621
#else
622
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
623
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
624
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
625
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
626
#endif /* _LITTLE_ENDIAN */
627
        s0 = sa[0];
628
        dp[4] = t0;
629
        dp[5] = t1;
630
        dp[6] = t2;
631
        dp[7] = t3;
632
      }
633

634
#ifdef _LITTLE_ENDIAN
635
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
636
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
637
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
638
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
639
#else
640
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
641
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
642
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
643
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
644
#endif /* _LITTLE_ENDIAN */
645
      dp[0] = t0;
646
      dp[1] = t1;
647
      dp[2] = t2;
648
      dp[3] = t3;
649
#ifdef _LITTLE_ENDIAN
650
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
651
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
652
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
653
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
654
#else
655
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
656
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
657
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
658
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
659
#endif /* _LITTLE_ENDIAN */
660
      dp[4] = t0;
661
      dp[5] = t1;
662
      dp[6] = t2;
663
      dp[7] = t3;
664
      dp += 8;
665
      sp = (mlib_u8 *) sa;
666
      i += 4;
667

668
      for (; i < size; i++, sp++) {
669
        *dp++ = tab0[sp[0]];
670
        *dp++ = tab1[sp[0]];
671
      }
672
    }
673
  }
674
  else if (csize == 3) {
675
    mlib_s32 i, j;
676

677
    for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
678
      mlib_u32 *sa;
679
      mlib_d64 *tab0 = (mlib_d64 *) table[0];
680
      mlib_d64 *tab1 = (mlib_d64 *) table[1];
681
      mlib_d64 *tab2 = (mlib_d64 *) table[2];
682
      mlib_u32 s0;
683
      mlib_d64 t0, t1, t2, t3, t4, t5;
684
      mlib_s32 off;
685
      mlib_s32 size = xsize;
686
      mlib_d64 *dp = (mlib_d64 *) dst;
687
      mlib_u8 *sp = (void *)src;
688

689
      off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
690

691
      for (i = 0; i < off; i++, sp++) {
692
        *dp++ = tab0[sp[0]];
693
        *dp++ = tab1[sp[0]];
694
        *dp++ = tab2[sp[0]];
695
        size--;
696
      }
697

698
      sa = (mlib_u32 *) sp;
699

700
      s0 = sa[0];
701
      sa++;
702

703
      for (i = 0; i < size - 7; i += 4, dp += 12, sa++) {
704
#ifdef _LITTLE_ENDIAN
705
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
706
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
707
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
708
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
709
        t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
710
        t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
711
#else
712
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
713
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
714
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
715
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
716
        t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
717
        t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
718
#endif /* _LITTLE_ENDIAN */
719
        dp[0] = t0;
720
        dp[1] = t1;
721
        dp[2] = t2;
722
        dp[3] = t3;
723
        dp[4] = t4;
724
        dp[5] = t5;
725
#ifdef _LITTLE_ENDIAN
726
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
727
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
728
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
729
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
730
        t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
731
        t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
732
#else
733
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
734
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
735
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
736
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
737
        t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
738
        t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
739
#endif /* _LITTLE_ENDIAN */
740
        s0 = sa[0];
741
        dp[6] = t0;
742
        dp[7] = t1;
743
        dp[8] = t2;
744
        dp[9] = t3;
745
        dp[10] = t4;
746
        dp[11] = t5;
747
      }
748

749
#ifdef _LITTLE_ENDIAN
750
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
751
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
752
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
753
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
754
      t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
755
      t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
756
#else
757
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
758
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
759
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
760
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
761
      t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
762
      t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
763
#endif /* _LITTLE_ENDIAN */
764
      dp[0] = t0;
765
      dp[1] = t1;
766
      dp[2] = t2;
767
      dp[3] = t3;
768
      dp[4] = t4;
769
      dp[5] = t5;
770
#ifdef _LITTLE_ENDIAN
771
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
772
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
773
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
774
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
775
      t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
776
      t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
777
#else
778
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
779
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
780
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
781
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
782
      t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
783
      t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
784
#endif /* _LITTLE_ENDIAN */
785
      dp[6] = t0;
786
      dp[7] = t1;
787
      dp[8] = t2;
788
      dp[9] = t3;
789
      dp[10] = t4;
790
      dp[11] = t5;
791
      dp += 12;
792
      sp = (mlib_u8 *) sa;
793
      i += 4;
794

795
      for (; i < size; i++, sp++) {
796
        *dp++ = tab0[sp[0]];
797
        *dp++ = tab1[sp[0]];
798
        *dp++ = tab2[sp[0]];
799
      }
800
    }
801
  }
802
  else if (csize == 4) {
803
    mlib_s32 i, j;
804

805
    for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
806
      mlib_u32 *sa;
807
      mlib_d64 *tab0 = (mlib_d64 *) table[0];
808
      mlib_d64 *tab1 = (mlib_d64 *) table[1];
809
      mlib_d64 *tab2 = (mlib_d64 *) table[2];
810
      mlib_d64 *tab3 = (mlib_d64 *) table[3];
811
      mlib_u32 s0;
812
      mlib_d64 t0, t1, t2, t3;
813
      mlib_s32 off;
814
      mlib_s32 size = xsize;
815
      mlib_d64 *dp = (mlib_d64 *) dst;
816
      mlib_u8 *sp = (void *)src;
817

818
      off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
819

820
      for (i = 0; i < off; i++, sp++) {
821
        *dp++ = tab0[sp[0]];
822
        *dp++ = tab1[sp[0]];
823
        *dp++ = tab2[sp[0]];
824
        *dp++ = tab3[sp[0]];
825
        size--;
826
      }
827

828
      sa = (mlib_u32 *) sp;
829

830
      s0 = sa[0];
831
      sa++;
832

833
      for (i = 0; i < size - 7; i += 4, dp += 16, sa++) {
834
#ifdef _LITTLE_ENDIAN
835
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
836
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
837
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
838
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 << 3) & 0x7F8));
839
#else
840
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
841
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
842
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
843
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 21) & 0x7F8));
844
#endif /* _LITTLE_ENDIAN */
845
        dp[0] = t0;
846
        dp[1] = t1;
847
        dp[2] = t2;
848
        dp[3] = t3;
849
#ifdef _LITTLE_ENDIAN
850
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
851
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
852
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
853
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 5) & 0x7F8));
854
#else
855
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
856
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
857
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
858
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 13) & 0x7F8));
859
#endif /* _LITTLE_ENDIAN */
860
        dp[4] = t0;
861
        dp[5] = t1;
862
        dp[6] = t2;
863
        dp[7] = t3;
864
#ifdef _LITTLE_ENDIAN
865
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
866
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
867
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
868
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 13) & 0x7F8));
869
#else
870
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
871
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
872
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
873
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 5) & 0x7F8));
874
#endif /* _LITTLE_ENDIAN */
875
        dp[8] = t0;
876
        dp[9] = t1;
877
        dp[10] = t2;
878
        dp[11] = t3;
879
#ifdef _LITTLE_ENDIAN
880
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
881
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
882
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
883
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 21) & 0x7F8));
884
#else
885
        t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
886
        t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
887
        t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
888
        t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 << 3) & 0x7F8));
889
#endif /* _LITTLE_ENDIAN */
890
        s0 = sa[0];
891
        dp[12] = t0;
892
        dp[13] = t1;
893
        dp[14] = t2;
894
        dp[15] = t3;
895
      }
896

897
#ifdef _LITTLE_ENDIAN
898
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
899
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
900
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
901
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 << 3) & 0x7F8));
902
#else
903
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
904
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
905
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
906
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 21) & 0x7F8));
907
#endif /* _LITTLE_ENDIAN */
908
      dp[0] = t0;
909
      dp[1] = t1;
910
      dp[2] = t2;
911
      dp[3] = t3;
912
#ifdef _LITTLE_ENDIAN
913
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
914
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
915
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
916
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 5) & 0x7F8));
917
#else
918
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
919
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
920
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
921
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 13) & 0x7F8));
922
#endif /* _LITTLE_ENDIAN */
923
      dp[4] = t0;
924
      dp[5] = t1;
925
      dp[6] = t2;
926
      dp[7] = t3;
927
#ifdef _LITTLE_ENDIAN
928
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
929
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
930
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
931
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 13) & 0x7F8));
932
#else
933
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
934
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
935
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
936
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 5) & 0x7F8));
937
#endif /* _LITTLE_ENDIAN */
938
      dp[8] = t0;
939
      dp[9] = t1;
940
      dp[10] = t2;
941
      dp[11] = t3;
942
#ifdef _LITTLE_ENDIAN
943
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
944
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
945
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
946
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 21) & 0x7F8));
947
#else
948
      t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
949
      t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
950
      t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
951
      t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 << 3) & 0x7F8));
952
#endif /* _LITTLE_ENDIAN */
953
      dp[12] = t0;
954
      dp[13] = t1;
955
      dp[14] = t2;
956
      dp[15] = t3;
957
      dp += 16;
958
      sp = (mlib_u8 *) sa;
959
      i += 4;
960

961
      for (; i < size; i++, sp++) {
962
        *dp++ = tab0[sp[0]];
963
        *dp++ = tab1[sp[0]];
964
        *dp++ = tab2[sp[0]];
965
        *dp++ = tab3[sp[0]];
966
      }
967
    }
968
  }
969
}
970

971
/***************************************************************/
972
void mlib_ImageLookUpSI_S16_D64(const mlib_s16 *src,
973
                                mlib_s32       slb,
974
                                mlib_d64       *dst,
975
                                mlib_s32       dlb,
976
                                mlib_s32       xsize,
977
                                mlib_s32       ysize,
978
                                mlib_s32       csize,
979
                                const mlib_d64 **table)
980
{
981
  const mlib_d64 *table_base[4];
982
  mlib_s32 c;
983

984
  for (c = 0; c < csize; c++) {
985
    table_base[c] = &table[c][32768];
986
  }
987

988
  MLIB_C_IMAGELOOKUPSI(mlib_d64, mlib_s16, table_base);
989
}
990

991
/***************************************************************/
992
void mlib_ImageLookUpSI_U16_D64(const mlib_u16 *src,
993
                                mlib_s32       slb,
994
                                mlib_d64       *dst,
995
                                mlib_s32       dlb,
996
                                mlib_s32       xsize,
997
                                mlib_s32       ysize,
998
                                mlib_s32       csize,
999
                                const mlib_d64 **table)
1000
{
1001
  const mlib_d64 *table_base[4];
1002
  mlib_s32 c;
1003

1004
  for (c = 0; c < csize; c++) {
1005
    table_base[c] = &table[c][0];
1006
  }
1007

1008
  MLIB_C_IMAGELOOKUPSI(mlib_d64, mlib_u16, table_base);
1009
}
1010

1011
/***************************************************************/
1012
void mlib_ImageLookUpSI_S32_D64(const mlib_s32 *src,
1013
                                mlib_s32       slb,
1014
                                mlib_d64       *dst,
1015
                                mlib_s32       dlb,
1016
                                mlib_s32       xsize,
1017
                                mlib_s32       ysize,
1018
                                mlib_s32       csize,
1019
                                const mlib_d64 **table)
1020
{
1021
  const mlib_d64 *table_base[4];
1022
  mlib_u32 shift = TABLE_SHIFT_S32;
1023
  mlib_s32 c;
1024

1025
  for (c = 0; c < csize; c++) {
1026
    table_base[c] = &table[c][shift];
1027
  }
1028

1029
  MLIB_C_IMAGELOOKUPSI(mlib_d64, mlib_s32, table_base);
1030
}
1031

1032
/***************************************************************/
1033

1034
Product

Resources

Company
