1 /*
2 * Copyright (c) 2003, 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_Bit_U8 - table lookup
30 *
31 * SYNOPSIS
32 * void mlib_ImageLookUp_Bit_U8(src, slb,
33 * dst, dlb,
34 * xsize, ysize,
35 * csize, table)
36 *
37 * ARGUMENT
38 * src pointer to input image (BIT)
39 * slb stride of input image (in pixels)
40 * dst pointer to output image (BYTE)
41 * dlb stride of output image (in pixels)
42 * xsize image width
43 * ysize image height
44 * csize number of channels
45 * table lookup table
46 *
47 * DESCRIPTION
48 * dst = table[src] (c, vis version)
49 */
50
51 #include "mlib_image.h"
52 #include "mlib_ImageLookUp.h"
53
54 /***************************************************************/
55 #define MAX_WIDTH 512
56
57 /***************************************************************/
58 #ifdef i386 /* do not copy by double data type for x86 */
59
60 typedef struct {
61 mlib_u32 int0, int1;
62 } two_uint;
63
64 #define TYPE_64BIT two_uint
65 #define TYPE_32BIT mlib_u32
66 #define DTYPE two_uint
67
68 #elif defined(_NO_LONGLONG)
69
70 #define TYPE_64BIT mlib_d64
71 #define TYPE_32BIT mlib_f32
72 #define DTYPE mlib_d64
73
74 #else
75
76 #define TYPE_64BIT mlib_d64
77 #define TYPE_32BIT mlib_f32
78 #define DTYPE mlib_u64
79
80 #endif /* i386 ( do not copy by double data type for x86 ) */
81
82 /***************************************************************/
83 typedef union {
84 TYPE_64BIT d64;
85 struct {
86 TYPE_32BIT f0, f1;
87 } f32s;
88 } d64_2_f32;
89
90 /***************************************************************/
91 #ifdef _LITTLE_ENDIAN
92
93 static const mlib_u32 mlib_bit_mask[16] = {
94 0x00000000u, 0xFF000000u, 0x00FF0000u, 0xFFFF0000u,
95 0x0000FF00u, 0xFF00FF00u, 0x00FFFF00u, 0xFFFFFF00u,
96 0x000000FFu, 0xFF0000FFu, 0x00FF00FFu, 0xFFFF00FFu,
97 0x0000FFFFu, 0xFF00FFFFu, 0x00FFFFFFu, 0xFFFFFFFFu
98 };
99
100 static const mlib_u32 mlib_bit_mask_2[4] = {
101 0x00000000u, 0xFFFF0000u, 0x0000FFFFu, 0xFFFFFFFFu
102 };
103
104 static const mlib_u32 mlib_bit_mask_3[3*4] = {
105 0x00000000u, 0xFF000000u, 0x00FFFFFFu, 0xFFFFFFFFu,
106 0x00000000u, 0xFFFF0000u, 0x0000FFFFu, 0xFFFFFFFFu,
107 0x00000000u, 0xFFFFFF00u, 0x000000FFu, 0xFFFFFFFFu
108 };
109
110 #else
111
112 static const mlib_u32 mlib_bit_mask[16] = {
113 0x00000000u, 0x000000FFu, 0x0000FF00u, 0x0000FFFFu,
114 0x00FF0000u, 0x00FF00FFu, 0x00FFFF00u, 0x00FFFFFFu,
115 0xFF000000u, 0xFF0000FFu, 0xFF00FF00u, 0xFF00FFFFu,
116 0xFFFF0000u, 0xFFFF00FFu, 0xFFFFFF00u, 0xFFFFFFFFu
117 };
118
119 static const mlib_u32 mlib_bit_mask_2[4] = {
120 0x00000000u, 0x0000FFFFu, 0xFFFF0000u, 0xFFFFFFFFu
121 };
122
123 static const mlib_u32 mlib_bit_mask_3[3*4] = {
124 0x00000000u, 0x000000FFu, 0xFFFFFF00u, 0xFFFFFFFFu,
125 0x00000000u, 0x0000FFFFu, 0xFFFF0000u, 0xFFFFFFFFu,
126 0x00000000u, 0x00FFFFFFu, 0xFF000000u, 0xFFFFFFFFu
127 };
128
129 #endif /* _LITTLE_ENDIAN */
130
131 /***************************************************************/
132 mlib_status mlib_ImageLookUp_Bit_U8_1(const mlib_u8 *src,
133 mlib_s32 slb,
134 mlib_u8 *dst,
135 mlib_s32 dlb,
136 mlib_s32 xsize,
137 mlib_s32 ysize,
138 mlib_s32 nchan,
139 mlib_s32 bitoff,
140 const mlib_u8 **table)
141 {
142 mlib_s32 i, j, n;
143 TYPE_64BIT dd_array[256];
144 mlib_u8 buff_lcl[MAX_WIDTH/8];
145 mlib_u8 *buff = (mlib_u8*)buff_lcl;
146 mlib_u32 val0, val1, *p_dd = (mlib_u32*)dd_array;
147
148 if (xsize > MAX_WIDTH) {
149 buff = mlib_malloc((xsize + 7)/8);
150
151 if (buff == NULL) return MLIB_FAILURE;
152 }
153
154 val0 = table[0][0];
155 val1 = table[0][1];
156 val0 |= (val0 << 8);
157 val1 |= (val1 << 8);
158 val0 |= (val0 << 16);
159 val1 |= (val1 << 16);
160
161 /* calculate lookup table */
162 for (i = 0; i < 16; i++) {
163 mlib_u32 v, mask = mlib_bit_mask[i];
164
165 v = (val0 &~ mask) | (val1 & mask);
166
167 for (j = 0; j < 16; j++) {
168 p_dd[2*(16*i + j)] = v;
169 }
170
171 for (j = 0; j < 16; j++) {
172 p_dd[2*(i + 16*j) + 1] = v;
173 }
174 }
175
176 for (j = 0; j < ysize; j++) {
177 mlib_s32 s0, size = xsize;
178 mlib_u8 *dp = dst;
179 mlib_u8 *sp = (void *)src;
180 mlib_u8 *sa;
181 TYPE_64BIT *da;
182 mlib_s32 doff, boff = bitoff;
183
184 if ((mlib_addr)dp & 7) {
185
186 /* result of (dp & 7) certainly fits into mlib_s32 */
187 doff = 8 - ((mlib_s32) ((mlib_addr)dp & 7));
188
189 if (doff > xsize) doff = xsize;
190
191 for (n = 0; n < doff; n++) {
192 dp[n] = table[0][(sp[0] >> (7 - boff)) & 0x1];
193 boff++;
194
195 if (boff >= 8) {
196 sp++;
197 boff -= 8;
198 }
199
200 size--;
201 }
202
203 dp += doff;
204 }
205
206 if (boff) {
207 mlib_ImageCopy_bit_na(sp, buff, size, boff, 0);
208 sp = buff;
209 }
210
211 sa = (mlib_u8*)sp;
212 da = (TYPE_64BIT*)dp;
213 i = 0;
214
215 if ((mlib_addr)sa & 1 && size >= 8) {
216 *da++ = dd_array[*sa++];
217 i += 8;
218 }
219
220 for (; i <= (size - 16); i += 16) {
221 s0 = *(mlib_u16*)sa;
222 #ifdef _LITTLE_ENDIAN
223 *da++ = dd_array[s0 & 0xFF];
224 *da++ = dd_array[s0 >> 8];
225 #else
226 *da++ = dd_array[s0 >> 8];
227 *da++ = dd_array[s0 & 0xFF];
228 #endif /* _LITTLE_ENDIAN */
229 sa += 2;
230 }
231
232 if (i <= (size - 8)) {
233 *da++ = dd_array[*sa++];
234 i += 8;
235 }
236
237 if (i < size) {
238
239 #ifdef _NO_LONGLONG
240
241 mlib_u32 emask;
242 val0 = sa[0];
243 val1 = p_dd[2*val0];
244
245 if (i < (size - 4)) {
246 ((mlib_u32*)da)[0] = val1;
247 da = (TYPE_64BIT *) ((mlib_u8 *)da + 4);
248 i += 4;
249 val1 = p_dd[2*val0+1];
250 }
251
252 #ifdef _LITTLE_ENDIAN
253 emask = (~(mlib_u32)0) >> ((4 - (size - i)) * 8);
254 #else
255 emask = (~(mlib_u32)0) << ((4 - (size - i)) * 8);
256 #endif /* _LITTLE_ENDIAN */
257 ((mlib_u32*)da)[0] = (val1 & emask) | (((mlib_u32*)da)[0] &~ emask);
258
259 #else /* _NO_LONGLONG */
260
261 #ifdef _LITTLE_ENDIAN
262 mlib_u64 emask = (~(mlib_u64)0) >> ((8 - (size - i)) * 8);
263 #else
264 mlib_u64 emask = (~(mlib_u64)0) << ((8 - (size - i)) * 8);
265 #endif /* _LITTLE_ENDIAN */
266
267 ((mlib_u64*)da)[0] = (((mlib_u64*)dd_array)[sa[0]] & emask) | (((mlib_u64*)da)[0] &~ emask);
268
269 #endif /* _NO_LONGLONG */
270 }
271
272 src += slb;
273 dst += dlb;
274 }
275
276 if (buff != (mlib_u8*)buff_lcl) mlib_free(buff);
277
278 return MLIB_SUCCESS;
279 }
280
281 /***************************************************************/
282 mlib_status mlib_ImageLookUp_Bit_U8_2(const mlib_u8 *src,
283 mlib_s32 slb,
284 mlib_u8 *dst,
285 mlib_s32 dlb,
286 mlib_s32 xsize,
287 mlib_s32 ysize,
288 mlib_s32 nchan,
289 mlib_s32 bitoff,
290 const mlib_u8 **table)
291 {
292 mlib_s32 i, j;
293 mlib_s32 s0, size;
294 #ifdef _NO_LONGLONG
295 mlib_u32 emask, dd1, dd2;
296 #else /* _NO_LONGLONG */
297 mlib_u64 emask, dd;
298 #endif /* _NO_LONGLONG */
299 DTYPE dd_array[16];
300 mlib_u32 *p_dd = (mlib_u32*)dd_array;
301 mlib_d64 buff_lcl[(MAX_WIDTH + MAX_WIDTH/8)/8];
302 mlib_u8 *buff = (mlib_u8*)buff_lcl, *buffs;
303 mlib_u32 val0, val1;
304
305 size = xsize * 2;
306
307 if (size > MAX_WIDTH) {
308 buff = mlib_malloc(size + (size + 7)/8);
309
310 if (buff == NULL) return MLIB_FAILURE;
311 }
312
313 buffs = buff + size;
314
315 val0 = table[0][0];
316 val1 = table[0][1];
317 #ifdef _LITTLE_ENDIAN
318 val0 = val0 | (table[1][0] << 8);
319 val1 = val1 | (table[1][1] << 8);
320 #else
321 val0 = (val0 << 8) | table[1][0];
322 val1 = (val1 << 8) | table[1][1];
323 #endif /* _LITTLE_ENDIAN */
324 val0 |= (val0 << 16);
325 val1 |= (val1 << 16);
326
327 /* calculate lookup table */
328 for (i = 0; i < 4; i++) {
329 mlib_u32 v, mask = mlib_bit_mask_2[i];
330
331 v = (val0 &~ mask) | (val1 & mask);
332
333 for (j = 0; j < 4; j++) {
334 p_dd[2*(4*i + j)] = v;
335 p_dd[2*(i + 4*j) + 1] = v;
336 }
337 }
338
339 for (j = 0; j < ysize; j++) {
340 mlib_u8 *dp = dst;
341 mlib_u8 *sp = (void *)src;
342 mlib_u8 *sa;
343 DTYPE *da;
344
345 if ((mlib_addr)dp & 7) dp = buff;
346
347 if (bitoff) {
348 mlib_ImageCopy_bit_na(sp, buffs, size, bitoff, 0);
349 sp = buffs;
350 }
351
352 sa = (mlib_u8*)sp;
353 da = (DTYPE*)dp;
354
355 for (i = 0; i <= (size - 16); i += 16) {
356 s0 = *sa++;
357 *da++ = dd_array[s0 >> 4];
358 *da++ = dd_array[s0 & 0xF];
359 }
360
361 if (i < size) {
362 s0 = *sa++;
363
364 #ifdef _NO_LONGLONG
365
366 dd1 = p_dd[2*(s0 >> 4)];
367 dd2 = p_dd[2*(s0 >> 4)+1];
368
369 if (i < (size - 8)) {
370 ((mlib_u32*)da)[0] = dd1;
371 ((mlib_u32*)da)[1] = dd2;
372 da++;
373 i += 8;
374 dd1 = p_dd[2*(s0 & 0xf)];
375 dd2 = p_dd[2*(s0 & 0xf)+1];
376 }
377
378 if (i < (size - 4)) {
379 ((mlib_u32*)da)[0] = dd1;
380 da = (DTYPE *) ((mlib_u8 *)da + 4);
381 i += 4;
382 dd1 = dd2;
383 }
384
385 #ifdef _LITTLE_ENDIAN
386 emask = (~(mlib_u32)0) >> ((4 - (size - i)) * 8);
387 #else
388 emask = (~(mlib_u32)0) << ((4 - (size - i)) * 8);
389 #endif /* _LITTLE_ENDIAN */
390 ((mlib_u32*)da)[0] = (dd1 & emask) | (((mlib_u32*)da)[0] &~ emask);
391
392 #else /* _NO_LONGLONG */
393
394 dd = ((mlib_u64*)dd_array)[s0 >> 4];
395
396 if (i < (size - 8)) {
397 ((mlib_u64*)da)[0] = dd;
398 da++;
399 i += 8;
400 dd = ((mlib_u64*)dd_array)[s0 & 0xf];
401 }
402
403 #ifdef _LITTLE_ENDIAN
404 emask = (~(mlib_u64)0) >> ((8 - (size - i)) * 8);
405 #else
406 emask = (~(mlib_u64)0) << ((8 - (size - i)) * 8);
407 #endif /* _LITTLE_ENDIAN */
408 ((mlib_u64*)da)[0] = (dd & emask) | (((mlib_u64*)da)[0] &~ emask);
409
410 #endif /* _NO_LONGLONG */
411 }
412
413 if (dp != dst) mlib_ImageCopy_na(dp, dst, size);
414
415 src += slb;
416 dst += dlb;
417 }
418
419 if (buff != (mlib_u8*)buff_lcl) mlib_free(buff);
420
421 return MLIB_SUCCESS;
422 }
423
424 /***************************************************************/
425 mlib_status mlib_ImageLookUp_Bit_U8_3(const mlib_u8 *src,
426 mlib_s32 slb,
427 mlib_u8 *dst,
428 mlib_s32 dlb,
429 mlib_s32 xsize,
430 mlib_s32 ysize,
431 mlib_s32 nchan,
432 mlib_s32 bitoff,
433 const mlib_u8 **table)
434 {
435 mlib_s32 i, j;
436 mlib_s32 s0, size;
437 mlib_u32 emask, dd;
438 TYPE_64BIT d_array01[16], d_array12[16];
439 TYPE_64BIT buff_lcl[(MAX_WIDTH + MAX_WIDTH/8)/8];
440 mlib_u8 *buff = (mlib_u8*)buff_lcl, *buffs;
441 mlib_u32 l0, h0, v0, l1, h1, v1, l2, h2, v2;
442
443 size = 3 * xsize;
444
445 if (size > MAX_WIDTH) {
446 buff = mlib_malloc(size + (size + 7)/8);
447
448 if (buff == NULL) return MLIB_FAILURE;
449 }
450
451 buffs = buff + size;
452
453 #ifdef _LITTLE_ENDIAN
454 l0 = (table[0][0] << 24) | (table[2][0] << 16) | (table[1][0] << 8) | (table[0][0]);
455 h0 = (table[0][1] << 24) | (table[2][1] << 16) | (table[1][1] << 8) | (table[0][1]);
456 l1 = (l0 >> 8); l1 |= (l1 << 24);
457 h1 = (h0 >> 8); h1 |= (h1 << 24);
458 l2 = (l1 >> 8); l2 |= (l2 << 24);
459 h2 = (h1 >> 8); h2 |= (h2 << 24);
460 #else
461 l0 = (table[0][0] << 24) | (table[1][0] << 16) | (table[2][0] << 8) | (table[0][0]);
462 h0 = (table[0][1] << 24) | (table[1][1] << 16) | (table[2][1] << 8) | (table[0][1]);
463 l1 = (l0 << 8); l1 |= (l1 >> 24);
464 h1 = (h0 << 8); h1 |= (h1 >> 24);
465 l2 = (l1 << 8); l2 |= (l2 >> 24);
466 h2 = (h1 << 8); h2 |= (h2 >> 24);
467 #endif /* _LITTLE_ENDIAN */
468
469 /* calculate lookup table */
470 for (i = 0; i < 16; i++) {
471 mlib_u32 mask0 = mlib_bit_mask_3[i >> 2];
472 mlib_u32 mask1 = mlib_bit_mask_3[4 + ((i >> 1) & 3)];
473 mlib_u32 mask2 = mlib_bit_mask_3[8 + (i & 3)];
474
475 v0 = (l0 &~ mask0) | (h0 & mask0);
476 v1 = (l1 &~ mask1) | (h1 & mask1);
477 v2 = (l2 &~ mask2) | (h2 & mask2);
478
479 ((mlib_u32*)d_array01)[2*i ] = v0;
480 ((mlib_u32*)d_array01)[2*i + 1] = v1;
481 ((mlib_u32*)d_array12)[2*i ] = v1;
482 ((mlib_u32*)d_array12)[2*i + 1] = v2;
483 }
484
485 for (j = 0; j < ysize; j++) {
486 mlib_u8 *dp = dst;
487 mlib_u8 *sp = (void *)src;
488 mlib_u8 *sa;
489 mlib_u32 *da;
490
491 if ((mlib_addr)dp & 7) dp = buff;
492
493 if (bitoff) {
494 mlib_ImageCopy_bit_na(sp, buffs, size, bitoff, 0);
495 sp = buffs;
496 }
497
498 sa = (mlib_u8*)sp;
499 da = (mlib_u32*)dp;
500
501 for (i = 0; i <= (size - 24); i += 24) {
502 d64_2_f32 dd;
503 s0 = *sa++;
504
505 ((TYPE_64BIT*)da)[0] = *(d_array01 + (s0 >> 4));
506
507 dd.f32s.f0 = ((TYPE_32BIT*)(d_array12 + (s0 >> 4)))[1];
508 dd.f32s.f1 = ((TYPE_32BIT*)(d_array01 + (s0 & 0xF)))[0];
509 ((TYPE_64BIT*)da)[1] = dd.d64;
510 ((TYPE_64BIT*)da)[2] = *(d_array12 + (s0 & 0xF));
511
512 da += 6;
513 }
514
515 if (i < size) {
516 s0 = *sa++;
517 dd = ((mlib_u32*)(d_array01 + (s0 >> 4)))[0];
518
519 if (i < (size - 4)) {
520 *da++ = dd;
521 i += 4;
522 dd = ((mlib_u32*)(d_array12 + (s0 >> 4)))[0];
523 }
524
525 if (i < (size - 4)) {
526 *da++ = dd;
527 i += 4;
528 dd = ((mlib_u32*)(d_array12 + (s0 >> 4)))[1];
529 }
530
531 if (i < (size - 4)) {
532 *da++ = dd;
533 i += 4;
534 dd = ((mlib_u32*)(d_array01 + (s0 & 0xF)))[0];
535 }
536
537 if (i < (size - 4)) {
538 *da++ = dd;
539 i += 4;
540 dd = ((mlib_u32*)(d_array12 + (s0 & 0xF)))[0];
541 }
542
543 if (i < (size - 4)) {
544 *da++ = dd;
545 i += 4;
546 dd = ((mlib_u32*)(d_array12 + (s0 & 0xF)))[1];
547 }
548
549 #ifdef _LITTLE_ENDIAN
550 emask = (~(mlib_u32)0) >> ((4 - (size - i)) * 8);
551 #else
552 emask = (~(mlib_u32)0) << ((4 - (size - i)) * 8);
553 #endif /* _LITTLE_ENDIAN */
554 da[0] = (dd & emask) | (da[0] &~ emask);
555 }
556
557 if (dp != dst) mlib_ImageCopy_na(dp, dst, size);
558
559 src += slb;
560 dst += dlb;
561 }
562
563 if (buff != (mlib_u8*)buff_lcl) mlib_free(buff);
564
565 return MLIB_SUCCESS;
566 }
567
568 /***************************************************************/
569 mlib_status mlib_ImageLookUp_Bit_U8_4(const mlib_u8 *src,
570 mlib_s32 slb,
571 mlib_u8 *dst,
572 mlib_s32 dlb,
573 mlib_s32 xsize,
574 mlib_s32 ysize,
575 mlib_s32 nchan,
576 mlib_s32 bitoff,
577 const mlib_u8 **table)
578 {
579 mlib_s32 i, j;
580 mlib_s32 s0, size;
581 DTYPE dd_array0[16], dd_array1[16], lh[4], dd;
582 mlib_d64 buff_lcl[(MAX_WIDTH + MAX_WIDTH/8)/8];
583 mlib_u8 *buff = (mlib_u8*)buff_lcl, *buffs;
584 mlib_u32 l, h;
585
586 size = xsize * 4;
587
588 if (size > MAX_WIDTH) {
589 buff = mlib_malloc(size + (size + 7)/8);
590
591 if (buff == NULL) return MLIB_FAILURE;
592 }
593
594 buffs = buff + size;
595
596 #ifdef _LITTLE_ENDIAN
597 l = (table[3][0] << 24) | (table[2][0] << 16) | (table[1][0] << 8) | (table[0][0]);
598 h = (table[3][1] << 24) | (table[2][1] << 16) | (table[1][1] << 8) | (table[0][1]);
599 #else
600 l = (table[0][0] << 24) | (table[1][0] << 16) | (table[2][0] << 8) | (table[3][0]);
601 h = (table[0][1] << 24) | (table[1][1] << 16) | (table[2][1] << 8) | (table[3][1]);
602 #endif /* _LITTLE_ENDIAN */
603
604 ((mlib_u32*)lh)[0] = l; ((mlib_u32*)lh)[1] = l;
605 ((mlib_u32*)lh)[2] = l; ((mlib_u32*)lh)[3] = h;
606 ((mlib_u32*)lh)[4] = h; ((mlib_u32*)lh)[5] = l;
607 ((mlib_u32*)lh)[6] = h; ((mlib_u32*)lh)[7] = h;
608
609 /* calculate lookup table */
610 dd_array0[ 0] = lh[0]; dd_array1[ 0] = lh[0];
611 dd_array0[ 1] = lh[0]; dd_array1[ 1] = lh[1];
612 dd_array0[ 2] = lh[0]; dd_array1[ 2] = lh[2];
613 dd_array0[ 3] = lh[0]; dd_array1[ 3] = lh[3];
614 dd_array0[ 4] = lh[1]; dd_array1[ 4] = lh[0];
615 dd_array0[ 5] = lh[1]; dd_array1[ 5] = lh[1];
616 dd_array0[ 6] = lh[1]; dd_array1[ 6] = lh[2];
617 dd_array0[ 7] = lh[1]; dd_array1[ 7] = lh[3];
618 dd_array0[ 8] = lh[2]; dd_array1[ 8] = lh[0];
619 dd_array0[ 9] = lh[2]; dd_array1[ 9] = lh[1];
620 dd_array0[10] = lh[2]; dd_array1[10] = lh[2];
621 dd_array0[11] = lh[2]; dd_array1[11] = lh[3];
622 dd_array0[12] = lh[3]; dd_array1[12] = lh[0];
623 dd_array0[13] = lh[3]; dd_array1[13] = lh[1];
624 dd_array0[14] = lh[3]; dd_array1[14] = lh[2];
625 dd_array0[15] = lh[3]; dd_array1[15] = lh[3];
626
627 for (j = 0; j < ysize; j++) {
628 mlib_u8 *dp = dst;
629 mlib_u8 *sp = (void *)src;
630 mlib_u8 *sa;
631 DTYPE *da;
632
633 if ((mlib_addr)dp & 7) dp = buff;
634
635 if (bitoff) {
636 mlib_ImageCopy_bit_na(sp, buffs, size, bitoff, 0);
637 sp = buffs;
638 }
639
640 sa = (mlib_u8*)sp;
641 da = (DTYPE*)dp;
642
643 for (i = 0; i <= (size - 32); i += 32) {
644 s0 = *sa++;
645 *da++ = dd_array0[s0 >> 4];
646 *da++ = dd_array1[s0 >> 4];
647 *da++ = dd_array0[s0 & 0xF];
648 *da++ = dd_array1[s0 & 0xF];
649 }
650
651 if (i < size) {
652 s0 = *sa++;
653 dd = dd_array0[s0 >> 4];
654
655 if (i <= (size - 8)) {
656 *da++ = dd;
657 i += 8;
658 dd = dd_array1[s0 >> 4];
659 }
660
661 if (i <= (size - 8)) {
662 *da++ = dd;
663 i += 8;
664 dd = dd_array0[s0 & 0xF];
665 }
666
667 if (i <= (size - 8)) {
668 *da++ = dd;
669 i += 8;
670 dd = dd_array1[s0 & 0xF];
671 }
672
673 if (i < size) {
674 *(mlib_u32*)da = *(mlib_u32*) & dd;
675 }
676 }
677
678 if (dp != dst) mlib_ImageCopy_na(dp, dst, size);
679
680 src += slb;
681 dst += dlb;
682 }
683
684 if (buff != (mlib_u8*)buff_lcl) mlib_free(buff);
685
686 return MLIB_SUCCESS;
687 }
688
689 /***************************************************************/